在初始化一个类，生成一个实例的时候；newInstance() 和 new 有什么区别？ 用newInstance与用new是区别的，区别在于创建对象的方式不一样，前者是使用类加载机制，那么为什么会有两种创建对象方式？这个就要从可伸缩、可扩展，可重用等软件思想上解释了。 Java中工厂模式经常使用newInstance来创建对象，因此从为什么要使用工厂模式上也可以找到具体答案。 例如： Class c = Class.forName(“A”);factory = (AInterface)c.newInstance(); 其中AInterface是A的接口，如果下面这样写，你可能会理解： String className = “A”;Class c = Class.forName(className);factory = (AInterface)c.newInstance(); 进一步，如果下面写，你可能会理解： String className = readfromXMlC//从xml 配置文件中获得字符串Class c = Class.forName(className);factory = (AInterface)c.newInstance(); 上面代码就消灭了A类名称，优点：无论A类怎么变化，上述代码不变，甚至可以更换A的兄弟类B , C , D….等，只要他们继承Ainterface就可以。 从jvm的角度看，我们使用new的时候，这个要new的类可以没有加载； 但是使用newInstance时候，就必须保证：1、这个类已经加载；2、这个类已经连接了。而完成上面两个步骤的正是class的静态方法forName（）方法，这个静态方法调用了启动类加载器（就是加载javaAPI的那个加载器）。 有了上面jvm上的理解，那么我们可以这样说，newInstance实际上是把new这个方式分解为两步,即，首先调用class的加载方法加载某个类，然后实例化。 这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了我们降耦的手段。
备注： newInstance: 弱类型。低效率。只能调用无参构造。 new: 强类型。相对高效。能调用任何public构造。 newInstance()是实现IOC、反射、面对接口编程 和 依赖倒置 等技术方法的必然选择，new 只能实现具体类的实例化，不适合于接口编程。 newInstance里面就是通过这个类的默认构造函数构建了一个对象，必须要有默认构造函数，如果没有默认构造函数就抛出InstantiationException, 如果没有访问默认构造函数的权限就抛出IllegalAccessException
本文已收录于以下专栏：
相关文章推荐
测试服务器，跑了一夜之后，java.exe占用了大量内存（将近5GB），系统内存占用97%。
使用jconsole连接到该进程，发现一下的现象：
1. Heap内存占用比较正常，不到2个G。非He...
Class.forName()、newInstance() 、New 三者区别！ 
        在Java开发特别是数据库开发中，经常会用到Class.forName( )这个方法。通过查询Ja...
