设计模式

创建型模式：

抽象工厂设计模式：
抽象工厂与抽象产品都只提供抽象方法，具体的产品组合由工厂对象实现完成。
工厂专注于生产产品，不需要关心具体的产品实现；
产品对象关注于设计产品，无需关心使用情况；
该模式有四个角色：抽象工厂、工厂类、抽象产品、产品类。
以下代码描述的是：产品A有两个子产品A1、A2；产品B有两个产品B1、B2；工厂有两个，Factory1 生产A1、B1；Factory2 生产 A2、B2。

 1 abstract class ProductA{
 2     ProductA(){}
 3     public abstract void use();    
 4 }
 5 class ProductA1 extends ProductA{
 6     ProductA1(){}    
 7     public void use(){
 8         System.out.println("A1 use");
 9     }
10 }
11 class ProductA2 extends ProductA{
12     ProductA2(){}    
13     public void use(){
14         System.out.println("A2 use");
15     }
16 }
17 
18 abstract class ProductB{
19     ProductB(){}
20     public abstract void use();
21 }
22 class ProductB1 extends ProductB{
23     ProductB1(){}    
24     public void use(){
25         System.out.println("B1 use");
26     }    
27 }
28 class ProductB2 extends ProductB{
29     ProductB2(){}    
30     public void use(){
31         System.out.println("B2 use");
32     }    
33 }
34 
35 abstract class Factory{
36     Factory(){}
37     public abstract ProductA createProductA();
38     abstract ProductB createProductB();
39 }
40 class Factory1 extends Factory{
41     Factory1(){}
42     public ProductA createProductA(){
43         return new ProductA1();
44     }
45     public ProductB createProductB(){
46         return new ProductB1();
47     }
48 }
49 class Factory2 extends Factory{
50     Factory2(){}
51     public ProductA createProductA(){
52         return new ProductA2();
53     }
54     public ProductB createProductB(){
55         return new ProductB2();
56     }
57 }
58 public class FactoryMain{
59     public static void main(String[] args){
60         Factory f1 = new Factory1();
61         Factory f2 = new Factory2();
62         ProductA A_f1 = f1.createProductA();
63         ProductB B_f1 = f1.createProductB();
64         ProductA A_f2 = f2.createProductA();
65         ProductB B_f2 = f2.createProductB();
66         A_f1.use();
67         B_f1.use();
68         A_f2.use();
69         B_f2.use();
70     }
71 }

View Code

建造者（生成器）模式:

建造者（生成器）模式把类的构建与它的表示分离，使同样的构建过程可以创建不同的表示。
包含四个角色：Builder,Dirctor,ConcreteBuilder,Product

 1 class Meal{
 2     Meal(){}
 3     public String getdrink(){
 4         return drink; 
 5     }
 6     public String getfood(){
 7         return food;
 8     }
 9     public void setdrink(String drink){
10         this.drink = drink;
11     }
12     public void setfood(String food){
13         this.food = food;
14     }
15     public void show(){
16         System.out.println(drink+" "+food);
17     }
18     private String food;
19     private String drink;
20 }
21 interface MealBuilder {
22     abstract public void buildDrink();
23     abstract public void buildFood();
24     abstract public Meal getMeal();
25 }
26 class MealBuilderA implements MealBuilder{
27     MealBuilderA(){
28         meal = new Meal();
29     }
30     public void buildDrink(){
31         meal.setdrink("drink_A");
32     }
33     public void buildFood(){
34         meal.setfood("food_A");
35     }
36     public Meal getMeal(){
37         return meal;
38     }
39     private Meal meal;
40 }
41 class MealBuilderB implements MealBuilder{
42     MealBuilderB(){
43         meal = new Meal();
44     }
45     public void buildDrink(){
46         meal.setdrink("drink_B");
47     }
48     public void buildFood(){
49         meal.setfood("food_B");
50     }
51     public Meal getMeal(){
52         return meal;
53     }
54     private Meal meal;
55 }
56 class KFCDirctor{
57     KFCDirctor(){}
58     public Meal construct(){
59         mb.buildDrink();
60         mb.buildFood();
61         return mb.getMeal();
62     }
63     public void setMealBuilder(MealBuilder mb){
64         this.mb = mb;
65     }
66     private MealBuilder mb;
67 }
68 public class BuilderMain{
69     public static void main(String[] args){
70         MealBuilder mb_A = new MealBuilderA();
71         MealBuilder mb_B = new MealBuilderB();
72         KFCDirctor waiter = new KFCDirctor();
73         waiter.setMealBuilder(mb_A);
74         Meal m_A = waiter.construct();
75         waiter.setMealBuilder(mb_B);
76         Meal m_B = waiter.construct();
77         m_A.show();
78         m_B.show();
79         
80     }
81 }

View Code

结构型模式：

适配器模式：

 1 /*
 2     对象适配器
 3 */
 4 class Target{
 5     Target(){}
 6     public void request(){
 7         System.out.println("request()");
 8     }
 9 }
