工厂模式

Posted 2021-11-26 ilnauy

1、是什么？

什么是工厂模式？现实生活中的工厂，我只关系结果（产品），不关系生产过程。

2、为什么？

对对象的创建过程进行了封装隐藏，减少对产品类的依赖

实现统一化管理，专业化管理；如果没有工厂，没有执行标准，三无产品（没有标准）；监督难度减轻

3、怎么做？

a、简单工厂

//汽车接口
public interface Car {
    public String getName();
}

public class Bmw implements Car {

    public String getName() {
        return "宝马";
    }

}

public class Benz implements Car {

    public String getName() {
        return "奔驰";
    }

}

public class Audi implements Car {

    public String getName() {
        return "奥迪";
    }

}

public class SimpleFactory {
    /**
     * 工厂太强了，不符合现实
     * 如果生产的产品很复杂，那么代码就会十分冗余
     */
    public Car getCar(String name) {
        if("bmw".equalsIgnoreCase(name)) {
            return new Bmw();
        }else if("Benz".equalsIgnoreCase(name)) {
            return new Benz();
        }else if("Audi".equalsIgnoreCase(name)) {
            return new Audi(); 
        }else {
            System.out.println("这个产品生产不出来");
            return null;
        }
    }
    
}

b、方法工厂

那么就给每个产品建造一间对应的工厂

//工厂接口
public interface Factory {

    //生成小汽车
    Car getCar();
    
}

public class AudiFactory implements Factory{

    public Car getCar() {
        return new Audi();
    }

}

public class BenzFactory implements Factory{

    public Car getCar() {
        return new Audi();
    }

}

public class BmwFactory implements Factory{

    public Car getCar() {
        return new Bmw();
    }

}

public class FactoryTest {

    public static void main(String[] args) {
        //工厂方法模式
        //各个产品的生产商，都拥有各自的工厂
        //生产工艺，生成额高科技程度是不一样的
        // 需要用户关心，这个产品的生产商
        AudiFactory factory = new AudiFactory();
        factory.getCar();
    }
    
}

c、抽象工厂

我不想关心是哪家工厂，告诉工厂需要什么产品就好了

//抽象工厂
public abstract class AbstractFactory {
    
    protected abstract Car getCar();
    
    public  Car getCar(String name) {
        if("Bmw".equalsIgnoreCase(name)) {
            return new BmwFactory().getCar();
        }else if("Benz".equalsIgnoreCase(name)) {
            return new BenzFactory().getCar();
        }else if("Audi".equalsIgnoreCase(name)) {
            return new AudiFactory().getCar();
        }else {
            System.out.println("没有该汽车类型");
            return null;
        }
    }
    
}

public class AudiFactory extends AbstractFactory{

    public Car getCar() {
        return new Audi();
    }

}

public class BenzFactory extends  AbstractFactory{

    public Car getCar() {
        return new Benz();
    }

}

public class BmwFactory extends  AbstractFactory{

    @Override
    protected Car getCar() {
        return new Bmw();
    }

    
}

//默认工厂
public class DefaultFactory extends AbstractFactory {

    private AudiFactory defaultFactory = new AudiFactory();
    
    @Override
    protected Car getCar() {
        return defaultFactory.getCar();
    }

}

public class AbstractfactoryTest {
    //设计模式的经典之处，就在于，解决了编写代码的人和调用代码的人痛处
    //隐藏复杂的逻辑处理过程，只关心执行结果。
    public static void main(String[] args) {
        DefaultFactory factory = new DefaultFactory();
        System.out.println(factory.getCar());
        
        System.out.println(factory.getCar("benz"));
    }
    
    
}