Java对象创建之new关键字和newinstance()方法

 new和newinstance()区别    
 在初始化一个类，生成一个实例的时候，newInstance()方法和new关键字除了一个是方法，一个是关键字外，最主要有什么区别?它们的区别在于创建对象的方式不一样，前者newInstance()是使用类加载机制，后者new关键字是创建一个新类。那么为什么会有两种创建对象方式?这主要考虑到软件的可伸缩、可扩展和可重用等软件设计思想。

　　Java中工厂模式经常使用newInstance()方法来创建对象，因此从为什么要使用工厂模式上可以找到具体答案。 例如：
　    真正起到消除耦合的，正是这个ExampleInterface 接口，而不是reflection
        class c = Class.forName(“Example”);
　　ExampleInterface factory = (ExampleInterface)c.newInstance();

      　　其中ExampleInterface是Example的接口，可以写成如下形式：

　　

        String className = "Example";
　　class c = Class.forName(className);

　　ExampleInterface  factory = (ExampleInterface)c.newInstance();

      　　进一步可以写成如下形式：
　　

        String className = readfromXMlConfig;//从xml 配置文件中获得字符串
　　class c = Class.forName(className);

　　ExampleInterface factory = (ExampleInterface)c.newInstance();

      上面代码已经不存在Example的类名称，它的优点是，无论Example类怎么变化，上述代码不变，甚至可以更换Example的兄弟类Example2 , Example3 , Example4……，只要他们继承ExampleInterface就可以。

       从jvm的角度看，我们使用new的时候，这个要new的类可以没有加载；      

      但是使用newInstance时候，就必须保证：     

         1、这个类已经加载；     

         2、这个类已经连接了。     

       上面两个步骤的正是class的静态方法forName（）方法，这个静态方法调用了启动类加载器（就是加载java API的那个加载器）。      

       有了上面jvm上的理解，那么我们可以这样说，newInstance实际上是把new这个方式分解为两步,即，首先调用class的加载方法加载某个类，然后实例化。  这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了我们降耦的手段。

　　最后用最简单的描述来区分new关键字和newInstance()方法的区别：

　　newInstance(): 弱类型。低效率。是实现IOC、反射、面对接口编程和依赖倒置等技术方法的必然选择！

　　new: 强类型。相对高效。能调用任何public构造。new只能实现具体类的实例化，不适合于接口编程。

1、类的加载方式不同
    在执行Class.forName("a.class.Name")时，JVM会在classapth中去找对应的类并加载，这时JVM会执行该类的静态代码段。在使用newInstance()方法的时候，必须保证这个类已经加载并且已经连接了，而这可以通过Class的静态方法forName()来完成的。
    使用关键字new创建一个类的时候，这个类可以没有被加载，一般也不需要该类在classpath中设定，但可能需要通过classlaoder来加载。
2、所调用的构造方法不尽相同
    new关键字能调用任何构造方法。
    newInstance()只能调用无参构造方法。
3、执行效率不同
    new关键字是强类型的，效率相对较高。
    newInstance()是弱类型的，效率相对较低。
    既然使用newInstance()构造对象的地方通过new关键字也可以创建对象，为什么又会使用newInstance()来创建对象呢？
    假设定义了一个接口Door，开始的时候是用木门的，定义为一个类WoodenDoor，在程序里就要这样写 Door door = new WoodenDoor() 。假设后来生活条件提高，换为自动门了，定义一个类AutoDoor，这时程序就要改写为 Door door = new AutoDoor() 。虽然只是改个标识符，如果这样的语句特别多，改动还是挺大的。于是出现了工厂模式，所有Door的实例都由DoorFactory提供，这时换一种门的时候，只需要把工厂的生产模式改一下，还是要改一点代码。
    而如果使用newInstance()，则可以在不改变代码的情况下，换为另外一种Door。具体方法是把Door的具体实现类的类名放到配置文件中，通过newInstance()生成实例。这样，改变另外一种Door的时候，只改配置文件就可以了。示例代码如下：
String className = 从配置文件读取Door的具体实现类的类名; 
Door door = (Door) Class.forName(className).newInstance();
    再配合依赖注入的方法，就提高了软件的可伸缩性、可扩展性。

 两种不同调用instance()的实现
其中newinstance(),又有两种方式：

    Class.newInstance()  
 eg:

      A a=(A)Class.forName(A.class.getName()).newInstance();  //只能调用public属性的无参构造函数

    Constructor.newInstance()
           Class c= Class.forName(A.class.getName());   
           /*以下调用无参的、私有构造函数*/  
         //获得无参构造
           Constructor c0=c.getDeclaredConstructor();  
         //设置无参构造是可访问的
           c0.setAccessible(true);   
           A a0=(A)c0.newInstance();    //调用无参构造函数，生成对象实例
           /*以下调用带参的、私有构造函数*/   
           Constructor c1=c.getDeclaredConstructor(new Class[]{int.class,int.class});   
           c1.setAccessible(true);   
          A a1=(A)c1.newInstance(new Object[]{5,6});   //调用有参构造函数，生成对象实例

两种方式的区别：
Class.newInstance() 只能够调用无参的构造函数，即默认的构造函数，要求被调用的构造函数是可见的，也即必须是public类型的；  

Constructor.newInstance() 可以根据传入的参数，调用任意构造构造函数，在特定的情况下，可以调用私有的构造函数。

实例代码：

public class A {  
            
/*            public A() {  
            System.out.println("A's constructor is called.");  
        }  */
            private A(){
                 System.out.println("A's constructor is called.");  
            }
      
        private A(int a, int b) {  
            System.out.println("a:" + a + " b:" + b);  
        }  
    }
 
public class B {
     public static void main(String[] args) {   
            B b=new B();   
            System.out.println("通过Class.NewInstance()调用私有构造函数:");   
            b.newInstanceByClassNewInstance();   
            System.out.println("通过Constructor.newInstance()调用私有构造函数:");   
            b.newInstanceByConstructorNewInstance();   
        }   
        /*通过Class.NewInstance()创建新的类示例*/   
        private void newInstanceByClassNewInstance(){   
            try {/*当前包名为reflect，必须使用全路径*/   
                A a=(A)Class.forName(A.class.getName()).newInstance();  
                System.out.println("通过Class.NewInstance()调用私有构造函数【成功】");  
            } catch (Exception e) {   
                System.out.println("通过Class.NewInstance()调用私有构造函数【失败】");   
            }  
        }  
          
        /*通过Constructor.newInstance()创建新的类示例*/   
        private void newInstanceByConstructorNewInstance(){   
            try {/*可以使用相对路径，同一个包中可以不用带包路径*/   
                Class c= Class.forName(A.class.getName());   
                /*以下调用无参的、私有构造函数*/  
              //获得无参构造
                Constructor c0=c.getDeclaredConstructor();  
              //设置无参构造是可访问的
                c0.setAccessible(true);   
                A a0=(A)c0.newInstance();   
                /*以下调用带参的、私有构造函数*/   
                Constructor c1=c.getDeclaredConstructor(new Class[]{int.class,int.class});   
                c1.setAccessible(true);   
                A a1=(A)c1.newInstance(new Object[]{5,6});  
                System.out.println("通过Constructor.newInstance()调用私有构造函数【成功】");
            } catch (Exception e) {   
                e.printStackTrace(); 
                System.out.println("通过Constructor.newInstance()调用私有构造函数【失败】");
            }   
        }   
}

————————————————

原文链接：https://blog.csdn.net/luckykapok918/article/details/50186797