通过Java中的三种不同方式，初始化对象有什么用？

Question

I am working with Java as beginner i was following a tutorial ( http://www.javatpoint.com/object-and-class-in-java ) which states that there are three different way through which one can initialize an object into java.

1. By reference variable
2. By method
3. By constructor

My Question is that what is the significance of using three different method for a single task.

Example: 1) Object and Class Example: Initialization through reference

 class Student{  
     int id;  
     String name;  
    }  
    class TestStudent2{  
     public static void main(String args[]){  
      Student s1=new Student();  
      s1.id=101;  
      s1.name="Sonoo";  
      System.out.println(s1.id+" "+s1.name);//printing members with a white space  
     }  
    }  

2) Object and Class Example: Initialization through method

    class Student{  
     int rollno;  
     String name;  
     void insertRecord(int r, String n){  
      rollno=r;  
      name=n;  
     }  
     void displayInformation(){System.out.println(rollno+" "+name);}  
    }  
    class TestStudent4{  
     public static void main(String args[]){  
      Student s1=new Student();  
      Student s2=new Student();  
      s1.insertRecord(111,"Karan");  
      s2.insertRecord(222,"Aryan");  
      s1.displayInformation();  
      s2.displayInformation();  
     }  
    } 

3) Object and Class Example: Initialization through constructor

class Employee{  
        int id;  
        String name;  
        float salary;  
        void insert(int i, String n, float s) {  
            id=i;  
            name=n;  
            salary=s;  
        }  
        void display(){System.out.println(id+" "+name+" "+salary);}  
    }  
    public class TestEmployee {  
    public static void main(String[] args) {  
        Employee e1=new Employee();  
        Employee e2=new Employee();  
        Employee e3=new Employee();  
        e1.insert(101,"ajeet",45000);  
        e2.insert(102,"irfan",25000);  
        e3.insert(103,"nakul",55000);  
        e1.display();  
        e2.display();  
        e3.display();  
    }  
    } 

Answer 1

What is the significance of using three different method for a single task.

It's the same significance as any task in software development: there are often multiple ways of writing code that would result in the same eventual state, and so we consider which one of these is most appropriate. Arguably (IMHO), this is the real skill of development: not simply being able to make the computer do a particular thing, but writing code to do that thing that is as simple/clean/understandable/extensible as it possibly can be.

In this specific case, I would strongly recommend initialising the fields through the constructor. Sometimes it makes sense for an object's fields to be mutable, and to be initialised after the object is created (as in cases 1 and 2). But in most cases - and especially here with "id" fields that define the object itself - it is clearest if the object is constructed with those fields. This way there's no point where the object is in an invalid state; it's impossible to create an Employee object that has no id .

Note that what you've pasted for example 3 is not an example of constructor initialisation! Read the page carefully, they say they will cover this later. The code you've pasted is unrelated.

I would do something like the following:

class Student{  
  final int id;  
  final String name;  

  // This is the constructor that will initialise the fields with what's passed in
  // (Note that because the fields are final, they MUST be set by the constructor)
  public Student(int id, String name) {
    this.id = id;
    this.name = name;
  }
}

class TestStudent6 {  
  public static void main(String args[]){  
    Student s1 = new Student(101, "Sonoo");  
    System.out.println(s1.id + " " + s1.name); //printing members with a white space  
  }  
}  

(Note that I'd probably also make the id and name fields private and set up getId() and getName() methods to access them instead, but that's outside the scope of what you asked.)

Answer 2

Objects have state and its internal to it, hence it should be best made hidden from the outside ie not accessible to outside classes. There will be other classes which may be dependent upon the object. Ideally these external classes should depend upon the public methods to modify or read the state. Hiding the internal details (states) and exposing only the needed methods is a good idea.

Now we have our fields encapsulated so in brief see initilization using constructor vs setters. If a class is composed of few fields without which an object of that class do not make sense, like a MovingCar is composed of wheels , so if there is a field wheels then it must be initilized along with the creation of object of MovingCar . These fields better are initilized through Constructors. The other fields such as musicSystem may be initilized using setter methods.

Sometimes we may end up with so many constructors (overloaded) which may make it confusing for the users of such a class. Methods are better which can be named to let the users know the intention. Even better aaproach in such a case is builder pattern .