5 Möglichkeiten, Objekte in Java zu erstellen

Als Java-Entwickler erstellen wir jeden Tag viele Objekte, verwenden jedoch normalerweise Abhängigkeitsmanagementsysteme wie Spring, um Objekte zu erstellen. Es gibt jedoch viele Möglichkeiten, Objekte zu erstellen, die wir in diesem Artikel kennenlernen werden.

Es gibt 5 Möglichkeiten, Objekte in Java zu erstellen. Ihre Beispiele und ihre Bytecodes sind unten aufgeführt

Wenn Sie Wenn Sie das Programm am Ende ausführen, werden Sie feststellen, dass die Methoden 1, 2 und 3 Konstruktoren zum Erstellen von Objekten verwenden und die Methoden 4 und 5 keine Konstruktoren aufrufen.

1. Verwenden Sie das neue Schlüsselwort

Dies ist die gebräuchlichste und einfachste Möglichkeit, Objekte zu erstellen. Auf diese Weise können wir jeden Konstruktor (parameterlos und parametrisiert) aufrufen.

Employee emp1 = new Employee();

0: new           #19          // class org/programming/mitra/exercises/Employee
3: dup   
4: invokespecial #21          // Method org/programming/mitra/exercises/Employee."":()V

2. Verwenden Sie die newInstance-Methode der Class-Klasse

Wir können auch die newInstance-Methode der Klasse verwenden Klasse zum Erstellen von Objekten. Diese newInstance-Methode ruft den parameterlosen Konstruktor auf, um das Objekt zu erstellen.

Wir können Objekte erstellen, indem wir die newInstance-Methode auf folgende Weise aufrufen:

Employee emp2 = (Employee) 
Class.forName("org.programming.mitra.exercises.Employee").newInstance();

oder

Employee emp2 = Employee.class.newInstance();

51: invokevirtual    #70    // Method java/lang/Class.newInstance:()Ljava/lang/Object;

3. Verwenden Sie die newInstance Methode der Constructor-Klasse

Ähnlich wie die newInstance-Methode der Class-Klasse gibt es auch in der java.lang.reflect.Constructor-Klasse eine newInstance-Methode zum Erstellen von Objekten. Über diese newInstance-Methode können wir parametrisierte und private Konstruktoren aufrufen.

Constructor<Employee> constructor = Employee.class.getConstructor();
Employee emp3 = constructor.newInstance();

111: invokevirtual  #80  // Method java/lang/reflect/Constructor.newInstance:([Ljava/lang/Object;)Ljava/lang/Object;

Die newInstance-Methode ruft intern die newInstance-Methode des Konstruktors auf. Dies ist auch der Grund, warum viele Frameworks wie Spring, Hibernate, Struts usw. Letzteres verwenden.

4. Verwenden Sie die Klonmethode

Immer wenn wir die Klonmethode eines Objekts aufrufen, erstellt der JVM ein neues Objekt und kopiert den gesamten Inhalt des vorherigen Objekts hinein. Beim Erstellen eines Objekts mit der Klonmethode wird kein Konstruktor aufgerufen.

Um die Klonmethode verwenden zu können, müssen wir zunächst die Cloneable-Schnittstelle und die zugehörige Klonmethode implementieren.

Employee emp4 = (Employee) emp3.clone();’

162: invokevirtual #87  // Method org/programming/mitra/exercises/Employee.clone ()Ljava/lang/Object;

5. Deserialisierung verwenden

Wenn wir ein Objekt serialisieren und deserialisieren, erstellt jvm ein separates Objekt für uns. Während der Deserialisierung erstellt der JVM das Objekt und ruft keinen Konstruktor auf.

Um ein Objekt zu deserialisieren, müssen wir unsere Klasse dazu bringen, die Serializable-Schnittstelle zu implementieren.

ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));
Employee emp5 = (Employee) in.readObject();

261: invokevirtual  #118   
// Method java/io/ObjectInputStream.readObject:()Ljava/lang/Object;

