/**

 * Creates and returns a copy of this object.  The precise meaning

 * of "copy" may depend on the class of the object. The general

 * intent is that, for any object {@code x}, the expression:

 * <blockquote>

 * <pre>

 * x.clone() != x</pre></blockquote>

 * will be true, and that the expression:

 * <blockquote>

 * <pre>

 * x.clone().getClass() == x.getClass()</pre></blockquote>

 * will be {@code true}, but these are not absolute requirements.

 * While it is typically the case that:

 * <blockquote>

 * <pre>

 * x.clone().equals(x)</pre></blockquote>

 * will be {@code true}, this is not an absolute requirement.

 * <p>

 * By convention, the returned object should be obtained by calling

 * {@code super.clone}.  If a class and all of its superclasses (except

 * {@code Object}) obey this convention, it will be the case that

 * {@code x.clone().getClass() == x.getClass()}.

 * <p>

 * By convention, the object returned by this method should be independent

 * of this object (which is being cloned).  To achieve this independence,

 * it may be necessary to modify one or more fields of the object returned

 * by {@code super.clone} before returning it.  Typically, this means

 * copying any mutable objects that comprise the internal "deep structure"

 * of the object being cloned and replacing the references to these

 * objects with references to the copies.  If a class contains only

 * primitive fields or references to immutable objects, then it is usually

 * the case that no fields in the object returned by {@code super.clone}

 * need to be modified.

 * <p>

 * ......

 */

//Object类中的clone()方法

protected native Object clone() throws CloneNotSupportedException;

//Cloneable 接口源码

public interface Cloneable {

}

//重写clone()方法

class CloneClass implements Cloneable{

　public Object clone(){

　　CloneClass o = null;

　　try{

　　　    o = (CloneClass)super.clone();
　　　　　CloneClass .setAddress(this.address.clone());//引用克隆类型赋值
}catch(CloneNotSupportedException e){ 　　　
e.printStackTrace(); 　　
} 　　
return o; 　
} 
}

public class A implements Serializable {

    private static final long serialVersionUID = "序列化ID";  //显式声明ID

    public Outer Aclone() {

        Outer outer = null;

        try {

        // 将对象序列化成流,因为写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面

            ByteArrayOutputStream baos = new ByteArrayOutputStream();

            ObjectOutputStream oos = new ObjectOutputStream(baos);

            oos.writeObject(this);

            // 将流序列化成对象

            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());

            ObjectInputStream ois = new ObjectInputStream(bais);

            outer = (Outer) ois.readObject();

        } catch (IOException e) {

            e.printStackTrace();

        } catch (ClassNotFoundException e) {

            e.printStackTrace();

        }

        return outer;

    }

}

/**

     * 通过字节流实现克隆

     */

static class StreamClone {

        public static <T extends Serializable> T clone(People obj) {

            T cloneObj = null;

            try {

                // 写入字节流

                ByteArrayOutputStream bo = new ByteArrayOutputStream();

                ObjectOutputStream oos = new ObjectOutputStream(bo);

                oos.writeObject(obj);

                oos.close();

                // 分配内存,写入原始对象,生成新对象

                ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());//获取上面的输出字节流

                ObjectInputStream oi = new ObjectInputStream(bi);

                // 返回生成的新对象

                cloneObj = (T) oi.readObject();

                oi.close();

            } catch (Exception e) {

                e.printStackTrace();

            }

            return cloneObj;

        }

    }