23 种设计模式——创建型设计模式（5种）

 1 public class LazySingleton {
 2     private static volatile LazySingleton instance = null;    //保证 instance 在所有线程中同步
 3     private LazySingleton() {}    //private 避免类在外部被实例化
 4     public static synchronized LazySingleton getInstance() {
 5         // getInstance 方法前加同步
 6         if(instance == null) {
 7             instance = new LazySingleton();
 8         }
 9         return instance;
10     }
11 }

1 public class HungrySingleton {
2     private static final HungrySingleton instance = new HungrySingleton();
3     private HungrySingleton(){}
4     public static HungrySingleton getInstance() {
5         return instance;
6     }
7 }

 1 // 具体原型类
 2 class Realizetype implements Cloneable {
 3     Realizetype() {
 4         System.out.println("具体原型创建成功！");
 5     }
 6     public Object clone() throws CloneNotSupportedException {
 7         System.out.println("具体原型复制成功！");
 8         return (Realizetype)super.clone();
 9     }
10 }

1 // 原型模式的测试类
2 public class PrototypeTest {
3     public static void main(String[] args)throws CloneNotSupportedException {
4         Realizetype obj1=new Realizetype();
5         Realizetype obj2=(Realizetype)obj1.clone();
6         System.out.println("obj1==obj2?"+(obj1==obj2));
7     }
8 }

具体原型创建成功！
具体原型复制成功！
obj1==obj2?false

 1 class SunWukong extends JPanel implements Cloneable {
 2 
 3     public SunWukong() {
 4         JLabel l1 = new JLabel(new ImageIcon("src/Wukong.jpg"));
 5         this.add(l1);   
 6     }
 7     public Object clone() {
 8         SunWukong w = null;
 9         try {
10             w = (SunWukong)super.clone();
11         } catch(CloneNotSupportedException e) {
12             System.out.println("拷贝悟空失败!");
13         }
14         return w;
15     }
16 }

 1 // 奖状类
 2 class citation implements Cloneable {
 3     String name;
 4     String info;
 5     String college;
 6     citation(String name,String info,String college) {
 7         this.name = name;
 8         this.info = info;
 9         this.college = college;
10         System.out.println("奖状创建成功！");
11     }
12     void setName(String name) {
13         this.name = name;
14     }
15     String getName() {
16         return(this.name);
17     }
18     void display() {
19         System.out.println(name+info+college);
20     }
21     public Object clone() throws CloneNotSupportedException {
22         System.out.println("奖状拷贝成功！");
23         return (citation)super.clone();
24     }
25 }

1 public class ProtoTypeCitation {
2     public static void main(String[] args) throws CloneNotSupportedException {
3         citation obj1 = new citation("张三","同学：在2016学年第一学期中表现优秀，被评为三好学生。","韶关学院");
4         obj1.display();
5         citation obj2 = (citation) obj1.clone();
6         obj2.setName("李四"); 
7         obj2.display();
8     }
9 }

奖状创建成功！
张三同学：在2016学年第一学期中表现优秀，被评为三好学生。韶关学院
奖状拷贝成功！
李四同学：在2016学年第一学期中表现优秀，被评为三好学生。韶关学院

1 interface Shape extends Cloneable {
2     public Object clone();    //拷贝
3     public void countArea();    //计算面积
4 }

 1 class Circle implements Shape {
 2     public Object clone() {
 3         Circle w = null;
 4         try {
 5             w = (Circle)super.clone();
 6         } catch(CloneNotSupportedException e) {
 7             System.out.println("拷贝圆失败!");
 8         }
 9         return w;
10     }
11     public void countArea() {
12         int r = 0;
13         System.out.print("这是一个圆，请输入圆的半径：");
14         Scanner input = new Scanner(System.in); // 阻塞，等待用户在命令行输入数据回车确认
15         r = input.nextInt();
16         System.out.println("该圆的面积=" + 3.1415 * r * r + "\n");
17     }
18 }

 1 class Square implements Shape {
 2     public Object clone() {
 3         Square b = null;
 4         try {
 5             b = (Square)super.clone();
 6         } catch(CloneNotSupportedException e) {
 7             System.out.println("拷贝正方形失败!");
 8         }
 9         return b;
10     }
11     public void countArea() {
12         int a=0;
13         System.out.print("这是一个正方形，请输入它的边长：");
14         Scanner input = new Scanner(System.in);
15         a = input.nextInt(); 
16         System.out.println("该正方形的面积=" + a * a + "\n");
17     }
18 }

 1 class ProtoTypeManager {
 2     private HashMap<String, Shape>ht=new HashMap<String,Shape>(); 
 3     public ProtoTypeManager() {
 4         ht.put("Circle", new Circle());
 5         ht.put("Square", new Square());
 6     } 
 7     public void addshape(String key,Shape obj) {
 8         ht.put(key,obj);
 9     }
10     public Shape getShape(String key) {
11         Shape temp = ht.get(key);
12         return (Shape) temp.clone();
13     }
14 }

