java工厂模式：简单工厂、工厂方法、抽象工厂

工厂模式

核心本质：

• 实例化对象不使用new，用工厂方法创建对象
• 使用工厂统一管理对象的创建，将调用者跟实现类解耦

三种模式：

1. 简单工厂模式

建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

• 优点是比较好理解，简单易操作。
• 缺点是类的创建依赖工厂类，如果想要拓展程序，必须对工厂类进行修改，这违反了设计模式的开闭原则（OCP），即对扩展开放，对修改关闭。

手机接口类

public interface Phone {
    void call();
    
}

两个手机实现类：

public class IPhone implements Phone{
    @Override
    public void call() {
        System.out.println("用苹果手机打电话！");
    }
}

public class MPhone implements Phone{
    @Override
    public void call() {
        System.out.println("用小米手机打电话！");
    }
}

生产手机的工厂类：

public class PhoneFactory {
    public Phone create(String type){
        if (type.equals("IPhone")){
            return new IPhone();
        }else if (type.equals("MPhone")){
            return new MPhone();
        }else
            return null;
    }
}

测试：

public class test {

    public static final String IPhone = "IPhone";
    public static final String MPhone = "MPhone";

    public static void main(String[] args) {
        PhoneFactory factory = new PhoneFactory();
        factory.create(IPhone).call();
        factory.create(MPhone).call();

    }

}

输出结果

2. 工厂方法模式

对简单工厂模式的改进，使用一个工厂接口，创建多个工厂类，每个工厂创建对应的对象。

• 工厂方法模式，创建一个工厂接口和创建多个工厂实现类，一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。有利于代码的维护和扩展。

工厂方法接口：

public interface PhoneFactory_M {
    Phone_M create();
}

两个工厂实现类

public class IPhoneFactory_M implements PhoneFactory_M {
    @Override
    public Phone_M create() {
        return new IPhone_M();
    }
}

public class MPhoneFactory_M implements PhoneFactory_M {
    @Override
    public Phone_M create() {
        return new MPhone_M();
    }
}

两个对象及实现类

public interface Phone_M {
    void call();
}

public class IPhone_M implements Phone_M {
    @Override
    public void call() {
        System.out.println("用苹果手机打电话_M");
    }
}

public class MPhone_M implements Phone_M {
    @Override
    public void call() {
        System.out.println("用小米手机打电话_M");
    }
}

测试

public class test_M {
    /**
     *  工厂方法模式
     * 对简单工厂模式的改进，使用一个工厂接口，创建多个工厂类，每个工厂创建对应的对象。
     *
     * 工厂方法模式，创建一个工厂接口和创建多个工厂实现类，一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。有利于代码的维护和扩展。
     * @param args
     */
    public static void main(String[] args) {
        PhoneFactory_M iPhoneFactory_m = new IPhoneFactory_M();
        iPhoneFactory_m.create().call();

        PhoneFactory_M mPhoneFactory_m = new MPhoneFactory_M();
        mPhoneFactory_m.create().call();

    }
}

输出结果

3. 抽象工厂模式

围绕一个超级工厂创建其他工厂，每个工厂可以生产不同类型的产品

• 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合。

• 从设计层面看，抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)。
• 将工厂抽象成两层，抽象工厂 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单个的简单工厂类变成了工厂集合， 更利于代码的维护和扩展。

超级工厂：

public interface Factory {
    Phone createPhone();

    Book createBook();
    
}

苹果工厂：

public class AppleFactory implements Factory {
    @Override
    public Phone createPhone() {
        return new IPhone();
    }

    @Override
    public Book createBook() {
        return new MacBook();
    }
}

小米工厂：

public class XiaoMiFactory implements Factory {
    @Override
    public Phone createPhone() {
        return new MPhone();
    }

    @Override
    public Book createBook() {
        return new MiBook();
    }
}

电脑接口类：

public interface Book {
    void play();
}

电脑接口的两个实现类：

public class MacBook implements Book {
    @Override
    public void play() {
        System.out.println("用苹果电脑打游戏");
    }
}

public class MiBook implements Book {
    @Override
    public void play() {
        System.out.println("用小米电脑打游戏");
    }
}

测试类：

public class test {
    public static void main(String[] args) {
        Factory appleFactory = new AppleFactory();
        appleFactory.createPhone().call();
        appleFactory.createBook().play();

        Factory xiaoMiFactory = new XiaoMiFactory();
        xiaoMiFactory.createPhone().call();
        xiaoMiFactory.createBook().play();

    }
}

输出结果