Introduction aux différences entre la méthode newInstance() et le mot-clé new en Java

Cet article présente principalement des informations pertinentes sur la différence entre la méthode newInstance() et le mot-clé new en Java. J'espère qu'à travers cet article, vous pourrez maîtriser la différence et l'utilisation de leurs maisons. Les amis dans le besoin pourront s'y référer. 🎜>

La différence entre la méthode newInstance() et le mot-clé new en java

* La différence réside dans la façon dont ils créent des objets. tandis que ce dernier crée un nouveau type d'objet.

* Alors pourquoi y a-t-il deux manières de créer des objets ? Cela prend principalement en compte les idées de conception logicielle telles que l'évolutivité, l'extensibilité et la réutilisabilité du logiciel.
* Lorsque nous utilisons le mot-clé new pour créer une classe, la classe peut ne pas être chargée. Mais lors de l'utilisation de la méthode newInstance(),
* doit s'assurer que : 1. Cette classe a été chargée 2. Cette classe a été connectée ;
* newInstance() décompose en fait la nouvelle méthode en deux étapes, c'est-à-dire qu'elle appelle d'abord la méthode de chargement de classe pour charger une certaine classe, puis l'instancie.
* Les avantages de cette approche étape par étape sont évidents. Nous pouvons obtenir une meilleure flexibilité en appelant la méthode de chargement statique pour le nom de la classe
* fournit un moyen de découplage (diminution du degré de couplage).
* Enfin, utilisez la description la plus simple pour distinguer la différence entre le nouveau mot-clé et la méthode newInstance() :
* newInstance : type faible. Inefficace. Seuls les constructeurs sans paramètres peuvent être appelés.
*nouveau : Type fort. Relativement efficace. Peut appeler n'importe quel constructeur public.

Le code est le suivant :

import java.lang.reflect.InvocationTargetException; 
import java.lang.reflect.Method; 
import java.lang.reflect.Field; 
 
public class testInvoke { 
  public void work(){ 
    System.out.println("-----------"); 
  }  
  public testInvoke work(String a,Integer b){ 
    System.out.println(a + b); 
    return this; 
  } 
  public void work(Integer b, int c ){ 
    System.out.println(b + c); 
  } 
   
  public static void main(String[] args) throws SecurityException, NoSuchMethodException, InstantiationException,     IllegalAccessException, IllegalArgumentException, InvocationTargetException{ 
    Class<?> clazz = testInvoke.class; 
    //Class<?> clazz = Class.forName("invoke.testInvoke"); 
    //testInvoke tinvoke = new testInvoke(); Class<?> clazz = tinvoke.getClass();  
    System.out.println(clazz); 
    //如果源类的方法没有参数，则要用new Class[]{} 
    Method method1 = clazz.getMethod("work", new Class[]{}); 
    Method method2 = clazz.getMethod("work", new Class[]{String.class, Integer.class});  
    Method method3 = clazz.getMethod("work", new Class[]{Integer.class, int.class}); 
    Object invokeTest = clazz.newInstance(); 
    /* 
     * Method类的invoke(Object obj,Object args[])方法接收的参数必须为对象，<br/> 
     * 如果参数为基本类型数据，必须转换为相应的包装类型的对象。invoke()方法的返回值总是对象，<br/> 
     * 如果实际被调用的方法的返回类型是基本类型数据，那么invoke()方法会把它转换为相应的包装类型的对象，再将其返回<br/> 
     */ 
    //invoke方法的第一个参数是源类的实例，第二个参数是实例的值 
    Object result1 = method1.invoke(invokeTest, new Object[]{}); 
    Object result2 = method2.invoke(invokeTest, new Object[]{"aaaa",new Integer(10)}); 
    Object result3 = method3.invoke(invokeTest, new Object[]{3,new Integer(4)}); 
    System.out.println(result1); 
    System.out.println(result2); 
    System.out.println(result3); 
 
    Method[] methods = clazz.getMethods(); 
    for(Method method : methods){ 
      System.out.println(method.getName()); 
    } 
     
    Field[] fileds = clazz.getFields(); 
    for(Field filed: fileds){ 
      System.out.println(filed.getName()); 
    } 
  } 
}

Informations sur la console :

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!