设计模式之工厂模式-抽象工厂（02）

（三）抽象工厂

　　抽象共厂的描述：抽象工厂是所有形态的工厂模式中最为抽象和最具一般性的。它可以向客户端提供一个接口，是的客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象；

　　抽象工厂的角色及其职责：（1）抽象工厂的角色[creator]:抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类型都必须实现这个接口（2）具体工厂[Concrete creator]：具体工厂是抽象工厂的一个实现，扶着实例化某个产品族中的产品对象。（3）抽象产品角色[product]:所有实例的共有的公共接口；（4）具体产品[Concrete product]：具体实例对象。

（1）抽象工厂的角色

 1 package com.pattern.factory.abstrac1;
 2 
 3 //抽象工厂角色类,相对于工厂方法，子类分厂中不在是只获得一个类型的学生
 4 //获得学生的工厂
 5 public interface StudentFactory {
 6     
 7     //获得博士生
 8     Student getDoctoralStudent();
 9     //获得研究生
10     Student getGraduateStudent();
11     //获得大学生
12     Student getUnderGraduateStudent();
13     
14 }
View Code

工厂方法的工厂只生产一种类型的产品，而抽象工厂生产的产品更加丰富些；

（2）具体工厂

　　2.1）北大工厂

 1 package com.pattern.factory.abstrac1;
 2 
 3 //北大（Peking University）工厂，北大里的博士，研究，大学生
 4 public class PekingUStudentFactory implements StudentFactory {
 5 
 6     @Override
 7     public Student getDoctoralStudent() {
 8         
 9         return new PekingDoctoralStudent();
10     }
11 
12     @Override
13     public Student getGraduateStudent() {
14         
15         return new PekingGraduateStudent();
16     }
17 
18     @Override
19     public Student getUnderGraduateStudent() {
20         
21         return new PekingUndergraduateStudent();
22     }
23 
24     
25 
26 }
View Code

　　2.2）复旦工厂

 1 package com.pattern.factory.abstrac1;
 2 
 3 //复旦工厂，复旦里的博士，研究，大学生
 4 public class FudanUStudentFactory implements StudentFactory {
 5     
 6     //获得复旦博士生
 7     @Override
 8     public Student getDoctoralStudent() {
 9         
10         return new FudanDoctoralStudent();
11     }
12     //获得复旦研究生
13     @Override
14     public Student getGraduateStudent() {
15         
16         return new FudanGraduateStudent();
17     }
18     
19     //获得复旦大学生
20     @Override
21     public Student getUnderGraduateStudent() {
22         
23         return new FudanUndergraduateStudent();
24     }
25 
26 }
View Code

（3）抽象产品角色

　　3.1）所有抽象产品的公共的接口（学生的接口）

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

　　3.2）不同类型产品的抽象类1（博士生的抽象类）

1 package com.pattern.factory.abstrac1;
2 
3 //博士生类亦被抽象出来，同时实现学生类
4 public abstract class DoctoralStudent implements Student{
5     
6     public abstract void show();
7     
8 }
View Code

　　3.3）不同类型产品的抽象类2（研究生的抽象类）

1 package com.pattern.factory.abstrac1;
2 
3 //研究生
4 public abstract class GraduateStudent implements Student {
5 
6     @Override
7     public abstract void show();
8 
9 }
View Code

　　3.3）不同类型产品的抽象类3（大学生的抽象类）

1 package com.pattern.factory.abstrac1;
2 
3 //大学生
4 public abstract class UndergraduateStudent implements Student {
5 
6     @Override
7     public abstract void show();
8 
9 }
View Code

（4）具体产品

　　4.1）北大工厂的具体产品（北大博士生，研究生，大学生）

 1 package com.pattern.factory.abstrac1;
 2 
 3 //北大博士生
 4 public class PekingDoctoralStudent extends DoctoralStudent {
 5 
 6     @Override
 7     public void show() {
 8         System.out.println("北大博士生");
 9     }
10     
11 }
View Code
 1 package com.pattern.factory.abstrac1;
 2 
 3 //北大研究生
 4 public class PekingGraduateStudent extends DoctoralStudent {
 5 
 6     @Override
 7     public void show() {
 8         System.out.println("北大研究生");
 9     }
10     
11 }
View Code
 1 package com.pattern.factory.abstrac1;
 2 
 3 //北大大学生
 4 public class PekingUndergraduateStudent extends DoctoralStudent {
 5 
 6     @Override
 7     public void show() {
 8         System.out.println("北大大学生");
 9     }
10     
11 }
View Code

　　4.2）复旦工厂的具体产品（复旦博士生，研究生，大学生）

 1 package com.pattern.factory.abstrac1;
 2 
 3 //复旦博士生
 4 public class FudanDoctoralStudent extends DoctoralStudent {
 5 
 6     @Override
 7     public void show() {
 8         System.out.println("复旦博士生");
 9     }//获得复旦大学生
10 
11 }
View Code
 1 package com.pattern.factory.abstrac1;
 2 
 3 //复旦研究生
 4 public class FudanGraduateStudent extends DoctoralStudent {
 5 
 6     @Override
 7     public void show() {
 8         System.out.println("复旦大学生");
 9     }
10 
11 }
View Code
 1 package com.pattern.factory.abstrac1;
 2 
 3 //复旦研究生
 4 public class FudanUndergraduateStudent extends DoctoralStudent {
 5 
 6     @Override
 7     public void show() {
 8         System.out.println("复旦研究生");
 9     }
10 
11 }
View Code

测试代码

 1 package com.pattern.factory.abstrac1;
 2 
 3 public class Test {
 4     
 5     public static void main(String[] args) {
 6         
 7         //现在具体的工厂两个，北大工厂，复旦工厂，两个工厂里都产博士生，研究生，大学生
 8         //1.先创建 北大工厂
 9         StudentFactory pekingUStudentFactory = new PekingUStudentFactory();
10         //获得北大的博士生
11         Student doctoralStudent = pekingUStudentFactory.getDoctoralStudent();
12         doctoralStudent.show();
13         //获得北大的研究生
14         Student graduateStudent = pekingUStudentFactory.getGraduateStudent();
15         graduateStudent.show();
16         //获得北大大学生
17         Student underGraduateStudent = pekingUStudentFactory.getUnderGraduateStudent();
18         underGraduateStudent.show();
19         
20         //同理获得复旦工厂，获得里面的学生
21         StudentFactory fudanUStudentFactory = new FudanUStudentFactory();
22         Student doctoralStudent2 = fudanUStudentFactory.getDoctoralStudent();
23         doctoralStudent2.show();
24         
25         Student graduateStudent2 = fudanUStudentFactory.getGraduateStudent();
26         graduateStudent2.show();
27         
28         Student underGraduateStudent2 = fudanUStudentFactory.getUnderGraduateStudent();
29         underGraduateStudent2.show();
30         
31 
32     }
33     
34 }
View Code

结果：

 

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