设计模式之工厂模式-工厂方法（02）

接着上一篇的工厂模式，工厂方法。由于简单工厂的扩展性不好，下面工厂方法，在这上面有了优化！

（二）工厂方法（多态工厂模式）

　　工厂方法描述：定义一个创建产品对象的工厂接口（总厂是接口，里面只规定了获得具体产品实例的方法），实际创建工作推迟到实现总厂接口的子类（分厂）当中。这样的好处是，可以在不修改具体工厂角色的情况下引进新的产品（即是不像简单工厂那样，增加一个具体产品，比如：增加了个浙大学生，要把在工厂中的方法中增加逻辑判断，），利于维护了；

　　工厂方法的角色及其职责：（1）抽象工厂角色[creator]:该模式的核心（总厂），任何工厂（分厂）都必须实现这个接口（2）具体工厂角色[concrete creator](即分厂)：具体工厂类是抽象工厂的一个实现，负责实例化产品对象；（3）抽象产品角色[product]:工厂方法所创建的所有对象的父类，他负责描述所有实例所共有的公共接口（4）具体产品[concrete product]:所创建的具体实例对象

（1）抽象工厂角色（总厂）

 1 package com.pattern.factory.method1;
 2 
 3 //抽象工厂角色类,具体的实例，去实现该接口的子类中获取
 4 //获得学生的工厂
 5 public interface StudentFactory {
 6     
 7     //获得学生的方法
 8     Student getStudent();
 9     
10 }
View Code

（2）具体工厂角色（分厂）

　　2.1）博士生工厂

 1 package com.pattern.factory.method1;
 2 
 3 //获得博士生的工厂
 4 public class DoctoralStudentFactory implements StudentFactory {
 5 
 6     @Override
 7     public Student getStudent() {
 8         
 9         return new DoctoralStudent();
10     }
11     
12 }
View Code

　  2.2）研究生工厂

 1 package com.pattern.factory.method1;
 2 
 3 //获得研究生的工厂
 4 public class GraduateStudentFactory implements StudentFactory {
 5 
 6     @Override
 7     public Student getStudent() {
 8         
 9         return new GraduateStudent();
10     }
11     
12 }
View Code

　  2.3）大学生工厂

 1 package com.pattern.factory.method1;
 2 
 3 //获得大学生的工厂
 4 public class UndergraduateStudentFactory implements StudentFactory {
 5 
 6     @Override
 7     public Student getStudent() {
 8         
 9         return new UndergraduateStudent();
10     }
11     
12 }
View Code

（3）抽象产品角色（三类学生）

1 package com.pattern.factory.method1;
2 
3 //学生接口
4 //抽象角色
5 public interface Student {
6     //显示一下
7     void show();
8 }
View Code

（4）具体产品

 　　4.1） 博士生

 1 package com.pattern.factory.method1;
 2 
 3 //博士生
 4 public class DoctoralStudent implements Student {
 5 
 6     @Override
 7     public void show() {
 8         System.out.println("博士生");
 9     }
10 
11 }
View Code

　4.2）研究生

 1 package com.pattern.factory.method1;
 2 
 3 //研究生
 4 public class GraduateStudent implements Student {
 5 
 6     @Override
 7     public void show() {
 8         System.out.println("研究生");
 9     }
10 
11 }
View Code

　　4.3）大学生

 1 package com.pattern.factory.method1;
 2 
 3 //大学生
 4 public class UndergraduateStudent implements Student {
 5 
 6     @Override
 7     public void show() {
 8         System.out.println("大学生");
 9     }
10 
11 }
View Code

测试代码：

 1 package com.pattern.factory.method1;
 2 
 3 public class Test {
 4     
 5     public static void main(String[] args) {
 6         
 7         //1.招博士生，直接去博士工厂，
 8         DoctoralStudentFactory doctoralStudentFactory = new DoctoralStudentFactory();
 9         Student doctoralStu = doctoralStudentFactory.getStudent();
10         doctoralStu.show();
11         
12         //2.招研究生，直接去研究生工厂，
13         GraduateStudentFactory graduateStudentFactory = new GraduateStudentFactory();
14         Student GraduateStu = graduateStudentFactory.getStudent();
15         GraduateStu.show();
16         
17         //3.大学生，大学生厂
18         UndergraduateStudentFactory undergraduateStudentFactory = new UndergraduateStudentFactory();
19         Student undergraduateStu = undergraduateStudentFactory.getStudent();
20         undergraduateStu.show();
21     
22     }
23     
24 }
View Code

测试结果：

总结：总厂是接口，分厂实现接口，抽象产品规定公共的行为，具体产品表现自己的内容；每个分厂对应生产一个具体的产品；

下一篇：抽象工厂

posted @ 2017-03-10 23:47  花雪依蒿  阅读(151)  评论(0)  编辑  收藏  举报