10 class Adapter extends Target{
11     Adapter(Adaptee adaptee){
12         this.adaptee = adaptee;
13     }
14     public void request(){
15         adaptee.specificRequest();
16     }
17     private Adaptee adaptee;
18 }
19 class Adaptee{
20     Adaptee(){}
21     public void specificRequest(){
22         System.out.println("specificRequest()");
23     }
24 }
25 class Client{
26     Client(Target t){
27         target = t;
28         target.request();
29     }
30     private Target target;
31 }
32 class AdapterMain{
33     public static void main(String[] args){
34         Target t = new Target();
35         Adaptee adaptee = new Adaptee();
36         Adapter adapter = new Adapter(adaptee);
37         new Client(adapter);
38     }
39 }

View Code

外观模式：

该模式有两个角色：Facade（外观角色）、SubSystem(子系统角色)

 1 class Facade{
 2     Facade(){
 3         systemA = new SystemA();
 4         systemB = new SystemB();
 5         systemC = new SystemC();
 6     }
 7     public void operation(){
 8         systemA.operation();
 9         systemB.operation();
10         systemC.operation();
11     }
12     private SystemA systemA;
13     private SystemB systemB;
14     private SystemC systemC;
15 }
16 class SystemA{
17     SystemA(){}
18     public void operation(){
19         System.out.println("SystemA->operation()");
20     }
21 }
22 class SystemB{
23     SystemB(){}
24     public void operation(){
25         System.out.println("SystemB->operation()");
26     }
27 }class SystemC{
28     SystemC(){}
29     public void operation(){
30         System.out.println("SystemC->operation()");
31     }
32 }
33 class FacadeMain{
34     public static void main(String[] args){
35         Facade fa = new Facade();
36         fa.operation();
37     }
38 }

View Code

代理模式：

 1 abstract class Subject{
 2     Subject(){}
 3     public abstract void request(); 
 4 }
 5 class RealSubject extends Subject{
 6     RealSubject(){}
 7     public void request(){
 8         System.out.println("RealSubject->request()");
 9     }
10 }
11 class Proxy extends Subject{
12     Proxy(){}
13     public void prerequest(){
14         System.out.println("Proxy->prerequest()");
15     }
16     public void afterrequest(){
17         System.out.println("Proxy->afterrequest()");
18     }
19     public void request(){
20         prerequest();
21         if(realSubject == null){
22             realSubject = new RealSubject();
23         }
24         realSubject.request();
25         afterrequest();
26     }
27     private RealSubject realSubject = null;
28 }
29 class ProxyMain{
30     public static void main(String[] args){
31         Subject s = new Proxy();
32         s.request();
33     }
34 }

View Code

行为型模式：

中介者模式：把具有复杂关系的对象进行解耦
缺点：具体的中介者类中包含了同事之间的交互细节，这可能导致具体中介者类非常复杂，使得系统难以维护。

 1 import java.util.HashMap;
 2 import java.util.Map;
 3 
 4 abstract class Colleague{
 5     Colleague(){}
 6     public abstract void send(int n,String msg);
 7     public abstract String receive(String msg);
 8     public abstract void setMediator(Mediator m);
 9 }
10 class ColleagueA extends Colleague{
11     ColleagueA(){}
12     public void setMediator(Mediator m){
13         this.m = m;
14     }
15     public void send(int n,String msg){
16         System.out.println("A send: "+msg);
17         m.operate(n,msg);
18     }
19     public String receive(String msg){
20         System.out.println("A receive: "+msg);
21         return msg;
22     }
23     private Mediator m;
24 }
25 class ColleagueB extends Colleague{
26     ColleagueB(){}
27     public void setMediator(Mediator m){
28         this.m = m;
29     }
30     public void send(int n,String msg){
31         System.out.println("B send: "+msg);
32         m.operate(n,msg);
33     }
34     public String receive(String msg){
35         System.out.println("B receive: "+msg);
36         return msg;
37     }
38     private Mediator m;
39 }
40 
41 abstract class Mediator{
42     protected Map<Integer,Colleague> M;
43     Mediator(){}
44     abstract void register(Integer n,Colleague c);
45     abstract void operate(Integer n,String msg);
46 }
47 class Mediator1 extends Mediator{
48     Mediator1(){
49         M = new HashMap<Integer,Colleague>();
50     }
51     public void register(Integer n,Colleague c){
52         M.put(n,c);
53         c.setMediator(this);
54     }
55     public void operate(Integer n,String msg){
56         Colleague c = M.get(n);
57         if(c!=null){
58             c.setMediator(this);
59             c.receive(msg);
60         }else{
61             System.out.println("receive is not exist.");
62         }
63     }
64 }
65 class MediatorMain{
66     public static void main(String[] args){
67         Colleague A = new ColleagueA();
68         Colleague B = new ColleagueB();
69         Mediator M = new Mediator1();
70         M.register(1,A);
71         M.register(2,B);
72         A.send(2,"Hello,I'm A.");
73         B.send(1,"Hello,I'm B.");
74     }
75 }

View Code

posted @ 2016-04-24 15:25 YoZane 阅读(149) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

yuanzhenliu

设计模式

创建型模式：

结构型模式：

行为型模式：

公告