工厂模式认知

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

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

/**
 * 抽象产品角色：
 * 它一般是具体产品继承的父类或者实现的接口。在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");
	}
	//对象的具体行为
	@Override
	public void driver() {
		// TODO Auto-generated method stub
		System.out.println("driver BenzCar....");
	}

}

/**
 * 具体产品角色：
 * 工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。
 * @author javadev
 *
 */
public class BMW implements Car {
	//构造函数
	public BMW(){
		System.out.println("make BWM car");
	}
	//对象的具体行为
	@Override
	public void driver() {
		// TODO Auto-generated method stub
		System.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 stub
		Car 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");
	}
	//飞机动作
	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.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
	@Override
	PlaneInterface craeatPlane() {
		// TODO Auto-generated method stub
		return new PlaneA();
	}

}

/**
 * PlanB具体工厂
 * 具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
 * @author javadev
 *
 */
public class PlaneBFactory extends AbstractPlane {

	//PlaneB工厂,生成PlaneB
	@Override
	PlaneInterface craeatPlane() {
		// TODO Auto-generated method stub
		return 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 {

	@Override
	public void distantFlying() {
		// TODO Auto-generated method stub
		System.out.println("to moon");
	}
	//构造函数
	public AirShipA() {
		// TODO Auto-generated method stub
		System.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
	@Override
	PlaneInterface craeatPlane() {
		// TODO Auto-generated method stub
		return new PlaneA();
	}
	//生成飞船A
	@Override
	AirShipInterface creatAirShip() {
		// TODO Auto-generated method stub
		return 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

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

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