Java 创建对象方法

最新推荐文章于 2024-08-11 20:44:12 发布

Cabinathor

最新推荐文章于 2024-08-11 20:44:12 发布

阅读量678

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/lmxmimihuhu/article/details/47272659

版权

java 专栏收录该内容

66 篇文章 0 订阅

订阅专栏

本文主要介绍java创建对象的方法，闲话少叙。

Java创建对象的方法有多种，常见基本如下：

1、用new语句创建对象，这是最常见的创建对象的方法。

2、通过工厂方法返回对象，如：String str = String.valueOf(23);
3、运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。

Object obj = Class.forName("java.lang.Object").newInstance();
4、调用对象的clone()方法。实现Cloneable接口，然后重写Object.clone()方法创建对象.
5、通过I/O流（包括反序列化），如运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。

6、String str="abc" 直接由jvm创建或者使用字符串操作符"+" String str1 = "a"+"bc"由jvm创建。

创建对象方法比较：

工厂方法往往是调用new的，所以可以看作new的一种变形，对于虚拟机，本质一致。反序列化就是将数据读入后，调用反射生成新对象，唯一需要注意的是反射调用了类的无参构造函数，反射需要保证类有无参构造函数。下面重点介绍new，clone和反射。

new:

1.JVM首先检查该类是否加载，没有加载会先加载类，对类进行加载，解析和初始化；

2.加载类后，JVM对该对象在Java堆中分配内存，

3.设置对象，先对对象的初始化零值，就是对象字段初始化为零值；再对对象的对象头部分初始化，就是设置该对象的JVM相关属性，比如该对象属于哪个类，hash值，GC年代等。至此，从JVM看，对象创建了。

4.执行<init>方法，按照程序员的意愿对对象的各个属性设置。比如，设置各个域的初始值。

clone：

clone目的是复制一个原对象的copy，简单的就是内存复制，所以简单的clone是很快的，即与原对象相同，但是不一样，对新对象的操作不会影响原对象。clone在java规范中要求 1. a.clone() != a; 2. a.clone().getClass = a.getClass(); 3. a.clone().equals(a).

clone要求对象实现clonable接口，Object的clone方法会检测对象是够实现了这个接口。Object方法的clone方法是protected，即只有子类和同包（自定义类自然做不到和Object同包）才能调用。

clone分浅clone和深clone。

浅clone，Shallow Clone，就是逐域拷贝，默认实现cloneable接口或者简单覆盖clone方法就是浅clone。例如：

public class A implements Cloneable {  
    public String name;  
  
    public Object clone() {  
        A o = null;  
        try {  
            o = (A) super.clone();  
        } catch (CloneNotSupportedException e) {  
            e.printStackTrace();  
        }  
        return o;  
    }  
}

一个类如果只有基本类型和字符串这样的不可变对象，那么仅仅实现Cloneable就够了。但是如果类中包含数组或者复杂对象，就需要深clone，即正确生成新对象。例如：

public class A implements Cloneable {
	public String name[];
	public Vector<B> claB;
	
	public A(){
		name=new String[2];
		claB=new Vector<B>();
	}

	public Object clone() {
		A o = null;
		try {
			o = (A) super.clone();
            o.name==(String[])name.clone();//深度clone
            o.claB=new Vector<B>();//将clone进行到底
            for(int i=0;i<claB.size();i++){
	            B temp=(B)claB.get(i).clone();//当然Class B也要实现相应clone方法
	            o.claB.add(temp);
		    }
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
				return o;
	}
}

其实，clone方法分三种情况处理。

1.对象只包含基本类型的域或者域指向了一个不可变对象，这种情况只需实现cloneable接口即可。

2.域中包含数组的对象，只需调用数组的clone方法。

3.域包含可变对象。这就是需要我们特别关照的情况，我们必须将这些可变的部分手动。比如，List。

下面有例子（有些正确clone，有些没有）：

package basic.objects.methods;

import java.util.ArrayList;
import java.util.List;

/**
 * 检测数组的clone的正确定。 c2的改变不应该引起c1对象的改变，这是clone的意义。
 */
public class Clones implements Cloneable {
	int[] ints;// 没有正确clone
	double[] doubles;// 正确处理
	List<String> strs;// 没有正确处理
	List<Character> chs; // 正确处理

	public Clones() {
		ints = new int[] { 0 };
		doubles = new double[] { 0 };
		strs = new ArrayList<String>();
		chs = new ArrayList<Character>();
	}

	@Override
	public Clones clone() {
		try {
			Clones c = (Clones) super.clone();
			c.doubles = doubles.clone();
			c.chs = new ArrayList<Character>(chs);
			return c;
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static void main(String[] args) throws CloneNotSupportedException {
		Clones c1 = new Clones();
		Clones c2 = (Clones) c1.clone();
		c2.ints[0] = 1;
		c2.doubles[0] = 1;
		c2.strs.add("new str in c2 added");
		c2.chs.add('H');
		System.out.println(c1.ints[0]);
		System.out.println(c1.doubles[0]);
		System.out.println(c1.strs);
		System.out.println(c1.chs);
	}
}