工厂模式认知

简单工厂模式，又称静态工厂模式

定义一个用于创建对象的接口类

/** * 抽象产品角色： * 它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。 * @author javadev * */public interface Car {public void driver();}

对象A,B...实现该接口

/** * 具体产品角色： * 工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。 * @author javadev * */public class BenzCar implements Car {//构造函数public BenzCar(){System.out.println("make BenzCar");}//对象的具体行为@Overridepublic void driver() {// TODO Auto-generated method stubSystem.out.println("driver BenzCar....");}}

/** * 具体产品角色： * 工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。 * @author javadev * */public class BMW implements Car {//构造函数public BMW(){System.out.println("make BWM car");}//对象的具体行为@Overridepublic void driver() {// TODO Auto-generated method stubSystem.out.println("driver BWM car...");}}

/** * 工厂类，工厂类一旦出现错误，整个系统将会受到影响 * 扩展不好，一旦新增一个产品，将要修改工厂类的逻辑，造成工厂类内逻辑过于复杂，不利扩展与维护。 * 使用了静态工厂方法，无法继承。 * 工厂类角色： * 这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现 * @author javadev * */public class SimpleFactory {public static Car carFactory(int type){if(type==1){return new BenzCar();}else{return new BMW();}}public static void main(String[] args) {// TODO Auto-generated method stubCar car = SimpleFactory.carFactory(1);car.driver();}}

执行结果：

make BenzCar
driver BenzCar....

工厂模式：

工厂模式是静态工厂模式的进一步抽象化与推广，工厂模式将不再只由一个工厂类决定哪一个产品类被实例化，这个决定将交给抽象工厂类的子类。

抽象产品：

/** * 抽象产品 * @author javadev * */public interface PlaneInterface {public void fly();}

具体产品：

/** * 具体产品：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 * @author javadev * */public class PlaneA implements PlaneInterface {//构造函数public PlaneA(){System.out.println("make one planeA");}//飞机动作@Overridepublic void fly() {// TODO Auto-generated method stubSystem.out.println("planeA flying...");}}

/** * 具体产品角色 * 它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 * @author javadev * */public class PlaneB implements PlaneInterface {<span style="white-space:pre"></span>//构造函数<span style="white-space:pre"></span>public PlaneB(){<span style="white-space:pre"></span>System.out.println("make one planeB");<span style="white-space:pre"></span>}<span style="white-space:pre"></span>//对象行为<span style="white-space:pre"></span>@Override<span style="white-space:pre"></span>public void fly() {<span style="white-space:pre"></span>// TODO Auto-generated method stub<span style="white-space:pre"></span>System.out.println("planeB flying...");<span style="white-space:pre"></span>}}

抽象工厂

/** * 抽象工厂 * 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 * @author javadev * */public abstract class AbstractPlane {abstract PlaneInterface craeatPlane();}

具体工厂

/** * PlanA具体工厂 * 具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 * @author javadev * */public class PlaneAFactory extends AbstractPlane {//生成planeA@OverridePlaneInterface craeatPlane() {// TODO Auto-generated method stubreturn new PlaneA();}}

/** * PlanB具体工厂 * 具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 * @author javadev * */public class PlaneBFactory extends AbstractPlane {//PlaneB工厂,生成PlaneB@OverridePlaneInterface craeatPlane() {// TODO Auto-generated method stubreturn new PlaneB();}}

测试类：

public class TestFactoryModel {public static void main(String[] args) {//通过抽象类创建 飞机工厂AbstractPlane factory = new PlaneAFactory();//通过飞机工厂中的方法创建飞机实例PlaneInterface planeA =  factory.craeatPlane();//调用飞机实例调用方法planeA.fly();}}

测试结果：

make one planeA
planeA flying...

抽象工厂模式：

抽象工厂模式中，抽象产品可以有一个或者多个，从而构成一个或者多个产品族，当只有一个产品族的时候，抽象工厂方法退化到工厂方法模式。

抽象产品：

/** * 飞船产品接口 * @author javadev * */public interface AirShipInterface {public void distantFlying();}

具体产品：

/** * 具体产品 * @author javadev * */public class AirShipA implements AirShipInterface {@Overridepublic void distantFlying() {// TODO Auto-generated method stubSystem.out.println("to moon");}//构造函数public AirShipA() {// TODO Auto-generated method stubSystem.out.println("make a airShipA");}}

多个抽象产品族：

/** * 抽象工厂 * 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 * @author javadev * */public abstract class AbstractPlane {//飞机abstract PlaneInterface craeatPlane();//飞船abstract AirShipInterface creatAirShip();}

具体工厂：

/** * PlanA，飞船A具体工厂 * 具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 * @author javadev * */public class PlaneAFactory extends AbstractPlane {//生成planeA@OverridePlaneInterface craeatPlane() {// TODO Auto-generated method stubreturn new PlaneA();}//生成飞船A@OverrideAirShipInterface creatAirShip() {// TODO Auto-generated method stubreturn new AirShipA();}}

测试类：

public class TestFactoryModel {public static void main(String[] args) {//通过抽象类创建 飞机工厂AbstractPlane factory = new PlaneAFactory();//通过飞机工厂中的方法创建飞机实例PlaneInterface planeA =  factory.craeatPlane();//调用飞机实例调用方法planeA.fly();//通过飞机工厂中的方法创建飞船实例AirShipInterface airShipA =  factory.creatAirShip();//调用飞船实例调用方法airShipA.distantFlying();}}

测试结果：

make one planeA
planeA flying...
make a airShipA
to moon

静态工厂方法模式：是由一个具体的工厂类，去创建其他的类对象，该工厂生产的对象的父类（工厂类）是相同的，是具体的。

工厂方法模式：是由一个抽象的工厂定义类，继承该抽象类的子类负责生产对象，这样的好处是将类的实例化延迟到子类中进行。