3

Can someone tell me what is the need to declare a class like this:

public class Test {

 String k;
 public Test(String a, String b, String c){
  k = a + " " + b + " " + c; //do something

 }

 public void run(){
  System.out.println(k);
 }

 public static void main(String[] args) {
  String l = args[0];
  String m = args[1];
  String n = args[2];
  Test obj = new Test(l,m,n);
  obj.run();
 }

}

Of course it works but I don't get the point why would one use such way to implement something. Is it because we need to pass arguments directly to the class main method that is why we use this way or is there some other reason?

What is the purpose of public Test(...) using the same class name. Why is it like this?

Improve this question
5
  • 2
    This won't compile at all Test obj = new file(l,m,n); Commented Nov 22, 2010 at 15:49
  • 1
    Makes no sense. Test obj = new file(l,m,n); - does not even compile. Commented Nov 22, 2010 at 15:50
  • Correct indentation? ;p Test obj = new file(l,m,n); should be Test obj = new Test(l,m,n); Commented Nov 22, 2010 at 15:50
  • 1
    are you asking why we need a main method? Are you asking why there are classes? Your question is unclear.. Commented Nov 22, 2010 at 15:51
  • 1
    I'm not sure I understand what you're really asking, please clarify. Commented Nov 22, 2010 at 15:52

5 Answers 5

Reset to default
7

The public Test(...) is a constructor and its purpose is for object creation. This is clearly seen from the sample code...

Test obj = new Test(l,m,n);

The variable obj is instantiated with object Test by being assigned to the Test's constructor. In java, every constructor must have the exact same name (and case) as the java file it's written in (In your case constructor Test is found in Test.java).

...Why is it like this?

It all depends on what you want to do with your object. You could have a zero-argument constructor (i.e. requires no parameters) and have methods to set your l, m, n, like so:

package net;


public class Test {

    private String k;

    /**
     * 
     */
    public Test() {
        super();
        // TODO Auto-generated constructor stub
    }

    public void set(String a, String b, String c) {
         k = a + " " + b + " " + c; //do something
    }

    public void run() {
        System.out.println(k);
    }

    public static void main(String[] args) {
        String l = args[0];
        String m = args[1];
        String n = args[2];
        Test obj = new Test();
        obj.set(l, m, n);
        obj.run();
    }
}

As you can see, it's exactly the same feature as your example but with a zero-argument constructor.

If your class has no constructor at all, java adds a public zero-argument constructor for you automatically.

Hope this helps.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Thanks, your example says it all.
3

The method called Test is a so-called constructor for the Test class. The constructor is the method that gets called when you write something like new Test(...).

Bear in mind that the main method is a static method, which means that it does not require an instance of the class Test to be called. This is not the case for the run method. run is an instance method, and to invoke it you need an instance of the Test class (the obj in your case).

Improve this answer

2 Comments

thanks Klaus, but Im just wondering why would one use this approach when a simple class like below can accomplish the task: public class Test{ static String k=""; public static void run(){ System.out.println(k); } public static void main(String[] args) { String l = args[0]; String m = args[1]; String n = args[2]; k = l+m+n; run(); } }
@Rizwan, there are many ways to accomplish the same thing in programming. Why someone would choose to do it like that could either be because of personal preference, because it's the only way they know, etc. For a program like that, that has no real value, I don't think it's important to discuss which approach is best.
1

The public Test(...) bit is the constructor of that class. It always has the same name as the class. Classes and main methods are two quite different aspects of programming. Classes define reusable components that have both state and methods. The main method is a special method that gets called from the command line.

Your example is so trivial that it doesnt really show any benefits of Object Orientated Programming. If you consider an example where you had different Classes intetracting you might get more of a feel for it.

Improve this answer

Comments

0

The main method is the entry point for the program and is called when you run java Test from the command line.

public Test(String a, String b, String c) is a public constructor for the Test class and is called when you call new Test(l,m,n); Note that a in the constructor and l in main method refer to the same String... this also applies to b and m; c and n.

As a side note, this class expects to be passed three values from the command line, and then stores them in l, m, and n

One last note: If you have a method with the signature public void run(), your class should likely implement Runnable so that it can be used in a Thread.

Improve this answer

Comments

-2

Learn Java.

A constructor is a function that gets called to create an object, and it's denoted by a function with the same name as the class, but no return type. Multiple constructors can be declared with different arguments.

In this case, the arguments are taken out of the argument array and passed as arguments to the constructor for Test.

These are fundamentally basic concepts to the Java programming language. You should read up on Java. Try Thinking in Java, this is a great book to get started.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.