第六讲：原型模式

两个对象person1和person2,如果他们只有名字不同,其他属性相同,不想重复创建对象,想把person1复制一份作为person2,可以使用原型模式.

如果person2克隆person1,那么具有相同的值,修改的话只需要修改Name这一个属性就行.其他的属性都不用设置了,因为都是从person1那里拷贝过来的.现在需要想方设法让person1调用一个方法获得person2这个对象.

public class Person implements Cloneable{//实现了Cloneable接口才可以被克隆.

引用的话P1和P2指向的是一个对象,引用的是一个对象,它们引用的地址是相同的.

Person1和Person2的数据是完全相同的.

克隆是Person1和Person2是两个不同的对象,只不过这两个不同的对象具有相同的数据.克隆不是简单的引用同一个对象,而是两个不同的对象,修改person1对person2没有任何影响.

原型就是原始模型.

Cloneable是一个简单的接口,就是一个声明一样的东西,它里面没有任何东西,只是给虚拟机看的,表面你这个对象是可以克隆的.

Person里面的数据都是数值型的:String和int.String可以看做是对象,但是因为String是在常量池的,是一个常量,所以String可以看做是常量.int和String都是数值型的.

如果是引用的话,就不是这样考虑了.

它只会把引用复制一份,不会把实际的List复制一份.

浅度的克隆:

浅度的克隆:复制引用不复制对象,它们两个还是指向同一个对象.person1的List《String>改变了person2的List<String>也会改变.person1的数值型的属性例如name改变,person2的对应属性不会改变.

深度克隆:不是以前简单的引用传递.

如果引用型属性不是List数组,而是一个Object对象,又是一个Person的话,就调用那个对象的clone()方法克隆一个新的对象.

应用场景:

深度克隆是绝对的互不影响,但是浅度克隆的话引用型的属性就会相互影响了.

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


public class MainClass {
    public static void main(String[] args) {
/*        Person person1 = new Person();
        person1.setName("lifengxing");
        person1.setAge(30);
        person1.setSex("男");*/
        
        /*Person person2 = new Person();
        person2.setName("beifeng");
        person2.setAge(30);
        person2.setSex("男");*/
        //Person person2   = person1;//引用.
        //Person person2 = person1.clone();//克隆不同于引用
/*        person1.setName("厉风行");
        System.out.println(person2.getName());*/
/*        System.out.println(person1.getName());
        System.out.println(person1.getAge());
        System.out.println(person1.getSex());
        
        System.out.println(person2.getName());
        System.out.println(person2.getAge());
        System.out.println(person2.getSex());*/
        Person person1 = new Person();
        List<String> friends = new  ArrayList<String>();
        friends.add("James");
        friends.add("Yao");
        
        person1.setFriends(friends);
        Person person2 = person1.clone();
        
        System.out.println(person1.getFriends());
        System.out.println(person2.getFriends());
        
        friends.add("Mike");
        person1.setFriends(friends);
        System.out.println(person1.getFriends());
        System.out.println(person2.getFriends());
    }
}

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


//public class Person {
public class Person implements Cloneable{//实现了Cloneable接口才可以被克隆.
//姓名
    private String name;
    //年龄
    private int age;
    //性别
    private String sex;
    //朋友
    private List<String> friends;//对象,不是保存为数值,而是引用,引用了一个对象.
    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 String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Person clone(){//创建一个克隆的方法.
        try {
            Person person = (Person) super.clone();
            //List<String> friends = this.getFriends();//把list手动复制一份
            List<String> friends = new ArrayList<String>();//把list手动复制一份
            for (String friend : this.getFriends()) {
                friends.add(friend);
            }
            person.setFriends(friends);
            //return (Person) super.clone();//调用它的父类Object的clone()方法.
            return person;
            //利用java的特性可以进行克隆
        } catch (CloneNotSupportedException e) {//没有实现Cloneable接口的话不支持克隆
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }
    public List<String> getFriends() {
        return friends;
    }
    public void setFriends(List<String> friends) {
        this.friends = friends;
    }
    
}