克隆
概述实现克隆的方式
实现Cloneable接口，并重写object类中的clone方法，可以实现浅克隆，也可以实现深克隆实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的克隆利用BeanUtils，apache和spring都提供了bean工具，它是浅克隆 浅克隆(Shallow Clone) 和 深克隆(Deep Clone)
浅克隆（Shallow Clone）深克隆（Deep Clone） 细节对比点
new操作符创建对象和clone方法复制对象的区别复制引用 和 复制对象 区别克隆两种实现方式的区别 java参数传递 = 值传递RMIJava中的动态代理
代理模式静态代理动态代理
克隆 概述克隆出现的原因：
在实际开发过程中，一个对象obj已经包含一些有用信息，这是我们需要将obj的信息复制到obj2中，使得obj和obj2对象具有两个完全不同的地址，修改一个对象的值，另一个对象不受影响。
1 被克隆对象所属类必须实现Cloneable接口
public class 类名 implements Cloneable{}
2 所属类必须重写Object类的clone方法
@Override
public Object clone() throws CloneNotSupportedException{
类名 obj =(类名)super.clone(); // 浅克隆
obj.属性名 = (属性类)属性名.clone(); //深克隆
return obj；
}
实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的克隆
// 要序列化对象所属类 需要实现Serializable接口
public class 类名 implements Serializable{}
// 序列化
1 创建序列化流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("文件路径"));
2 创建对象
类名 obj = new 类名();
3 使用序列化流的writeObject方法将对象写入指定的ObjectOutputStream流中
oos.writeObject(obj);
4 释放资源
oos.close();
// 反序列化
1 创建反序列化流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("文件路径"));
2 使用反序列化流的readObject方法从ObjectInputStream流中读取一个对象
Object obj = ois.readObject();
3 强制转化对象类型
类型 obj1 = (类型)obj;
4 释放资源
ois.close();
利用BeanUtils，apache和spring都提供了bean工具，它是浅克隆
浅克隆(Shallow Clone) 和 深克隆(Deep Clone)
两种克隆方式主要区别在于是否支持引用类型的成员变量的复制。
java中的数据类型分为：基本数据类型（数值型{整型、浮点型、字符型}） 和 引用数据类型（接口、类、数组）
浅克隆中，对象的复制只是复制它本身和其中包含的值类型的成员变量，而引用类型的成员变量并没有复制。
实现方法
覆盖Object类中的Clone()方法实现。
1 被复制的类需要实现Cloneable接口
public class 类名 implements Cloneable{}
2 覆盖clone()方法，方法调用super.clone()方法得到需要的复制对象，输入clone有选项可以选择，自动生成。 修改为public访问级别
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
实验分析：
1 被复制的类没有实现Cloneable接口，而直接使用 类名 对象2 = (类名)对象1.clone(); 会报错 报clone()方法在java.lang.Object中是protected访问控制。 2 被复制的类实现Cloneable接口，使用 类名 对象2 = (类名)对象1.clone(); 也会报错， 需要抛出异常CloneNotSupportException异常
案例：
// 320-test1
// 类
public class Student implements Cloneable{
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
// 测试类
public class StudentDemo {
public static void main(String[] args) throws CloneNotSupportedException {
Student s1 = new Student("汪苏泷",35);
Student s2 = (Student)s1.clone();
System.out.println(s1.getName() + ", " + s1.getAge());
System.out.println("--------------");
System.out.println(s2.getName() + ", " + s2.getAge());
System.out.println(s1 == s2);// false 说明对象在堆内存中的地址不同
}
}
深克隆（Deep Clone）
深克隆中，无论原型对象的成员变量的类型是值类型还是引用数据类型，都会复制一份给克隆对象。
实现方法：
方法一：通过覆盖Object类中的clone()方法实现
1 被复制对象的类 需要实现Cloneable接口
public class 类名 implements Cloneable{}
2 重写Object类中的clone()方法，输入clone有选项可以选择 修改为public访问级别
@Override
public Object clone() throws CloneNotSupportedException{
Outer obj = (Outer)super.clone(); //类对象使用clone()方法
obj.inner = (Inner)inner.clone();//类对象属性的类 使用clone()方法
return obj;
}
方法二：使用序列化(Serialization)实现，序列化流ObjectOutputStream、反序列化流ObjectInputStream
// 序列化
1 创建序列化流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("文件路径"));
2 创建对象
类名 obj1 = new 类名();
3 使用序列化方法writeObject(Object obj)
oos.writeObject(obj1);
4 释放资源
oos.close();
// 反序列化
1 创建反序列化对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("文件路径"));
2 使用反序列化方法readObject()
Object obj = ois.readObject();
3 强制类型转换 Object =》 类名
类名 obj2 =(类名)obj;
4 释放资源
ois.close();
方法一案例：
// 320-test2
// Student的属性 的类
public class Address implements Cloneable {
private String address;
public Address() {
}
public Address(String address) {
this.address = address;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
// Student 要克隆的对象所属的类
public class Student implements Cloneable{
private String name;
private int age;
private Address addr;
// 创建的是Address类的对象
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Address getAddr() {
return addr;
}
public void setAddr(Address addr) {
this.addr = addr;
}
@Override
public Object clone() throws CloneNotSupportedException {
Student stu = (Student)super.clone();//浅克隆
stu.addr = (Address)addr.clone();//深克隆
return stu;
}
}
// 测试类
public class StudentDemo {
public static void main(String[] args) throws CloneNotSupportedException {
Address addr = new Address("西安市");
Student s1 = new Student("汪苏泷",35);
s1.setAddr(addr);
Student s2 = (Student)s1.clone();
System.out.println(s1.getName() + ", " + s1.getAge()+", "+s1.getAddr().getAddress());
System.out.println(s2.getName() + ", " + s2.getAge()+", " + s2.getAddr().getAddress());
// System.out.println(s1 == s2);// false 说明对象在堆内存中的地址不同
// 修改前输出：汪苏泷, 35, 西安市
// 汪苏泷, 35, 西安市
// 两个对象的Addr变量都一样，为了验证原对象和新对象是两个不一样的，这里对s2对象的Addr变量修改值
addr.setAddress("重庆市");
System.out.println("修改之后");
System.out.println("--------------");
System.out.println(s1.getName() + ", " + s1.getAge()+", "+s1.getAddr().getAddress());
System.out.println(s2.getName() + ", " + s2.getAge()+", " + s2.getAddr().getAddress());
// 对s2对象的成员变量addr进行修改，s1对象的addr变量也发生了变化。 =》 说明 没有实现深克隆，只完成了浅克隆，成员是值类型的复制。
// 要想实现深克隆，需要给Student类中的addr变量所处在类Address设置为浅克隆实现的内容。Address实现cloneable、且重写clone方法
// 修改前输出：汪苏泷, 35, 重庆市
// 汪苏泷, 35, 重庆市
// 修改后输出：汪苏泷, 35, 重庆市
// 汪苏泷, 35, 西安市
}
}
细节对比点
new操作符创建对象和clone方法复制对象的区别
| 具体操作 | new | clone |
|---|---|---|
| 分配内存 | 根据new操作符后面的类型分配对应大小的内存空间 | 分配与源对象相同大小的内存空间 |
| 填充对象的域 | 调用构造方法，填充对象的各个域（对象的初始化） | 使用源对象中对应的各个域填充新对象的域 |
| 对象创建完毕 | 构造方法返回创建完毕的对象，并将其引用地址发布到外部(栈内存) | clone()方法返回对象，并将其引用发布到外部(栈内存) |
A 是 源对象，B 是 新对象
复制引用 = A 和 B 地址值 相同，说明是一个对象
复制对象 = A 和 B 地址值 不相同，说明是两个对象
| 区别项 | 实现Cloneable接口的方式 | 序列化和反序列化方式 |
|---|---|---|
| 是否可以实现深度克隆 | 可以， 若对象属性嵌套很多引用类型，则需要在类中写多个.clone()方法，使用不是很方便 | 可以，使用方便 |
| 是否支持编译时检测异常 | 不支持，是在运行时抛出异常的 | 支持，通过泛型限定，可以检查出克隆的对象是否支持序列化，在编译阶段完成 |
当java传递的参数是基本数据类型时，一个方法不能改变基本数据类型参数的值；
当java传递的参数是引用数据类型时，一个方法可以修改引用数据类型参数所指向的对象的值；
值传递的精髓：传递的是存储单元中的内容，而不是存储单元的引用。
基本数据类型参数
// idea_face-test2-TransferTest
public class TransferTest {
public static void main(String[] args) {
int num = 1;
System.out.println("method()方法调用前=" + num);
method(num);
System.out.println("method()方法调用后=" + num);
}
public static void method(int number){
number = 2;
}
//method()方法调用前=1
//method()方法调用后=1
}
分析：
引用数据类型参数
public class TransterTest2 {
public static void main(String[] args) {
Person p = new Person("汪苏泷");
System.out.println("调用方法前= name:" + p.getName());
method(p);
System.out.println("调用方法后= name:" + p.getName());
}
public static void method(Person p){
p.setName("许嵩");
}
// 调用方法前= name:汪苏泷
// 调用方法后= name:许嵩
}
分析：
RMI(Remote Method Invocation)，远程方法调用，允许运行在一个java虚拟机的对象调用运行在另一个java虚拟机上的对象的方法。两个虚拟机可以是运行在相同计算机上的不同进程，也可以是运行在网络中的不同计算机。RPC(Remote Procedure Call),远程过程调用，用于一个进程调用另一个进程。 Java中的动态代理 代理模式
代理模式（Proxy或Surrogate），就是一个人或机构代替另一个人或机构采取行动。
一些情况下，一个客户不想或者不能够直接引用一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
代理就是为其他对象提供一个代理以控制对某个对象的访问。优点：
可以隐藏真实目标类的实现；可以实现客户与真实目标类之间的解耦，在不修改真实目标类代码的情况下能够做一些操作；代理模式实现条件：
代理类和被代理类实现共同的接口（或继承）；代理类中存在指向被代理类的索引；实际执行是通过调用代理类的方法而实际执行的是被代理类的方法。代理分类：
静态代理：程序员创建或特定工具自动生成源码，在对其进行编译。运行前，代理类的.class文件就已经存在了；
动态代理：程序运行时，运用反射机制动态创建而成，动态代理类的字节码文件在程序运行时由java反射机制动态生成，无需程序员手工编写它的源代码。
动态代理分类：
基于接口的代理：代表 = JDK代理
基于继承的代理：代表 = CGlib代理
静态代理
动态代理
