工厂方法模式-大话设计模式

1.OO原则：

      (1)OCP：开闭原则Open-Closed Principle，一个软件的实体对扩展开放，对修改关闭。即对一个已有的软件，如果需要扩展，应当在不需要修改已有代码的基础上进行。

      (2)DIP：依赖倒转原则 Dependence Inversion Principle，要针对接口编程，而不要针对实现编程。

      (3)LoD：迪米特法则 Law of Demeter，只与你直接的朋友通信，而避免和陌生人通信。

2.工厂方法模式角色

      (1)抽象工厂角色：工厂方法模式的核心，与应用程序无关。

      (2)具体工厂角色：

      (3)抽象产品角色：

      (4)具体产品角色：

3.简单实例：

      (1)产品Plant接口

//产品Plant接口public interface Plant {}

      (2)具体产品PlantA,PlantB

//具体产品PlantApublic class PlantA implements Plant {      public PlantA () {            System.out.println("creat PlantA");      }      public void doSomething () {            System.out.println("PlantA do something...");      }}//具体产品PlantBpublic class PlantB implements Plant {      public PlantB () {           System.out.println("creat PlantB");      }             public void doSomething () {           System.out.println("PlantB do something...");}             }

      (3)产品Fruit接口

package model;//产品Fruit接口public interface Fruit {}

      (4)具体产品FruitA,FruitB

//具体产品FruitApublic class FruitA implements Fruit {public FruitA () {System.out.println ("create FruitA");}public void doSomething () {System.out.println ("FruitA do something...");}}//具体产品FruitBpublic class FruitB implements Fruit {public FruitB () {System.out.println ("create FruitB");}public void doSomething () {System.out.println ("FruitB do something...");}}

      (5)抽象工厂方法

//抽象工厂方法public interface AbstractFactory {public Plant createPlant();public Fruit createFruit();}

      (6)具体工厂方法

//具体工厂方法public class FactoryA implements AbstractFactory {@Overridepublic Plant createPlant() {return new PlantA();}@Overridepublic Fruit createFruit() {return new FruitA();}}public class FactoryB implements AbstractFactory {@Overridepublic Plant createPlant() {return new PlantB();}@Overridepublic Fruit createFruit() {return new FruitB();}}

4.简单工厂模式与工厂方法模式比较：

      (1)简单工厂模式：静态工厂模式，用来实例化目标类的静态类。实例如下：

//运动员public interface player {public void run();public void jump();}

//足球运动员public class soccer implements player {        @Override        public void run() {                }        @Override        public void jump() {                }}

//篮球运动员//篮球运动员public class baskerballer implements player {@Overridepublic void run() {}@Overridepublic void jump() {}}

///体育协会  注册运动员public class game {public static player createSoccer() {return new soccer();}public static player createBask() {return new baskerballer();}}

//俱乐部public class club {private player shouMen;private player houWei;private player qianFeng;public void test() {this.qianFeng = game.createSoccer();this.houWei = game.createSoccer();this.shouMen = game.createSoccer();shouMen.run();houWei.jump();}}

        这是简单工厂模式的一个简单实例，不用接口不用工厂把具体类暴露给客户端的混乱情形；如果增加一个“乒乓球运动员”产品类，就必须修改“体育协会”工厂类，增加个“注册乒乓球运动员”方法。所以可以看出简单工厂模式是不完全满足OCP的。

      (3)工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个工厂类，而工厂方法模式有一组实现了相同接口的工厂类，下例子介绍工厂方法的一个实现。

//运动员public interface player {public void run();public void jump();}//足球运动员public class soccer implements player {@Overridepublic void run() {}@Overridepublic void jump() {}} //篮球运动员public class baskerballer implements player {@Overridepublic void run() {}@Overridepublic void jump() {}}

//体育协会 注册//体育协会 注册public interface game {public player zhuCe();}//足球协会public class soccerGame implements game {@Overridepublic player zhuCe() {return new soccer();}}//篮球协会public class baskerballerGame implements game {@Overridepublic player zhuCe() {return new baskerballer();}}

//俱乐部public class club {private player shouMen;private player houWei;public void test() {game chinaGame = new soccerGame();this.shouMen = chinaGame.zhuCe();this.houWei = chinaGame.zhuCe();shouMen.run();houWei.jump();}}

      “体育协会”工厂类变成了“体育协会接口”，实现此接口的分别是“足球协会”和"篮球协会"具体的工厂类。这样就完全OCP，如果在需要加入产品类，不在需要修改工厂类，而只需相应的添加一个实现工厂接口的具体工厂类。