什么是工厂模式(什么是工厂模式和单例模式)

工厂模式是我们开发中用的比较多的设计模式，在spring框架到处可以看得到工厂模式，工厂模式属于创建型的模式，一种批量创建对象的模式。工厂模式又分为简单工厂模式和抽象工厂模式。

1.简单工厂模式属于工厂模式的一种，简单工厂模式是有一个工厂对象决定创建哪一中产品类的实例。

简单的工厂模式，定义了一个创建对象的类，这个类来封装实例化对象的代码。

在软件开发中，当我们用到大量的创建某种，某类或者某一批对象时候就会选择工厂模式。也叫静态工厂模式。

这里我们引入一个制作pizza例子。来演示一下工厂模式。

这里首先写一个PIZZA抽象类，prepare方法，各个有所不同需要子类去实现

public abstract class Pizza { protected String name; public abstract void prepare(); public void bake(){ System.out.println(name+"baking"); } public void cut(){ System.out.println(name+"cutting;"); } public void tName(String name) { this.name = name; }}

public class CheePizza extends Pizza{ @Override public void prepare() { System.out.println("给只做奶酪披萨，准备原材料"); }}

public class GreekPizza extends Pizza{ @Override public void prepare() { System.out.println("给只希腊披萨，准备原材料"); }}

public class PepperPizza extends Pizza { @Override public void prepare() { System.out.println("给只做胡椒披萨，准备原材料"); }}

定义一个工厂类，用来创建不同口味的Pizza

public class SimpleFactory { public Pizza createPizza(String orderType){ Pizza pizza = null; System.out.println("使用简单的工厂模式"); if (orderType.equals("greek")){ pizza = new GreekPizza(); pizza.tName("希腊披萨"); }el if(orderType.equals("chee")) { pizza = new CheePizza(); pizza.tName("奶酪披萨"); }el if(orderType.equals("pepper")){ pizza = new PepperPizza(); pizza.tName("胡椒披萨"); } return pizza; }}

调用方

public class OrderSimPizza { SimpleFactory simpleFactory; Pizza pizza = null; public OrderSimPizza(SimpleFactory factory){ tSimpleFactory(factory); } public void tSimpleFactory(SimpleFactory simpleFactory) { String orderType = simpleFactory.getOrderType(); this.simpleFactory = simpleFactory; pizza = simpleFactory.createPizza(orderType); if (pizza !=null){ pizza.prepare(); pizza.bake(); pizza.cut(); }el{ System.out.println("制造pizza失败"); } }}

main方法

public static void main(String[] args) { SimpleFactory simpleFactory = new SimpleFactory(); simpleFactory.tOrderType("greek"); new OrderSimPizza(simpleFactory);}

如果新增加一个pizza，我只需要修改一下工厂类即可，这也就实现了增加一个品类了。

披萨项目的新的需求，客户在点餐时，可以点不同口味的披萨，比如说北京的奶酪披萨，伦敦奶酪披萨，

如果使用简单的工厂模式，需要创建不同的工厂类，比如说BJPizzaFactrory ,LDPizzaSimpleFactory等等，从当前的这个案例来说，也是可以的，当时考虑项目的规模和可维护，可扩展性，并不是特别的好，这个时候，就可以考虑工厂方法模式。

所谓的工厂方法模式，将对象的实例化功能抽象成抽象方法，有具体的子类去实现。

工厂方法模式，定义一个创建对象的抽象方法，由子类决定要实例化的类，工厂方法模式将对象实例化推迟到子类。

1.定义一个包含抽象方法的抽象类。

public class BJOrderPizza extends OrderPizza{ public BJOrderPizza(String orderType) { super(orderType); } @Override public Pizza createPizza(String orderType) { Pizza pizza = null; if (orderType.equals("chee")){ pizza = new BJCheePizza(); }el if(orderType.equals("pepper")){ pizza = new BJPapperPizza(); } return pizza; }}

2.定义2个子类去继承这个抽象方法

public class LDOrderPizza extends OrderPizza { public LDOrderPizza(String orderType) { super(orderType); } @Override public Pizza createPizza(String orderType) { Pizza pizza = null; if (orderType.equals("chee")){ pizza = new LDCheePizza(); }el if(orderType.equals("pepper")){ pizza = new LDPapperPizza(); } return pizza; }}

public class BJOrderPizza extends OrderPizza{ public BJOrderPizza(String orderType) { super(orderType); } @Override public Pizza createPizza(String orderType) { Pizza pizza = null; if (orderType.equals("chee")){ pizza = new BJCheePizza(); }el if(orderType.equals("pepper")){ pizza = new BJPapperPizza(); } return pizza; }}

定义一些具体要实现的类

public class BJCheePizza extends Pizza { @Override public void prepare() { System.out.println("北京的奶酪,准备原材料"); }}

public class BJPapperPizza extends Pizza { @Override public void prepare() { tName("北京的胡椒披萨"); System.out.println("北京的胡椒披萨，准备原材料"); }}

public class LDCheePizza extends Pizza { @Override public void prepare() { tName("伦敦的奶酪披萨"); System.out.println("伦敦的奶酪披萨正在准备中"); }}

public class LDPapperPizza extends Pizza { @Override public void prepare() { tName("伦敦的胡椒披萨"); System.out.println("伦敦的胡椒披萨正在准备中"); }}抽象工厂模式

1.抽象工厂模式，定义一个interface 用于创建相关的或者有依赖关系的对象簇，而无需指明具体的类

2.抽象工厂模式，可以将简单工厂模式和工厂方法模式进行一个结合

3.从设计层面看，抽象工厂模式就是简单工厂模式的改进，或者说进一步的抽象。

4.抽象工厂模式，将工厂抽象成2层，AbsFactory和具体实现的子类，程序员可以根据创建类型使用对应的工厂子类。这样可以将单个简单的工厂变成工厂簇，更加有利于代码的维护和扩展。

代码的实现部分

1.创建一个抽象工厂的接口

public interface AbsFactory { public Pizza createPizza(String orderType);}

2.创建抽象工厂的实现类

public class BJFactory implements AbsFactory{ @Override public Pizza createPizza(String orderType) { Pizza pizza = null; if (orderType.equals("chee")){ pizza = new BJCheePizza(); }el if(orderType.equals("pepper")){ pizza = new BJPapperPizza(); } return pizza; }}

@Overridepublic Pizza createPizza(String orderType) { Pizza pizza = null; if (orderType.equals("chee")){ pizza = new LDCheePizza(); }el if(orderType.equals("pepper")){ pizza = new LDPapperPizza(); } return pizza;}

创建调用方，具体实施要创建的类

public class OrderPizza { private AbsFactory factory; private String orderType; public void tFactory(AbsFactory factory){ this.factory = factory; } public AbsFactory getFactory() { return factory; } public void tOrderType(String orderType) { this.orderType = orderType; Pizza pizza = null; pizza = factory.createPizza(orderType); if (pizza !=null){ pizza.prepare(); pizza.bake(); pizza.cut(); } }}

主方法的入口

public static void main(String[] args) { OrderPizza orderPizza = new OrderPizza(); orderPizza.tFactory(new LDFactory()); orderPizza.tOrderType("chee");}