1 public class ProtoTypeShape {
2     public static void main(String[] args) {
3         ProtoTypeManager pm = new ProtoTypeManager();    
4         Shape obj1 = (Circle)pm.getShape("Circle");
5         obj1.countArea();          
6         Shape obj2 = (Shape)pm.getShape("Square");
7         obj2.countArea();     
8     }
9 }

这是一个圆，请输入圆的半径：3
该圆的面积=28.2735
这是一个正方形，请输入它的边长：3

该正方形的面积=9

1 // 抽象产品：提供了产品的接口
2 interface Product {
3     public void show();
4 }

1 //具体产品1：实现抽象产品中的抽象方法
2 class ConcreteProduct1 implements Product {
3     public void show() {
4         System.out.println("具体产品1显示...");
5     }
6 }

1 // 具体产品2：实现抽象产品中的抽象方法
2 class ConcreteProduct2 implements Product {
3     public void show() {
4         System.out.println("具体产品2显示...");
5     }
6 }

1 // 抽象工厂：提供了厂品的生成方法
2 interface AbstractFactory {
3     public Product newProduct();
4 }

1 //具体产品2：实现抽象产品中的抽象方法
2 class ConcreteProduct2 implements Product {
3     public void show() {
4         System.out.println("具体产品2显示...");
5     }
6 }

1 // 抽象工厂：提供了厂品的生成方法
2 interface AbstractFactory {
3     public Product newProduct();
4 }

1 //具体工厂1：实现了厂品的生成方法
2 class ConcreteFactory1 implements AbstractFactory {
3     public Product newProduct() {
4         System.out.println("具体工厂1生成-->具体产品1...");
5         return new ConcreteProduct1();
6     }
7 }

1 //具体工厂2：实现了产品的生成方法
2 class ConcreteFactory2 implements AbstractFactory {
3     public Product newProduct() {
4         System.out.println("具体工厂2生成-->具体产品2...");
5         return new ConcreteProduct2();
6     }
7 }

1 // 抽象产品：动物类
2 interface IAnimal {
3     public void show();
4 }

1 // 具体产品：马类
2 public class Horse implements IAnimal {
3     @Override
4     public void show() {
5         System.out.println("这是一匹马！");
6     }
7 }

// 具体产品：牛类
public class Cattle implements IAnimal {
    @Override
    public void show() {
        System.out.println("这是一头牛！");
    }
}

1 //抽象工厂：畜牧场
2 interface IAnimalFarm {
3     public IAnimal newAnimal();
4 }

1 //具体工厂：养马场
2 class HorseFarm implements IAnimalFarm {
3     public IAnimal newAnimal() {
4         System.out.println("新马出生！");
5         return new Horse();
6     }
7 }

1 //具体工厂：养牛场
2 class CattleFarm implements IAnimalFarm {
3     public IAnimal newAnimal() {
4         System.out.println("新牛出生！");
5         return new Cattle();
6     }
7 }

 1 public class AnimalFarmTest {
 2 
 3     public static void main(String[] args) {
 4         try {
 5             IAnimal a;
 6             IAnimalFarm af = (IAnimalFarm) ReadXML.getObject(HorseFarm.class);
 7             if (af != null) {
 8                 a = af.newAnimal();
 9                 a.show();
10             }
11         } catch (Exception e) {
12             System.out.println(e.getMessage());
13         }
14     }
15 }
16 
17 public class ReadXML {
18     public static Object getObject(Class<?> mClass) {
19         try {
20             return mClass.newInstance();
21         } catch (InstantiationException e) {
22             e.printStackTrace();
23             return null;
24         } catch (IllegalAccessException e) {
25             e.printStackTrace();
26             return null;
27         }
28     }
29 }

新马出生！
这是一匹马！

1 interface AbstractFactory {
2     public Product1 newProduct1();
3     public Product2 newProduct2();
4 }

 1 class ConcreteFactory1 implements AbstractFactory {
 2     public Product1 newProduct1() {
 3         System.out.println("具体工厂 1 生成-->具体产品 11...");
 4         return new ConcreteProduct11();
 5     }
 6     public Product2 newProduct2() {
 7         System.out.println("具体工厂 1 生成-->具体产品 21...");
 8         return new ConcreteProduct21();
 9     }
10 }

1 // 抽象产品：动物类
2 interface Animal {
3     public void show();
4 }

1 // 具体产品：马类
2 class Horse implements Animal {
3     public void show() {
4         System.out.println("这是一匹马");
5     }
6 }