在初始化一个类，生成一个实例的时候，newInstance()方法和new关键字除了一个是方法，一个是关键字外，最主要有什么区别？它们的区别在于创建对象的方式不一样，前者是使用类加载机制，后者是创建一...
在初始化一个类，生成一个实例的时候；newInstance() 和 new 有什么区别?
用newInstance与用new是区别的，区别在于创建对象的方式不一样，前者是使用类加载机制，那么为什么会...
new和newInstance的区别对比
在初始化一个类，生成一个实例的时候；newInstance() 和 new 有什么区别？
用newInstance与用new是区别的，区别在于创建对象的方式不一样，前者是使用类加载机制，那么为什么会...
在Java开发特别是数据库开发中，经常会用到Class.forName( )这个方法。通过查询Java Documentation我们会发现使用Class.forName( )静态方法的目的是为了动态...
转自：/mianshiti/it/java/7148/
在初始化一个类，生成一个实例的时候；newInstance() 和 new 有什么区别?
区别在于创建对象的方式不一样，前者是使用类加载机制，那么为什么会有两种创建对象方式？这个就要从可伸缩、可扩展，可重用等软件思想上解释了。Java中工厂模式经常使用newInstance来创建对象，因此...
他的最新文章
讲师：姜飞俊
讲师：汪木铃
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)Class.newInstance()与new、Constructor.newInstance()的区别
我的图书馆
Class.newInstance()与new、Constructor.newInstance()的区别
在初始化一个类，生成一个实例的时候，newInstance() 和 new 有什么区别？
　　用newInstance与用new是区别的，区别在于创建对象的方式不一样，前者是使用类加载机制，那么为什么会有两种创建对象方式？这个就要从可伸缩、可扩展，可重用等软件思想上解释了。
　　Java中工厂模式经常使用newInstance来创建对象，因此从为什么要使用工厂模式上也可以找到具体答案。
　　例如：
　　[java] Class&c&=&Class.forName(“A”);&&factory&=&(AInterface)c.newInstance();&&&
　　其中AInterface是A的接口，如果下面这样写，你可能会理解：
　　[java] String&className&=&"A";&&Class&c&=&Class.forName(className);&&factory&=&(AInterface)c.newInstance();&&&
　　进一步，如果下面写，你可能会理解：
[java] String&className&=&readfromXMlC&&//从xml&配置文件中获得字符串&&Class&c&=&Class.forName(className);&&factory&=&(AInterface)c.newInstance();&&
　　上面代码就消灭了A类名称，优点：无论A类怎么变化，上述代码不变，甚至可以更换A的兄弟类B , C , D....等，只要他们继承Ainterface就可以。
　　　从jvm的角度看，我们使用new的时候，这个要new的类可以没有加载；
　　但是使用newInstance时候，就必须保证：
1、这个类已经加载；
2、这个类已经连接了。
而完成上面两个步骤的正是class的静态方法forName方法，这个静态方法调用了启动类加载器（就是加载java API的那个加载器）。
　　有了上面jvm上的理解，那么我们可以这样说，newInstance实际上是把new这个方式分解为两步,即，首先调用class的加载方法加载某个类，然后实例化。
　　这样分步的好处是显而易见的。new者，包括用A.class，在编译期已经确定，不可能在运行期变更，一旦要变更必须改变这部分代码，而newInstance者，Class.forName(String)的参数可以在运行期配置，而无须改动代码，我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了我们降耦的手段。
newInstance: 弱类型。低效率。只能调用无参构造。
new: 强类型。相对高效。能调用任何public构造。
newInstance() 的参数版本与无参数版本详解
通过反射创建新的类示例，有两种方式：
Class.newInstance()
Constructor.newInstance()
以下对两种调用方式给以比较说明：
Class.newInstance() 只能够调用无参的构造函数，即默认的构造函数；
Constructor.newInstance() 可以根据传入的参数，调用任意构造构造函数。
Class.newInstance() 抛出所有由被调用构造函数抛出的异常。
Class.newInstance() 要求被调用的构造函数是可见的，也即必须是public类型的;
Constructor.newInstance() 在特定的情况下，可以调用私有的构造函数。
Class A（被调用的示例）：
[java] public&class&A&{&&&&&&private&A()&{&&&&&&&&&&System.out.println("A's&constructor&is&called.");&&&&&&}&&&&&&&&private&A(int&a,&int&b)&{&&&&&&&&&&System.out.println("a:"&+&a&+&"&b:"&+&b);&&&&&&}&&}&&
Class B（调用者）： [java] public&class&B&{&&&&&&&public&static&void&main(String[]&args)&{&&&&&&&&&&&B&b=new&B();&&&&&&&&&&&out.println("通过Class.NewInstance()调用私有构造函数:");&&&&&&&&&&&b.newInstanceByClassNewInstance();&&&&&&&&&&&out.println("通过Constructor.newInstance()调用私有构造函数:");&&&&&&&&&&&b.newInstanceByConstructorNewInstance();&&&&&&&}&&&&&&&/*通过Class.NewInstance()创建新的类示例*/&&&&&&&private&void&newInstanceByClassNewInstance(){&&&&&&&&&&&try&{/*当前包名为reflect，必须使用全路径*/&&&&&&&&&&&&&&&A&a=(A)Class.forName("reflect.A").newInstance();&&&&&&&&&&&}&catch&(Exception&e)&{&&&&&&&&&&&&&&&out.println("通过Class.NewInstance()调用私有构造函数【失败】");&&&&&&&&&&&}&&&&&&}&&&&&&&&&&&&/*通过Constructor.newInstance()创建新的类示例*/&&&&&&&private&void&newInstanceByConstructorNewInstance(){&&&&&&&&&&&try&{/*可以使用相对路径，同一个包中可以不用带包路径*/&&&&&&&&&&&&&&&Class&c=Class.forName("A");&&&&&&&&&&&&&&&/*以下调用无参的、私有构造函数*/&&&&&&&&&&&&&&&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});&&&&&&&&&&&}&catch&(Exception&e)&{&&&&&&&&&&&&&&&e.printStackTrace();&&&&&&&&&&&}&&&&&&&}&&&}&&
输入结果如下：
通过Class.NewInstance()调用私有构造函数:
通过Class.NewInstance()调用私有构造函数【失败】
通过Constructor.newInstance()调用私有构造函数:
A's constructor is called.
说明方法newInstanceByClassNewInstance调用失败，而方法newInstanceByConstructorNewInstance则调用成功。
如果被调用的类的构造函数为默认的构造函数，采用Class.newInstance()则是比较好的选择，
一句代码就OK；如果需要调用类的带参构造函数、私有构造函数，
就需要采用Constractor.newInstance()，两种情况视使用情况而定。
不过Java Totorial中推荐采用Constractor.newInstance()。
TA的最新馆藏[转]&[转]&[转]&
喜欢该文的人也喜欢JAVA基础（7）
Class.forName()、newInstance() 、New 三者区别！&
&&&&&&& 在Java开发特别是数据库开发中，经常会用到Class.forName( )这个方法。通过查询Java Documentation我们会发现使用Class.forName( )静态方法的目的是为了动态加载类。在加载完成后，一般还要调用Class下的newInstance( )静态方法来实例化对象以便操作。因此，单单使用Class.forName( )是动态加载类是没有用的，其最终目的是为了实例化对象。&&&&&
这里有必要提一下就是Class下的newInstance()和new有什么区别？
首先，newInstance( )是一个方法，而new是一个关键字，其次，Class下的newInstance()的使用有局限，因为它生成对象只能调用无参的构造函数，而使用 new关键字生成对象没有这个限制。&&&& 好，到此为止，我们总结如下：&&&&
&Class.forName(&&)返回的是类&&&&&
&Class.forName(&&).newInstance()返回的是object&&&&&
有数据库开发经验朋友会发现，为什么在我们加载数据库驱动包的时候有的却没有调用newInstance( )方法呢？
即有的jdbc连接数据库的写法里是Class.forName(xxx.xx.xx);而有一 些：
Class.forName(xxx.xx.xx).newInstance()，为什么会有这两种写法呢？&&&& 刚才提到，Class.forName(&&);的作用是要求JVM查找并加载指定的类，如果在类中有静态初始化器的话，JVM必然会执行该类的静态代码 段。而在JDBC规范中明确要求这个Driver类必须向DriverManager注册自己，即任何一个JDBC Driver的 Driver类的代码都必须类似如下：&&
public class MyJDBCDriver implements Driver {
DriverManager.registerDriver(new MyJDBCDriver());
既然在静态初始化器的中已经进行了注册，所以我们在使用JDBC时只需要Class.forName(XXX.XXX);就可以了。&&&
贴出Proxool 连接池的静态初始化方法：
public class ProxoolDriver implements Driver {
private static final Log LOG = LogFactory.getLog(ProxoolDriver.class);
DriverManager.registerDriver(new ProxoolDriver());
} catch (SQLException e) {
System.out.println(e.toString());
& 上面这个文章是网络流传的一个关于JDBC如何注册驱动的,其实forName用法不仅仅如此,还可以在下面里面用到&
注:一般在通用框架里面用的就是class.forName来加载类,然后再通过反射来调用其中的方法,譬如Tomcat源码里面,这样就避免了new关键字的耦合度,还有让不同的类加载器来加载不同的类,方便提高类之间的安全性和隔离性.
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：13798次
排名：千里之外
原创：26篇
转载：11篇
(2)(5)(12)(5)(13)
(window.slotbydup = window.slotbydup || []).push({
id: '4740881',
container: s,
size: '200,200',
display: 'inlay-fix'博客分类：
在初始化一个类，生成实例的时候，大家可能用new比较多，用newInstance较少。
收集到的资料为：
最简单的描述来区分new关键字和newInstance()方法的区别：
　　newInstance: 弱类型。低效率。只能调用无参构造。
　　new: 强类型。相对高效。能调用任何public构造。
newInstance()是实现IOC、反射、面对接口编程和依赖倒置等技术方法的必然选择，new只能实现具体类的实例化，不适合于接口编程。
　　Java中工厂模式经常使用newInstance来创建对象，因此从为什么要使用工厂模式上也可以找到具体答案。
　　例如：
　　Class c = Class.forName(“A”);factory = (AInterface)c.newInstance();
　　其中AInterface是A的接口，如果下面这样写，你可能会理解：
　　String className = "A";Class c = Class.forName(className);factory = (AInterface)c.newInstance();
　　进一步，如果下面写，你可能会理解：
　　String className = readfromXMlC//从xml 配置文件中获得字符串Class c = Class.forName(className);factory = (AInterface)c.newInstance();
因收集的内容比较零散，并作了修改，不列出处。
　　上面代码就消灭了A类名称，优点：无论A类怎么变化，上述代码不变，甚至可以更换A的兄弟类B , C , D....等，只要他们继承Ainterface就可以。
　　从jvm的角度看，我们使用new的时候，这个要new的类可以没有加载；
　　但是使用newInstance时候，就必须保证：
1、这个类已经加载；
2、这个类已经连接了。
而完成上面两个步骤的正是class的静态方法forName（）方法，这个静态方法调用了启动类加载器（就是加载java API的那个加载器）。
　　有了上面jvm上的理解，那么我们可以这样说，newInstance实际上是把new这个方式分解为两步,即，首先调用class的加载方法加载某个类，然后实例化。
　　这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了我们降耦的手段。
核心提示：在初始化一个类，生成一个实例的时候，newInstance()方法和new关键字除了一个是方法，一个是关键字外，最主要有什么区别?它们的区别在于创建对象的方式不一样，前者是使用类加载机制，后者是创建一个新类。那么为什么会有两种创建对象方式?这主要考虑到软件
在初始化一个类，生成一个实例的时候，newInstance()方法和new关键字除了一个是方法，一个是关键字外，最主要有什么区别?它们的区别在于创建对象的方式不一样，前者是使用类加载机制，后者是创建一个新类。那么为什么会有两种创建对象方式?这主要考虑到软件的可伸缩、可扩展和可重用等软件设计思想。
　　Java中工厂模式经常使用newInstance()方法来创建对象，因此从为什么要使用工厂模式上可以找到具体答案。 例如：
1. class c = Class.forName(“Example”);
2. ory = (ExampleInterface)c.newInstance();
　　其中ExampleInterface是Example的接口，可以写成如下形式：
String className = "Example";
2. 　　class c = Class.forName(className);
3. 　　factory = (ExampleInterface)c.newInstance();
　　进一步可以写成如下形式：
String className = readfromXMlC//从xml 配置文件中获得字符串
2. 　　class c = Class.forName(className);
3. 　　factory = (ExampleInterface)c.newInstance();
　　上面代码已经不存在Example的类名称，它的优点是，无论Example类怎么变化，上述代码不变，甚至可以更换Example的兄弟类Example2 , Example3 , Example4……，只要他们继承ExampleInterface就可以。
　　从JVM的角度看，我们使用关键字new创建一个类的时候，这个类可以没有被加载。但是使用newInstance()方法的时候，就必须保证：1、这个类已经加载;2、这个类已经连接了。而完成上面两个步骤的正是Class的静态方法forName()所完成的，这个静态方法调用了启动类加载器，即加载java API的那个加载器。
　　现在可以看出，newInstance()实际上是把new这个方式分解为两步，即首先调用Class加载方法加载某个类，然后实例化。 这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了一种降耦的手段。
　　最后用最简单的描述来区分new关键字和newInstance()方法的区别：
　　newInstance: 弱类型。低效率。只能调用无参构造。
　　new: 强类型。相对高效。能调用任何public构造。
robinsoncrusoe
浏览: 509443 次
来自: 深圳
请问,那个Node 是哪个包里面的类?
总结的很好，感谢感谢
居然是10年发的,难怪截屏自动保存的名字是 ...
是注解不是注释。。。
[b][b][b][b][b][b][b][b][b][b][ ...}