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

Cet article présente principalement un résumé des 5 façons de créer des objets en Java. L'éditeur pense que c'est plutôt bien, je vais donc le partager avec vous maintenant et le donner comme référence. Suivons l'éditeur et jetons un coup d'œil

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方法	} → 没有调用构造函数
使用反序列化	} → 没有调用构造函数

Développé en Java Habituellement, nous créons plusieurs objets tous les jours, 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 trouverez les méthodes 1, 2 et 3 qui utilisent le constructeur pour créer des objets, et les méthodes 4 et 5 n'appellent pas le constructeur.

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

est très similaire à 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;

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. Vous voulez comprendre la différence entre les deux méthodes newInstance,

4. Utilisez la méthode clone

Chaque fois que nous appelons la méthode clone d'un objet, le jvm créera un nouvel objet, copiez-y 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. Utilisation de la désérialisation

Lorsque nous sérialisons et désérialisons un objet, jvm crée un objet séparé. objet 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 partons de ci-dessus Comme le montre le fragment de bytecode, à l'exception de la première méthode, les quatre autres méthodes sont toutes converties en invoqué virtuel (méthode directe de création d'un objet), et la première méthode est convertie en deux appels, new et invoqué spécial (appel du constructeur ).

Exemple

Jetons un coup d'œil à la création d'un objet pour la classe Employé 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 Employé de 5 manières.

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

Ce qui précède est le contenu de cet article Tout le contenu, j'espère qu'il sera utile à l'apprentissage de chacun, et j'espère aussi que tout le monde soutiendra le site Web PHP chinois.

Pour plus de résumé des 5 façons de créer des objets en Java et des articles connexes, veuillez faire attention au site Web PHP chinois !