// 具体产品：牛类
class Cattle implements Animal {
    public void show() {
        System.out.println("这是一头牛");
    }
}

1 // 抽象产品：植物类
2 interface Plant {
3     public void show();
4 }

1 // 具体产品：水果类
2 class Fruitage implements Plant {
3     public void show() {
4         System.out.println("这是一水果");
5     }
6 }

1 // 具体产品：蔬菜类
2 class Vegetables implements Plant {
3     public void show() {
4         System.out.println("这是一蔬菜");
5     }
6 }

1 // 抽象工厂：农场类
2 interface Farm {
3     public Animal newAnimal();
4     public Plant newPlant();
5 }

 1 // 具体工厂：韶关农场类
 2 class SGfarm implements Farm {
 3     public Animal newAnimal() {
 4         System.out.println("新牛出生！");
 5         return new Cattle();
 6     }
 7     public Plant newPlant() {
 8         System.out.println("蔬菜长成！");
 9         return new Vegetables();
10     }
11 }

 1 // 具体工厂：上饶农场类
 2 class SRfarm implements Farm {
 3     public Animal newAnimal() {
 4         System.out.println("新马出生！");
 5         return new Horse();
 6     }
 7     public Plant newPlant() {
 8         System.out.println("水果长成！");
 9         return new Fruitage();
10     }
11 }

 1 class Product {
 2     private String partA;
 3     private String partB;
 4     private String partC;
 5     public void setPartA(String partA) {
 6         this.partA=partA;
 7     }
 8     public void setPartB(String partB) {
 9         this.partB=partB;
10     }
11     public void setPartC(String partC) {
12         this.partC=partC;
13     }
14     public void show() {
15         //显示产品的特性
16     }
17 }

 1 abstract class Builder {
 2     //创建产品对象
 3     protected Product product=new Product();
 4     public abstract void buildPartA();
 5     public abstract void buildPartB();
 6     public abstract void buildPartC();
 7     //返回产品对象
 8     public Product getResult() {
 9         return product;
10     }
11 }

 1 public class ConcreteBuilder extends Builder {
 2     public void buildPartA() {
 3         product.setPartA("建造 PartA");
 4     }
 5     public void buildPartB() {
 6         product.setPartA("建造 PartB");
 7     }
 8     public void buildPartC() {
 9         product.setPartA("建造 PartC");
10     }
11 }

 1 class Director {
 2     private Builder builder;
 3     public Director(Builder builder) {
 4         this.builder=builder;
 5     }
 6     //产品构建与组装方法
 7     public Product construct() {
 8         builder.buildPartA();
 9         builder.buildPartB();
10         builder.buildPartC();
11         return builder.getResult();
12     }
13 }

1 public class Client {
2     public static void main(String[] args) {
3         Builder builder = new ConcreteBuilder();
4         Director director = new Director(builder);
5         Product product = director.construct();
6         product.show();
7     }
8 }

 1 // 产品：客厅
 2 class Parlour {
 3     private String wall;    //墙
 4     private String TV;    //电视
 5     private String sofa;    //沙发  
 6     public void setWall(String wall) {
 7         this.wall = wall;
 8     }
 9     public void setTV(String TV) {
10         this.TV = TV;
11     }
12     public void setSofa(String sofa) {
13         this.sofa = sofa;
14     }   
15     public void show() {
16         System.out.println("开始装修客厅");
17     }   
18 }

 1 // 抽象建造者：装修工人
 2 abstract class Decorator {
 3     // 创建产品对象
 4     protected Parlour product = new Parlour();
 5     publicabstract void buildWall();
 6     publicabstract void buildTV();
 7     publicabstract void buildSofa();
 8     //返回产品对象
 9     public  Parlour getResult() {
10         return  product;
11     }
12 }

 1 // 具体建造者：具体装修工人1
 2 class ConcreteDecorator1  extends Decorator {
 3     public void buildWall() {
 4         product.setWall("w1");
 5     }
 6     public void buildTV() {
 7         product.setTV("TV1");
 8     }
 9     public void buildSofa() {
10         product.setSofa("sf1");
11     }
12 }

 1 //具体建造者：具体装修工人2
 2 class ConcreteDecorator2 extends Decorator {
 3       public void buildWall() {
 4           product.setWall("w2");
 5       }
 6       public void buildTV() {
 7           product.setTV("TV2");
 8       }
 9       public void buildSofa() {
10           product.setSofa("sf2");
11       }
12 }

 1 //指挥者：项目经理
 2 class ProjectManager {
 3     private Decorator builder;
 4     public ProjectManager(Decorator builder) {
 5           this.builder = builder;
 6     }
 7     //产品构建与组装方法
 8     public Parlour decorate() {
 9           builder.buildWall();
10           builder.buildTV();
11           builder.buildSofa();
12           return builder.getResult();
13     }
14 }