《一》建造者模式
建造者模式 就是建造不同的東西，但是基本流程不變，將複雜的對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。 //構建產品 public class Person { private String head; private String body; private String foot; public String getHead() { return head; } public void setHead(String head) { this.head = head; } public String getBody() { return body; } public void setBody(String body) { this.body = body; } public String getFoot() { return foot; } public void setFoot(String foot) { this.foot = foot; }
}
//產品接口 public interface PersonBuilder { void buildhead(); void buildbody(); void buildfoot(); Person buildperson(); }
//實例一個產品 public class ManBuilder implements PersonBuilder{
Person person;
public ManBuilder(){
person = new Person();
}
public void buildhead() {
person.setHead("建造男人的頭");
}
public void buildbody() {
person.setBody("建造男人的身體");
}
public void buildfoot() {
person.setFoot("建造男人的腳");
}
public Person buildperson() {
return person;
}}
//調用具體建造者來創建對象的各個部分，不涉及具體信息， //之負責保證對象各部分完整創建。 public class PersonDirector { public Person constructPerson(PersonBuilder pb){ pb.buildbody(); pb.buildfoot(); pb.buildhead(); return pb.buildperson(); } }
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
PersonDirector pd=new PersonDirector();
Person person=pd.constructPerson(new ManBuilder());
System.out.println(person.getHead());
System.out.println(person.getBody());
System.out.println(person.getFoot());
}}
《二》 深複製與淺複製
1.淺複製 被複制對象的所有變量都含有與原來的對象相同的值，而所有的對其他對象的引用仍然指向原來的對象，淺複製僅僅複製所考慮的對象，而不復制它所引用的對象。
//淺拷貝 public class Person implements Cloneable{ private int age; private String name; public Person(int age,String name){ this.age=age; this.name=name; } public Person(){} public int getAge(){ return age; } public String getName(){ return name; } public static void main(String[] args){ Person p=new Person(23,”ha “); Person p1=null; try { p1 = (Person)p.clone(); //克隆 } catch (CloneNotSupportedException e) { // TODO Auto-generated catch block e.printStackTrace(); } //測試p和p1是否指向同一對象 String result=p.getName()== p1.getName()?”clone是淺拷貝”:”clone是深拷貝”; System.out.println(result); }
}
2、深複製 被複制對象的所有變量都含有與原來的對象相同的值，但不指向原來的對象。 class Professor implements Cloneable { String name; int age; Professor(String name,int age) { this.name=name; this.age=age; } public Object clone() { Object o=null; try { o=super.clone(); //對o也進行克隆 } catch(CloneNotSupportedException e) { System.out.println(e.toString()); } return o; } }
class Student implements Cloneable { String name; int age; Professor p; Student(String name,int age,Professor p) { this.name=name; this.age=age; this.p=p; } public Object clone() { Student o=null; try { o=(Student)super.clone();
}
catch(CloneNotSupportedException e)
{
System.out.println(e.toString());
}
o.p= (Professor)p.clone();//關鍵句
return o; } } public class DeepCopy{ public static void main(String[] args) { Professor p=new Professor(“wangwu”,50); Student s1=new Student(“zhangsan”,18,p); Student s2=(Student)s1.clone(); s2.p.name=”lisi”; s2.p.age=30; System.out.println(“name=”+s1.p.name+”,”+”age=”+s1.p.age); System.out.println(“name=”+s2.p.name+”,”+”age=”+s2.p.age); } }