java工厂模式—210422

1、工厂模式的定义

工厂模式是我们最常用的实例化对象模式，是用工厂方法代替new操作的一种模式。工厂模式抽象了对象创建的具体细节，隐藏了创建过程的复杂度。

2、工厂模式的好处

会给系统带来更好的可扩展性和尽量少的修改量（不是新增量）。

3、工厂模式分类

1）简单工厂模式：把对象的创建放到一个工厂类中，通过参数来创建不同的对象。缺点是每添一个对象，就需要对简单工厂类进行修改。

//懒，就写一起了
public class Factory {
    //测试方法
    public static void main(String[] args) {
        Factory factory = new Factory();
        //打印我是ProductA
        factory.getProduct("A").showProduct();
        //打印我是ProductB
        factory.getProduct("B").showProduct();

    }
    //工厂方法
    private IProduct getProduct(String pruductName){
        switch (pruductName){
            case "A": return new ProductA();
            case "B": return new ProductB();
            default: return new ProductA();
        }
    }
    //产品接口
    private interface IProduct{
        void showProduct();
    }
    //产品A
    private class ProductA implements IProduct{
        @Override
        public void showProduct() {
            System.out.println("我是ProductA");
        }
    }
    //产品B
    private class ProductB implements IProduct{
        @Override
        public void showProduct() {
            System.out.println("我是ProductB");
        }
    }
}

2）工厂方法模式：提供一个用于创建对象的工厂接口，让其实现类(工厂实现类)决定实例化哪一种产品类，并且由该实现类创建对应类的实例。

//懒，就写一起了
public class MainTest {
    //测试方法
    public static void main(String[] args) {
        MainTest mainTest = new MainTest();
        mainTest.test();
    }
    public void test(){
        IFactory factoryA = new FactoryA();
        IProduct productA = factoryA.getProduct();
        //打印我是ProductA
        productA.showProduct();

        IFactory factoryB = new FactoryB();
        IProduct productB = factoryB.getProduct();
        //打印我是ProductB
        productB.showProduct();
    }
    //工厂接口
    private interface IFactory{
        IProduct getProduct();
    }
    //工厂A
    private class FactoryA implements IFactory{
        @Override
        public IProduct getProduct() {
            return new ProductA();
        }
    }
    //工厂B
    private class FactoryB implements IFactory{
        @Override
        public IProduct getProduct() {
            return new ProductB();
        }
    }
    //产品接口
    private interface IProduct{
        void showProduct();
    }
    //产品A
    private class ProductA implements IProduct{
        @Override
        public void showProduct() {
            System.out.println("我是ProductA");
        }
    }
    //产品B
    private class ProductB implements IProduct{
        @Override
        public void showProduct() {
            System.out.println("我是ProductB");
        }
    }
}

3）抽象工厂模式：工厂方法的复杂化，可以把一些有联系或者功能相近的产品，放到一个工厂去生产，没有必要单独再开一个工厂了。

//懒，就写一起了
public class MainTest {
    //测试方法
    public static void main(String[] args) {
        MainTest mainTest = new MainTest();
        mainTest.test();
    }
    public void test(){
        IFactory factoryA = new FactoryA();
        IProduct productA = factoryA.getProduct();
        //打印我是ProductA
        productA.showProduct();
        IWoker wokerA = factoryA.getWoker();
        //打印我是WokerA
        wokerA.showWoker();

        IFactory factoryB = new FactoryB();
        IProduct productB = factoryB.getProduct();
        //打印我是ProductB
        productB.showProduct();
        IWoker wokerB = factoryB.getWoker();
        //打印我是WokerB
        wokerB.showWoker();
    }
    //工厂接口
    private interface IFactory{
        IProduct getProduct();
        IWoker getWoker();
    }
    //工厂A
    private class FactoryA implements IFactory{
        @Override
        public IProduct getProduct() {
            return new ProductA();
        }
        @Override
        public IWoker getWoker() {
            return new WokerA();
        }
    }
    //工厂B
    private class FactoryB implements IFactory{
        @Override
        public IProduct getProduct() {
            return new ProductB();
        }
        @Override
        public IWoker getWoker() {
            return new WokerB();
        }
    }
    //产品接口
    private interface IProduct{
        void showProduct();
    }
    //产品A
    private class ProductA implements IProduct{
        @Override
        public void showProduct() {
            System.out.println("我是ProductA");
        }
    }
    //产品B
    private class ProductB implements IProduct{
        @Override
        public void showProduct() {
            System.out.println("我是ProductB");
        }
    }
    //工种接口
    private interface IWoker{
        void showWoker();
    }
    //工种A
    private class WokerA implements IWoker{
        @Override
        public void showWoker() {
            System.out.println("我是WokerA");
        }
    }
    //工种B
    private class WokerB implements IWoker{
        @Override
        public void showWoker() {
            System.out.println("我是WokerB");
        }
    }
}