Aus dem obigen Bytecode-Fragment können wir ersehen, dass mit Ausnahme der ersten Methode alle anderen vier Methoden in invokevirtual (direkte Methode zum Erstellen eines Objekts) umgewandelt werden zwei Aufrufe, new und invokespecial (Konstruktoraufruf).

Beispiel

Lassen Sie uns einen Blick auf die Erstellung von Objekten für die folgende Employee-Klasse werfen:

class Employee implements Cloneable, Serializable {   
    private static final long serialVersionUID = 1L;   
    private String name;   
    public Employee() {   
        System.out.println("Employee Constructor Called...");   
    }   
    public String getName() {   
        return name;   
    }   
    public void setName(String name) {   
        this.name = name;   
    }   
    @Override   
    public int hashCode() {   
        final int prime = 31;   
        int result = 1;   
        result = prime * result + ((name == null) ? 0 : name.hashCode());   
        return result;   
    }   
    @Override   
    public boolean equals(Object obj) {   
        if (this == obj)   
            return true;   
        if (obj == null)   
            return false;   
        if (getClass() != obj.getClass())   
            return false;   
        Employee other = (Employee) obj;   
        if (name == null) {   
            if (other.name != null)   
                return false;   
        } else if (!name.equals(other.name))   
            return false;   
        return true;   
    }   
    @Override   
    public String toString() {   
        return "Employee [name=" + name + "]";   
    }   
    @Override   
    public Object clone() {   
        Object obj = null;   
        try {   
            obj = super.clone();   
        } catch (CloneNotSupportedException e) {   
            e.printStackTrace();   
        }   
        return obj;   
    }   
}

Im folgenden Java-Programm erstellen wir Employee-Objekte auf fünf Arten . Den Code finden Sie auf GitHub.

public class ObjectCreation {   
    public static void main(String... args) throws Exception {   
        // By using new keyword   
        Employee emp1 = new Employee();   
        emp1.setName("Naresh");   
        System.out.println(emp1 + ", hashcode : " + emp1.hashCode());   
        // By using Class class's newInstance() method   
        Employee emp2 = (Employee) Class.forName("org.programming.mitra.exercises.Employee")   
                               .newInstance();   
        // Or we can simply do this   
        // Employee emp2 = Employee.class.newInstance();   
        emp2.setName("Rishi");   
        System.out.println(emp2 + ", hashcode : " + emp2.hashCode());   
        // By using Constructor class's newInstance() method   
        Constructor<Employee> constructor = Employee.class.getConstructor();   
        Employee emp3 = constructor.newInstance();   
        emp3.setName("Yogesh");   
        System.out.println(emp3 + ", hashcode : " + emp3.hashCode());   
        // By using clone() method   
        Employee emp4 = (Employee) emp3.clone();   
        emp4.setName("Atul");   
        System.out.println(emp4 + ", hashcode : " + emp4.hashCode());   
        // By using Deserialization   
        // Serialization   
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("data.obj"));   
        out.writeObject(emp4);   
        out.close();   
        //Deserialization   
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("data.obj"));   
        Employee emp5 = (Employee) in.readObject();   
        in.close();   
        emp5.setName("Akash");   
        System.out.println(emp5 + ", hashcode : " + emp5.hashCode());   
    }   
}

Das Programm gibt Folgendes aus:

public class ObjectCreation {   
Employee Constructor Called...   
Employee [name=Naresh], hashcode : -1968815046   
Employee Constructor Called...   
Employee [name=Rishi], hashcode : 78970652   
Employee Constructor Called...   
Employee [name=Yogesh], hashcode : -1641292792   
Employee [name=Atul], hashcode : 2051657   
Employee [name=Akash], hashcode : 63313419

Die oben genannten 5 Möglichkeiten zum Erstellen von Objekten in Java finden Sie auf der chinesischen PHP-Website (www .php.cn )!