简单工厂模式,又称静态工厂模式
定义一个用于创建对象的接口类
/**
* 抽象产品角色:
* 它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
* @author javadev
*
*/
public interface Car {
public void driver();
}
/**
* 具体产品角色:
* 工厂类所创建的对象就是此角色的实例。在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
静态工厂方法模式:是由一个具体的工厂类,去创建其他的类对象,该工厂生产的对象的父类(工厂类)是相同的,是具体的。
工厂方法模式:是由一个抽象的工厂定义类,继承该抽象类的子类负责生产对象,这样的好处是将类的实例化延迟到子类中进行。