java 构造函数问题

1、构造函数什么时候被调用，被谁调用？

转摘：http://bbs.csdn.net/topics/350231037

当然，只有在NEW的时候，才会真正的创建这个对象，只有在创建时才会调用该类的构造函数。
如：
Class A{
public A(){
System.out.println("这是A的构造函数");
}
}
Class Test{
public statics void main(String[] args){
A a1;    //--->此时是不会打印出“这是A的构造函数”这段的
a1=new A();    //此时会打印出来
}
}

--------------------

情况当然不限于此了。
毕竟JAVA在创建对象时除了new的方式，还有反射的方式，就是
Class.forName(完整类名)

但反射加载时，只会调用类的无参构造函数。在反射时如果一个类中没有无参构造函数，那是会报实例化异常的。

在同一个类中如果出现构造函数的重载，那也有可能出现其中一个调用另外一个的情况。最显著的情况是因为某些参数采用默认值的方式。

还有创建子类对象时，会自动逐层调用父类的构造函数完成相关的初始化工作。

---------------------

创建该类实例时，会调用类内部构造方法，其实也就是new
上面有说反射的，反射的机制也是调用new关键字构造

不过反射和new在分配上不同 反射是动态的

String str="Me"  是不是分两步的？先是String str=null，然后str=new String("Me")

Class.ForName("").newInstance就可以调用不带参数的构造函数。

事实上例如在这样一个语句：Person ps=new Person();其实实例化了两个对象。Person ps是一个，new Person()是另一个。第一个ps其实就是一个引用其内部存储的是第二个对象的内存地址。所以第二个才是实体对象，所以new时才调用构造方法！！

--------------------

首先你要明白对象创建的几种方法:
1.使用new关键字
2.使用clone方法
3.java的反射机制
4.java的反序列化
以上四种都可以产生java对象
1,3都会明确的显式的调用构造函数
2是在内存上对已有对象的影印 所以不会调用构造函数
4是从文件中还原类的对象 也不会调用构造函数

-------------------

一般情况下，对象可以通过这三种方式创建：
1、构造函数，当然就是NEW的时候调了
2、拷贝构造函数，又有三种情况会调到，作为函数参数，作为返回值，用一个对象去创建另一个对象
当然在JAVA里面Object类都是以引用方式传的，所以在JAVA里面基本上不会在函数调用的时候调用
作为返回值会调用的，clone函数和用一个字符串对象去创建另一个字符串对象就是很好的例子
3、操作符重载
比如像String strHello = "HelloWorld";就是这样的，其实操作符重载也是一个函数

当然，第2和第3太难，JAVA里面都把下层的给屏蔽掉了，但是在下层还是会这样执行的，所以好多人都说C++难就是这些方面

------------------

1 JVM自动创建对象,不需要人为干预.
2 new操作符
3 Class.newInstance(Args)
4 Constructor 对象就是用来创建对象的

java中创建对象要通过new来实现，而构造函数只会在创建对象是才会被调用

只能这么说，万象不离本质，本质上都是通过NEW来创建一个对象，而得到一个对象的方式却可以有多种，并不一定要通过NEW来获得，可以通过设计模式中的单件模式获得一个实例，但内部实现代码无非都是通过NEW来实现的，所以不要给外表骗了，要懂得实质。
最后总结（NEW是本质，其他方式（比如getInstance、反射等）是通过封装后得到的现象）请区分好两者，希望对楼主有帮助。

-------------------

package constructor;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class TestConstructor {
	public static void main(String[] args){
		System.out.println("========= test new ==========");
		Bean b1 = testNew();
		b1.setId(1);
		b1.setName("b1");
		System.out.println(b1);
		System.out.println("========= test newInstance ==========");
		Bean b2 = testNewInstance();
		b2.setId(2);
		b2.setName("b2");
		System.out.println(b2);
		System.out.println("========= test clone ==========");
		Bean b3 = testClone(b1);
		b3.setName("b3");
		System.out.println(b3);
		System.out.println("========= test serializeBean&unserializeBean ==========");
		serializeBean(b1);
		Bean b4 = unserializeBean();
		b4.setName("b4");
		System.out.println(b4);
	}
	
	public static Bean testNew(){
		Bean b = new Bean();
		return b;
	}
	public static Bean testNewInstance(){
		try {
			Bean b = Bean.class.newInstance();
			return b;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	public static Bean testClone(Bean bean){
		try {
			Bean b = (Bean)bean.clone();
			return b;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	
	public static void serializeBean(Bean bean){
		try {
			FileOutputStream fos = new FileOutputStream("bean.ser");
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			oos.writeObject(bean);
			oos.close();
			fos.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	public static Bean unserializeBean(){
		try {
			FileInputStream fis = new FileInputStream("bean.ser");
			ObjectInputStream ois = new ObjectInputStream(fis);
			Bean b = (Bean)ois.readObject();
			return b;
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
}

class Bean implements Cloneable, Serializable{
	private static final long serialVersionUID = 8017660448545672348L;
	int id;
	String name;
	
	Bean(){
		this(-1, "No Name");
		System.out.println("--Bean() called--");
	}
	public Bean(int id, String name){
		this.id = id;
		this.name = name;
		System.out.println("--Bean(int id, String name) called--");
	}
	
	public String toString(){
		StringBuffer sb = new StringBuffer("Bean@").append(this.hashCode())
			.append("[id:").append(id).append("; name:'").append(name).append("']");
		return sb.toString();
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	protected Bean clone() throws CloneNotSupportedException {
		System.out.println("-----clone["+this+"]-----");
		return (Bean)super.clone();
	}
}

输出：

========= test new ==========
--Bean(int id, String name) called--
--Bean() called--
Bean@25899876[id:1; name:'b1']
========= test newInstance ==========
--Bean(int id, String name) called--
--Bean() called--
Bean@31131058[id:2; name:'b2']
========= test clone ==========
-----clone[Bean@25899876[id:1; name:'b1']]-----
Bean@5442802[id:1; name:'b3']
========= test serializeBean&unserializeBean ==========
Bean@25699763[id:1; name:'b4']

最初对象的产生，是new或者怎样到内存的，clone和serialized是内存数据的指向或拷贝？最终的本质，都是数据。类似c的malloc，分配一片内存给数据对象。指针或引用，也是占用内存，只是内存的内容是实际对象的地址。