原型模式

看了原型模型，主要就是克隆的问题，以前对深浅克隆模模糊糊，现在清楚了大概，写下来留着以后参考！

//深克隆就是克隆之后对克隆对象改变属性不会影响原来的对象（连引用也一起克隆）

//浅克隆是只克隆值类型对于引用类型克隆其引用，String除外他是一个特殊的引用

看下深克隆的例子吧：

简历类：

package com.founder.prototype;

public class JianLi implements Cloneable
{
    private String name;

    private String sex;

    private int age;

//    private String jobExperience;
    private JobExperience job;

    public JianLi()
    {
    }

    public JianLi(String name, String sex, int age, JobExperience jobExperience)
    {
        super();
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.job = jobExperience;
    }

    @Override
    public String toString()
    {
        return "[name:" + name + ",sex:" + sex + ",age:" + age
            + ",jobExperience:" + job + "]";
    }

    @Override
    public Object clone() throws CloneNotSupportedException
    {
        JianLi jianli = (JianLi)super.clone();
        jianli.setJob((JobExperience)jianli.getJob().clone());  //这里是关键，在克隆对象的时候也克隆他的引用类型的对象
        return jianli;
    }

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public String getSex()
    {
        return sex;
    }

    public void setSex(String sex)
    {
        this.sex = sex;
    }

    public int getAge()
    {
        return age;
    }

    public void setAge(int age)
    {
        this.age = age;
    }

    public JobExperience getJob()
    {
        return job;
    }

    public void setJob(JobExperience job)
    {
        this.job = job;
    }

 
}

工作经验类：

package com.founder.prototype;

public class JobExperience implements Cloneable
{

    private String companyName;

    private String jobContent;

    private String ageLimit;

    public JobExperience()
    {
    }

    public JobExperience(String companyName, String jobContent, String ageLimit)
    {
        super();
        this.companyName = companyName;
        this.jobContent = jobContent;
        this.ageLimit = ageLimit;
    }

    @Override
    public String toString()
    {
        StringBuilder buf = new StringBuilder();
        buf.append("[").append("companyName:").append(companyName).append(",").append(
                "jobContent:").append(jobContent).append(",").append(
                "ageLimit:").append(ageLimit).append("]");
        return buf.toString();
    }

    public String getCompanyName()
    {
        return companyName;
    }

    public void setCompanyName(String companyName)
    {
        this.companyName = companyName;
    }

    public String getJobContent()
    {
        return jobContent;
    }

    public void setJobContent(String jobContent)
    {
        this.jobContent = jobContent;
    }

    public String getAgeLimit()
    {
        return ageLimit;
    }

    public void setAgeLimit(String ageLimit)
    {
        this.ageLimit = ageLimit;
    }
    
    @Override
    public Object clone() throws CloneNotSupportedException
    {
        return super.clone();
    }

}

测试类：

package com.founder.prototype;

public class TJianLi
{

    //深克隆就是克隆之后对克隆对象改变属性不会影响原来的对象（连引用也一起克隆）
    //浅克隆是只克隆值类型对于引用类型克隆其引用，String除外他是一个特殊的引用
    public static void main(String[] args) throws CloneNotSupportedException
    {
        JobExperience e = new JobExperience("founder","mpps","1");
        JianLi j1 = new JianLi("kalus", "M", 18, e);
        System.out.println("克隆前j1："+j1);
        JianLi j2 = (JianLi) j1.clone();
        j2.getJob().setCompanyName("yy");
//        JianLi j3 = (JianLi) j1.clone();
//        j3.getJob().setCompanyName("zz");
        System.out.println("=================");
        System.out.println("克隆后j1 "+j1);
        System.out.println();
        System.out.println("克隆后j2 "+j2);
//        System.out.println("j3 "+j3);
    }
}

测试发现结果：j1对象无论在克隆前后都他的引用类型的值是没有变化的，如果浅克隆的话只是克隆引用，他们值的还是同一个对象，改变克隆引用类型的值也会改变原来的对象值

这里没有考虑深层克隆，以后在补充。。。