5 façons de créer des objets en Java

En tant que développeurs Java, nous créons de nombreux objets chaque jour, mais nous utilisons généralement des systèmes de gestion des dépendances, tels que Spring, pour créer des objets. Cependant il existe de nombreuses façons de créer des objets, que nous allons découvrir dans cet article.

Il existe 5 façons de créer des objets en Java. Leurs exemples et leurs bytecodes sont donnés ci-dessous

Si vous exécutez le programme à la fin, vous constaterez que les méthodes 1, 2 et 3 utilisent des constructeurs pour créer des objets et que les méthodes 4 et 5 n'appellent pas de constructeurs.

1. Utilisez le nouveau mot-clé

C'est la manière la plus courante et la plus simple de créer des objets. De cette façon, nous pouvons appeler n'importe quel constructeur (sans paramètre et paramétré).

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. Utilisez la méthode newInstance de la classe Class

Nous pouvons également utiliser la méthode newInstance de la Class classe pour créer des objets. Cette méthode newInstance appelle le constructeur sans paramètre pour créer l'objet.

Nous pouvons créer des objets en appelant la méthode newInstance des manières suivantes :

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

ou

Employee emp2 = Employee.class.newInstance();

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

3. Utilisez la newInstance méthode de la classe Constructor

Semblable à la méthode newInstance de la classe Class, il existe également une méthode newInstance dans la classe java.lang.reflect.Constructor pour créer des objets. Nous pouvons appeler des constructeurs paramétrés et privés via cette méthode newInstance.

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;

La méthode newInstance appelle en interne la méthode newInstance du Constructeur. C’est aussi la raison pour laquelle de nombreux frameworks, comme Spring, Hibernate, Struts, etc., utilisent ce dernier.

4. Utilisez la méthode clone

Chaque fois que nous appelons la méthode clone d'un objet, la jvm créera un nouvel objet et y copiera tout le contenu de l'objet précédent. La création d'un objet à l'aide de la méthode clone n'appelle aucun constructeur.

Pour utiliser la méthode clone, nous devons d'abord implémenter l'interface Cloneable et implémenter sa méthode de clonage définie.

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

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

5. Utiliser la désérialisation

Lorsque nous sérialisons et désérialisons un objet, jvm créera un objet séparé pour nous. Lors de la désérialisation, la jvm crée l'objet et n'appelle aucun constructeur.

Afin de désérialiser un objet, nous devons faire en sorte que notre classe implémente l'interface Serialisable.

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

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

Nous pouvons voir à partir du fragment de bytecode ci-dessus qu'à l'exception de la première méthode, les quatre autres méthodes sont toutes converties en Invokevirtual (méthode directe de création d'objet transformée en). deux appels, new et Ensurespecial (appel du constructeur).

Exemple

Jetons un coup d'œil à la création d'objets pour la classe Employee suivante :

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;   
    }   
}

Dans le programme Java suivant, nous allons créer des objets Employee de 5 manières . Vous pouvez trouver le code sur 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());   
    }   
}

Le programme affichera :

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

Voici les 5 façons de créer des objets en Java. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www. .php.cn ) !