工厂模式简述+图

工厂模式分为3种

• 简单工厂
• 工厂方法
• 抽象工厂

码云：工厂模式代码

准备工作

public interface Phone {
    void run();
}

public class Apple implements Phone {
    @Override
    public void run() {
        System.out.println("this is IPhone");
    }
}

public class Redmi implements Phone {
    @Override
    public void run() {
        System.out.println("this is Redmi");
    }
}

一、简单工厂模式

根据传入的不同类型返回对应的实例

public class PhoneFactory {
    public static Phone createPhone(String type){
        if ("".equals(type)||null==type){
            return null;
        }
        if (type.equals("Redmi")){
            return new Redmi();
        }else if ("Apple".equals(type)){
            return new Apple();
        }
        return null;
    }
}
class TestPhone{
    public static void main(String[] args) {
        Phone apple = PhoneFactory.createPhone("Apple");
        apple.run();
    }
}

助记图

这种方式向添加一种新的产品时，就必须修改工厂类。显然，简单工厂违反了开闭原则。所以简单工厂只适合产品对象较少，且需求固定的场景，而对产品丰富，需求不固定的场景来说不合适

二、工厂方法

定义一个创建对象的接口，让子类决定实例化哪个工厂类，工厂模式使其创建过程延迟到子类进行，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

public interface PhoneMothodFactory {
    Phone createPhone();
}

public class RedmiMothodFactory implements PhoneMothodFactory {
    @Override
    public Phone createPhone() {
        return new Redmi();
    }
}

public class AppleMothodFactory implements PhoneMothodFactory {
    @Override
    public Phone createPhone() {
        return new Apple();
    }
}

public  class TestMethodFactory  {
    public static void main(String[] args) {
        PhoneMothodFactory mothodFactory = new RedmiMothodFactory();
        Phone phone = mothodFactory.createPhone();
        phone.run();
    }
}

助记图

这种方法，如果需要很多产品的话，需要创建非常多的工厂，所以这种方式的缺点也很明显，就是需求增加就要增加工厂

三、抽象工厂

为创建一组相关或者是相互依赖的对象提供的一个接口，而不需要制定他们的具体类。抽象工厂和工厂方法的模式基本一样，区别在于：工厂方法是生产一个具体的产品，而抽象工厂可以用来生产一组产品

需要使用到之前准备工作所创建的三个类

public interface Pad {
    void run();
}

public interface PadAbstractFactory {
    Pad createPad();
}

public interface PhoneAbstractFactory {
    Phone createPhone();
}

public interface Factory extends PhoneAbstractFactory,PadAbstractFactory {
}

public class MiPad implements Pad {
    @Override
    public void run() {
        System.out.println("Mi Pad");
    }
}

public class IPad implements Pad {
    @Override
    public void run() {
        System.out.println("IPad");
    }
}

public class MiAbstractFactory implements Factory {
    @Override
    public Pad createPad() {
        return new MiPad();
    }

    @Override
    public Phone createPhone() {
        return new Redmi();
    }
}

public class AppleAbstractFactory implements Factory {
    @Override
    public Pad createPad() {
        return new IPad();
    }

    @Override
    public Phone createPhone() {
        return new Apple();
    }
}

public class TestAbstractFactory {
    public static void main(String[] args) {
        Factory appleAbstractFactory = new AppleAbstractFactory();
        Phone phone = appleAbstractFactory.createPhone();
        phone.run();

        Factory miAbstractFactory = new MiAbstractFactory();
        Pad pad = miAbstractFactory.createPad();
        pad.run();
    }
}

助记图