JAVA设计模式--创造型模式--工厂模式

目录

1、简单工厂模式（Simple Factory）

简单工厂模式的优缺点

2、工厂方法模式（Factory Method）

工厂方法模式的优缺点

3、抽象工厂模式（Abstract Factory）

4、工厂方法模式与抽象工厂模式对比：

---

        工厂模式是我们最常用的实例化对象模式，是用工厂方法代替new操作的一种模式。它是创造型模式。工厂模式有三种，简单工厂模式、工厂方法模式和抽象工厂模式。

1、简单工厂模式（Simple Factory）

        该模式对对象创建管理方式最为简单，因为其仅仅简单的对不同类对象的创建进行了一层薄薄的封装。该模式通过向工厂传递类型来指定要创建的对象。简单工厂模式并不在23种设计模式之中。

        假设现在某公司旗下存在两个食品工厂，分别生产汉堡和薯条。

        首先，创建二者的共同接口：

public interface Food{ 
    public void make(); 
    public void eat();
}

        其次，创建两个实现类：

public class Hamberger implements Food { 
    @Override 
    public void make() { 
        System.out.println("make a hamberger"); 
    } 
    @Override
    public void eat(){
        System.out.println("eat a hamberger");
    }
    public HambergerMaker(){
        this.make();
    }
}
public class Chips implements Food { 
    @Override 
    public void make() { 
        System.out.println("make some chips"); 
    }
    @Override
    public void eat(){
        System.out.println("eat some chips");
    }
    public ChipsMaker(){
        this.make();
    }
}

        最后，建工厂类：

public class FoodFactory{ 
    public Food produce(String type) { 
        if ("hamberger".equals(type)) { 
            return new Hamberger(); 
        } else if ("chips".equals(type)) { 
            return new Chips(); 
        } else { 
            System.out.println("请输入正确的类型!"); 
            return null; 
        } 
    } 
}

        我们来测试下：

public class FactoryTest { 
    public static void main(String[] args) { 
        FoodFactory factory = new FoodFactory(); 
        Food food1 = factory.produce("hamberger"); 
        food1.eat();
        Food food2 = factory.produce("chips");
        food2.eat();
        Food food3 = factory.produce("nuddles");
    } 
} 

        输出：

make a hamberger
eat a hamberger
make some chips
eat some chips
请输入正确的类型

简单工厂模式的优缺点

        简单工厂模式的优点：将对象的创建交给专门的工厂类负责，实现了对象的创建和对象的使用分离。

        简单工厂模式的缺点：工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，需要增加一个 if 判断分支才能支持。而且当产品类型较多时，简单工厂的 if 判断将会非常多，不容易维护。

---

2、工厂方法模式（Factory Method）

        工厂方法模式的定义为：定义一个用于创建对象的接口或者抽象类，让实现类或者子类决定实例化哪一个类。

        其中，Food接口及其子类的代码不变，增加一个抽象工厂AbstractFoodFactory，里面定义了生产食物的方法 produceFood()，具体创造什么类型食物由其子工厂实现。

抽象工厂代码如下：

public abstract class AbstractFactory{
    public abstract Food produceFood();
}

        工厂类代码如下：

public class FactoryA extends AbstractFactory{
    @Override
    public Food produceFood(){
        return new Hamberger();
    }
}

public class FactoryB extends AbstractFactory{
    @Override
    public Food produceFood(){
        return new Chips();
    }
}
    

        测试类代码如下：

public class TestFactory{
    public static void main(String[] args){
        AbstractFactory factory = null;
        factory = new FactoryA();
        Food food1 = factory.produceFood();
        food1.eat();
        factory = new FactoryB();
        Food food2 = factory.produceFood();
        fodd2.eat();
    }
}

        输出结果如下：        

make a hamberger
eat a hamberger
make some chips
eat some chips

工厂方法模式的优缺点

        工厂方法模式的优点：遵循了开-闭原则，扩展性极强。比如现在要增加一个面条类，我们只需要增加一个创建面条类的工厂，这个工厂继承自抽象工厂即可，不需要改变原有代码，可维护性高。

        工厂方法模式的缺点：增加了类的数量，当有成千上万个类型的产品时，就需要有成千上万个工厂类来生产这些产品。

---

3、抽象工厂模式（Abstract Factory）

        抽象工厂模式的定义为：为创建一组相关或者相互依赖的对象提供一个接口，而无需指定他们具体的类。

        可能有些晦涩难懂，不妨先看看代码层面出现了哪些改变。假设这两个工厂均增加饮料生产业务，分别生产可乐和茶。

        首先，增加这两个类。

public interface Drinks{
    public void make();
    public void drink();
}

public class Cola implements Drinks{
    @Override
    public void make(){
        System.out.println("make a glass of cola");
    }
    @Override
    public void drink(){
        System.out.println("drink a glass of cola");
}

public class Tea implements Drinks{
    @Override
    public void make(){
        System.out.println("make a cup of tea");
    }
    @Override
    public void drink(){
        System.out.println("drink a cup of tea");
}

        修改抽象工厂：

public interface AbstractFactory{
    public Food produceFood();
    public Drink produceDrink();
}
    

        两个实现类：

public class FactoryA implements AbstractFactory { 
    @Override
    public Food produceFood(){
        return new Hamberger();
    }
    @Override
    public Drink produceDrink(){
        return new Cola();
    }
}
public class FactoryB implements AbstractFactory { 
    @Override
    public Food produceFood(){
        return new Chips();
    }
    @Override
    public Drink produceDrink(){
        return new Tea();
    }
}

测试类：

public class TestFactory{
    public static void main(String[] args){
        AbstractFactory factory = null;
        factory = new FactoryA();
        Food food1 = factory.produceFood();
        food1.eat();
        Drink drink1 = factory.produceDrink();
        drink1.drink();

        factory = new FactoryB();
        Food food2 = factory.produceFood();
        fodd2.eat();
        Drink drink2 = factory.produceDrink();
        drink2.drink();
    }
}

测试结果：

make a hamberger
eat a hamberger
make a glass of cola
drink a glass of cola
make some chips
eat some chips
make a cup of tea
drink a cup of tea

4、工厂方法模式与抽象工厂模式对比：

工厂方法模式	抽象工厂模式
针对同一个产品等级结构	针对多层次产品等级结构
一个抽象产品类	多个抽象产品类
派生出一系列具体产品类	每个抽象产品类均可派生一系列具体产品类
一个抽象工厂类，派生出一系列具体工厂类
每个工厂类只能创建一个产品类的实例	每个工厂类能创建多个产品类的实例

---