工厂模式

工厂模式主要是为创建对象提供过度接口，以便将创建对象的具体过程屏蔽隔离起来，以达到灵活性的目的

主要分为三类：

简单工厂模式

工厂方法模式

抽象工厂模式

在《设计模式》中，工厂模式分为工厂方法模式和抽象工厂模式，简单工厂模式被当成工厂方法的特例

一：简单工厂模式

引入了创建者的概念，将实例化的代码从应用代码抽离，在工厂类的静态方法中处理创建对象的细节，后续创建的对象则需改造静态方法，

但由于使用静态方法来获取对象，使其不能在运行期间通过不同方式去动态改变创建行为，因此存在一定局限性。

//这是制造咖啡的工厂模式例子
public abstract class Coffee {

    /**
     * 获取咖啡的名称
     */
    public abstract String getName();

}
           

　　

public class Americano extends Coffee {
    @Override
    public String getName() {
        return "美式拿铁";
    }
}


public class Cappuccino extends Coffee{
    @Override
    public String getName() {
        return "卡布奇诺";
    }
}



public class Latte extends Coffee{
    @Override
    public String getName() {
        return "拿铁";
    }
}
           

上面三个是不同制造咖啡的具体实现，现在用一个工厂类来实现客户想点这三种咖啡的静态方法

public class SimpleFactory {
    public static Coffee getInstance(String type){
        if("americano".equals(type)){
            return new Americano();
        }else if("cappuccino".equals(type)){
            return new Cappuccino();
        }else if("latte".equals(type)){
            return new Latte();
        }else{
            throw new RuntimeException("type["+type+"]类型不可识别，没有匹配到可实例化的对象！");
        }
    }
}
           

　　

最后就是客户端来调用这个工厂类来点三种不同的咖啡了，这里我们采用一个Test类模拟一下

public class Test {
    public static void main(String[] args)  {
        Coffee americano = SimpleFactory.getInstance("americano");
        System.out.println("创建的实例为："+americano.getName());
        Coffee cappuccino = SimpleFactory.getInstance("cappuccino");
        System.out.println("创建的实例为："+cappuccino.getName());
        Coffee latte = SimpleFactory.getInstance("latte");
        System.out.println("创建的实例为："+latte.getName());

    }
}
           

结果如下

二：工厂方法模式

定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法让类把实例化推迟到了子类

将简单工厂的工厂类变成一个父类，由不同工厂子类继承

public abstract class CoffeeFactory {
    //不同地区能生成不同咖啡
    public abstract Coffee[] getName();
}


public class ChinaFactory extends CoffeeFactory {
    //中国能生产的咖啡
    @Override
    public Coffee[] getName() {
        return new Coffee[]{new Cappuccino(),new Latte()};
    }
}



public class AmericaFactory extends CoffeeFactory {
    //美国能生产的咖啡
    @Override
    public Coffee[] getName() {
        return new Coffee[]{new Americano(),new Latte()};
    }
}
           

　　

接下里测试一下

public class Test {
    public static void main(String[] args) {
        CoffeeFactory americaCoffeeFactory = new AmericaFactory();
        Coffee[] americaCoffeeFactoryName = americaCoffeeFactory.getName();
        for (Coffee coffee : americaCoffeeFactoryName) {
            System.out.println(coffee.getName());
        }
    }
}
           

　　

三：抽象工厂方法

提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

public interface AbstractFactory {
   //获取咖啡名称
    Coffee createCoffee();
  //获取茶的名称
    Tea createTea();
}



public class OneFactory implements AbstractFactory{
    @Override
    public Coffee createCoffee() {
        return new Latte();
    }

    @Override
    public Tea createTea() {
        return new  MilkTea();
    }
}


public class TwoFactory implements AbstractFactory{
    @Override
    public Coffee createCoffee() {
        return new Cappuccino();
    }

    @Override
    public Tea createTea() {
        return new GreenTea();
    }
}
           

　　茶（Tea）按照咖啡（Coffee）写法弄一个就好了

接下来是测试

public class Test {
    public static void main(String[] args) {
        AbstractFactory oneFactory = new OneFactory();
        AbstractFactory twoFactory = new TwoFactory();
        System.out.println("one工厂的有：");
        System.out.println(oneFactory.createCoffee().getName());
        System.out.println(oneFactory.createTea().getName());
        System.out.println("two工厂的有：");
        System.out.println(twoFactory.createCoffee().getName());
        System.out.println(twoFactory.createTea().getName());
    }
}
           

　　

转载于:https://www.cnblogs.com/xiaobo520/p/10499051.html