设计模式（二）工厂三兄弟

文章目录

简介

简单工厂（Factory）
工厂方法（Factory Method）
抽象工厂（Abstract Factory）

简介

实例（公共代码）：
先创建一个Milk接口

public interface Milk {

    /**
     * 获取一个标准的产品
     * @return
     */
    public String getName();
}

实现接口创建三个具体类

public class MengNiu implements Milk {
    @Override
    public String getName() {
        return "蒙牛";
    }
}

public class TeLunSu implements Milk {
    @Override
    public String getName() {
        return "特仑苏";
    }
}

public class YiLi implements Milk {
    @Override
    public String getName() {
        return "伊利";
    }
}

简单工厂（Factory）

简单工厂模式的实质是有一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。一般不算在23中设计模式之中。在Spring中的BeanFactory就是简单工厂的体现，根据传入一个唯一的标识来获得Bean类，但是是否在传入参数后创建还是传入参数前创建这个要根据具体情况来定。
创建简单工厂：

public class SimpleFactory {
    public Milk getMilk(String name){
        if ("蒙牛".equals(name)) {
            return new MengNiu();
        } else if ("伊利".equals(name)){
            return new YiLi();
        } else if ("特仑苏".equals(name)){
            return new TeLunSu();
        }else {
            System.out.println("不能生成所需的产品");
        return null;
        }
  }
}

在调用的时候需要传入具体的参数

public class SimpleFactoryTest {
    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        System.out.println(simpleFactory.getMilk("特仑苏"));
    }
}

工厂方法（Factory Method）

工厂方法模式，定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法是一个类的实例化延迟到其子类。
应用场景：通常由应用程序直接使用new创建新的对象，为了将对象的创建和使用相分离，采用工厂模式，即应用程序将对象的创建和初始化职责交给工厂对象。
创建一个工厂接口

public interface Factory {
    // 工厂必然具有生产产品的技能，统一的产品出口
    Milk getMilk();
}

具体的工厂需要有各自的工厂

YiliFactory ：

public class YiliFactory implements Factory {

    @Override
    public Milk getMilk() {
        
        return new YiLi();
    }
}

TelunsuFactory ：

public class TelunsuFactory implements Factory {
    @Override
    public Milk getMilk() {
        return new TeLunSu();
    }
}

MengNiuFactory ：

public class MengNiuFactory implements Factory {
    @Override
    public Milk getMilk()
    {
        return new  MengNiu();
    }
}

在调用的时候直接实例化需要的工厂

public class FactoryTest {
    public static void main(String[] args) {
        Factory factory = new MengNiuFactory();
        System.out.println(factory.getMilk());
    }
}

抽象工厂（Abstract Factory）

抽象工厂模式，提供一个创建一系列相关或者相互依赖对象的接口，而无需指定他们具体的类。抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。

创建一个包含所有种类的抽象工厂

public abstract class AbstractFactory {

    /**
     * 获得一个蒙牛品牌牛奶
     * @return
     */
    public abstract Milk getMengniu();

    /**
     * 获得一个伊利品牌牛奶
     * @return
     */
    public abstract Milk getYili();

    /**
     * 获得一个特仑苏品牌牛奶
     * @return
     */
    public abstract Milk getTelunsu();
}

创建一个牛奶工厂

public class MilkFactory extends AbstractFactory {
    @Override
    public Milk getMengniu() {

        return new MengNiu();
    }

    @Override
    public Milk getYili()
    {
        return new YiLi();
    }

    @Override
    public Milk getTelunsu() {

        return new TeLunSu();
    }
}

调用：

public class AbstractFactoryTest {
    public static void main(String[] args) {
        MilkFactory milkFactory = new MilkFactory();
        System.out.println(milkFactory.getMengniu().getName());
    }
}```