工厂模式

1. 工厂模式介绍

　　提供了一种将对象创建过程封装到一个单独的类中的方式，这个类就是被称为‘工厂类’，它根据特定的条件来决定应该创建哪个对象

2. 工厂模式的创建方式

　　（1）简单工厂模式

public interface Phone {

    /**
     * 抽象电话功能
     */
    void call();
}

public class IPhone implements Phone {

    @Override
    public void call() {
        System.out.println("使用Iphone打电话");
    }
}

public class HuaweiPhone implements Phone {

    @Override
    public void call() {
        System.out.println("使用华为手机打电话");
    }
}

public class MiPhone implements Phone {

    @Override
    public void call() {
        System.out.println("使用MiPhone打电话");
    }
}

public class SimpleFactoryPattern {

    public static Phone create(String name){
        if (name.equals("IPhone")){
            return new IPhone();
        }else if (name.equals("MIPhone")){
            return new MiPhone();
        }else if (name.equals("Huawei")){
            return new HuaweiPhone();
        }
        return null;
    }
}

public class Main {
    public static void main(String[] args) {

        Phone iPhone = SimpleFactoryPattern.create("IPhone");
        iPhone.call();

        Phone miPhone = SimpleFactoryPattern.create("MIPhone");
        miPhone.call();
    }
}

　　优点：

　　（1）简单工厂模式的实现相对较为简单，易于理解和使用；

　　（2）简单工厂模式可以将对象的创建与使用分离开来，降低了客户端代码和具体某类之间的耦合度；

　　缺点：

　　（1）一旦某类过多或者某产品变化频繁，就需要不断修改工厂类的代码，这样会导致工厂类变得过于庞大和复杂，可扩展性受到限制；

　　（2）违反开闭原则：简单工厂模式的扩展性较差，如果需要添加新的某产品，就需要修改工厂类的代码，这样就会违反开闭原则；

　　（2）工厂模式

public interface Phone {

    /**
     * 抽象电话功能
     */
    void call();
}

public class IPhone implements Phone {

    @Override
    public void call() {
        System.out.println("使用Iphone打电话");
    }
}

public class MiPhone implements Phone {

    @Override
    public void call() {
        System.out.println("使用MiPhone打电话");
    }
}

public interface PhoneFactory {

    /**
     * 抽象创建对象
     */
    Phone create();
}

public class IPhoneFactory implements PhoneFactory {
    @Override
    public Phone create() {
        return new IPhone();
    }
}

public class MiPhoneFactory implements PhoneFactory {

    @Override
    public Phone create() {
        return new MiPhone();
    }
}

public class Main {
    public static void main(String[] args) {
        MiPhoneFactory miPhoneFactory = new MiPhoneFactory();
        miPhoneFactory.create().call();

        IPhoneFactory iPhoneFactory = new IPhoneFactory();
        iPhoneFactory.create().call();
    }
}

　　优点：

　　不同于简单工厂模式，工厂方法模式和抽象工厂模式支持增加新的产品类型而不需要修改原有的代码，符合开闭原则，提高了系统的可扩展性

　　缺点：

　　工厂方法只能创建一种产品，一种产品只能对应一种工厂；因此，当产品过多的时候，也就增加了复杂度，创建过多的类；

　　（3）超级工厂

public interface Phone {

    /**
     * 抽象电话功能
     */
    void call();
}

public class IPhone implements Phone {

    @Override
    public void call() {
        System.out.println("使用Iphone打电话");
    }
}

public class MiPhone implements Phone {

    @Override
    public void call() {
        System.out.println("使用MiPhone打电话");
    }
}

public class SuperFactorys {

    public static <T> T create(String className){
        try {
            //动态加载class
            Class<?> clazz = Class.forName(className);
            //通过class对象获取构造函数创建实例
            T instance = (T)clazz.getConstructor().newInstance();
            return instance;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("create instance fail",e);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Phone phone = SuperFactorys.create("com.lewang.factory.type03.MiPhone");
        phone.call();
    }
}

　　超级工厂模式利用反射机制完美的解决了简单工厂模式存在的开闭原则的问题；结合了反射机制和泛型，也使得客户端代码更加的简洁，代码更具有灵动性、可维护性和扩展性！

　　参考：https://blog.csdn.net/m0_67840539/article/details/130976213