Comment créer des objets en Java

Comment créer un objet en Java : 1. Utilisez le mot-clé new ; 2. Utilisez la méthode newInstance de la classe Class pour appeler le constructeur sans paramètre pour créer un objet ; classe ; 4. Utiliser la méthode de clonage ; 5. Utiliser la désérialisation.

L'environnement d'exploitation de ce tutoriel : système Windows 7, version Java 8, ordinateur DELL G3.

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

使用new关键字	} → 调用了构造函数
使用Class类的newInstance方法	} → 调用了构造函数
使用Constructor类的newInstance方法	} → 调用了构造函数
使用clone方法	} → 没有调用构造函数
使用反序列化	} → 没有调用构造函数

Si vous exécutez le programme à la fin, vous trouverez les méthodes 1, 2, et 3 utilisent des constructeurs pour créer des objets, et 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 classe Class pour créer des objets. Cette méthode newInstance appelle le constructeur sans paramètre pour créer l'objet.

On peut créer des objets en appelant la méthode newInstance de la manière suivante :

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

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

3 Utilisez la méthode newInstance de la classe Constructor

et. la méthode newInstance de la classe Class Tout comme la classe java.lang.reflect.Constructor, il existe également une méthode newInstance 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;

Ces deux méthodes newInstance sont ce que tout le monde appelle la réflexion. En fait, la méthode newInstance de Class appelle en interne la méthode newInstance de Constructor. C’est aussi la raison pour laquelle de nombreux frameworks, comme Spring, Hibernate, Struts, etc. utilisent ce dernier. Pour comprendre la différence entre les deux méthodes newInstance, veuillez lire cet article Création d'objets via Reflection en Java avec exemple.

4 Utilisez la méthode clone

chaque fois que nous Quand. la méthode clone d'un objet est appelée, le 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;

Comme nous pouvons le voir dans le fragment de bytecode ci-dessus, à l'exception de la première méthode, les 4 autres méthodes sont toutes converties Pour Ensurevirtual (une méthode directe de création d'un objet), la première méthode se transforme en deux appels, new et Ensurespecial (un appel de 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 utiliserons 5 méthode pour créer un objet Employee. 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 :

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

Tutoriels vidéo associés recommandés : Tutoriel vidéo Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!