工厂模式学习

目录

工厂模式

简单工厂模式

         工厂方法模式

抽象工厂模式

---

 

---

工厂模式

把项目中对象的实例化部分抽取出来单独进行处理和设计

简单工厂模式

概括：首先创建一个产品抽象类，每一个具体产品实现这个抽向类；再创建一个工厂来创建每一个产品的实例（简单工厂模式并不属于 GOF 定义的 23 种设计模式）

披萨工厂

public class SimplePizzaFactory {

	public Pizza CreatePizza(String ordertype) {
		Pizza pizza = null;

		if (ordertype.equals("cheese")) {
			pizza = new CheesePizza();
		} else if (ordertype.equals("greek")) {
			pizza = new GreekPizza();
		} else if (ordertype.equals("pepper")) {
			pizza = new PepperPizza();
		}
		return pizza;

	}

}

public class OrderPizza {
	SimplePizzaFactory mSimplePizzaFactory;

	public OrderPizza(SimplePizzaFactory mSimplePizzaFactory) {

		setFactory(mSimplePizzaFactory);
	}

	public void setFactory(SimplePizzaFactory mSimplePizzaFactory) {
		Pizza pizza = null;
		String ordertype;

		this.mSimplePizzaFactory = mSimplePizzaFactory;

		do {
			ordertype = gettype();
			pizza = mSimplePizzaFactory.CreatePizza(ordertype);
			if (pizza != null) {
				pizza.prepare();
				pizza.bake();
				pizza.cut();
				pizza.box();
			}

		} while (true);

	}

	private String gettype() {
		try {
			BufferedReader strin = new BufferedReader(new InputStreamReader(
					System.in));
			System.out.println("input pizza type:");
			String str = strin.readLine();

			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}

}

使用

public class PizzaStroe {
	public static void main(String[] args) {
		SimplePizzaFactory mSimplePizzaFactory;
		OrderPizza mOrderPizza;
		mOrderPizza=new	OrderPizza(new SimplePizzaFactory());	
	}
}

有哪些不足？

当添加新的一种披萨时要修改工厂类，添加if else

 

工厂方法模式

public abstract class OrderPizza {

	public OrderPizza() {
		Pizza pizza = null;
		String ordertype;

		do {
			ordertype = gettype();
			pizza = createPizza(ordertype);

			pizza.prepare();
			pizza.bake();
			pizza.cut();
			pizza.box();
		} while (true);
	}

	abstract Pizza createPizza(String ordertype);

	private String gettype() {
		try {
			BufferedReader strin = new BufferedReader(new InputStreamReader(
					System.in));
			System.out.println("input pizza type:");
			String str = strin.readLine();

			return str;
		} catch (IOException e) {
			e.printStackTrace();
			return "";
		}
	}

}

具体实现

public class NYOrderPizza extends OrderPizza {
	@Override
	Pizza createPizza(String ordertype) {
		Pizza pizza = null;

		if (ordertype.equals("cheese")) {
			pizza = new NYCheesePizza();
		} else if (ordertype.equals("pepper")) {
			pizza = new NYPepperPizza();
		}
		return pizza;
	}
}

使用

public class PizzaStroe {
	public static void main(String[] args) {
		OrderPizza mOrderPizza;
		mOrderPizza=new	NYOrderPizza();
	}
}

 

抽象工厂模式

提供一个创建一系列相关或相互依赖对象的接口而无需指定他们具体的类

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

实现：

1.创建一个汽车工厂的抽象类，根据汽车轮胎，发动机，制动器的不同可以有不同型号的汽车，三者都可以分为一般品质和高级品质，创建轮胎的接口，不同品质的轮胎可以分别实现。发动机和制动器同理

public abstract class CarFactory {

    /**
     * 轮胎
     * @return
     */
    public abstract Tyre createTyre();

    /**
     * 发动机
     * @return
     */
    public abstract Motor createMotor();

    /**
     * 制动器
     * @return
     */
    public abstract Brake createBrake();
}

public interface Tyre {
}

public class CommonTyre implements Tyre{
}

public class GreateTyre implements Tyre {
}

2.X5系列和X7系列分别实现汽车抽象类，X5为例，X5使用一般品质的轮胎发动机和制动器

public class X5CarFactory extends CarFactory {
    @Override
    public Tyre createTyre() {
        return new CommonTyre();
    }

    @Override
    public Motor createMotor() {
        return new CommonMotor();
    }

    @Override
    public Brake createBrake() {
        return new CommonBrake();
    }
}

3.创建一个工厂生产类，根据不同订单型号返回X5和X7工厂

public class CarFactoryProducter {
    public static CarFactory getCarFatory(String type){
        if("X5".equals(type)){
            return new X5CarFactory();
        }else {
            return new X7CarFactory();
        }
    }
}

4.使用，创建一个汽车订单类，根据订单型号X5获取汽车工厂，生产对应的发动机轮胎制动器组装汽车

public class CarOrder {
    public static void main(String[] args) {
        CarFactory x5 = CarFactoryProducter.getCarFatory("X5");
        Brake brake = x5.createBrake();
        Motor motor = x5.createMotor();
        Tyre tyre = x5.createTyre();
        Car car = new Car(tyre, motor, brake);
    }
}

以上源代码见git：https://github.com/hounk801/design-pattern/tree/master/src/main/java/hounk/factory

依赖抽象原则

参考：

大话设计模式

菜鸟教程：https://www.runoob.com/design-pattern/abstract-factory-pattern.html

知识星球——java极客技术：可扫码加入