工厂设计模式.md

工厂设计模式

• 工厂设计模式
  • 工厂模式的特点
  • 简单工厂模式
  • 工厂方法模式
  • 抽象工厂模式

工厂模式的特点

隐藏复杂的逻辑处理过程，只关心执行结果。

工厂模式有三种：

1. 简单工厂，功能强大，扩展性不强。
2. 工厂方法，独立分工，但是学习成本过高。
3. 抽象工厂，简单工厂和工厂方法的结合体。

简单工厂模式

解剖：从一个厂家拿到宝马、奔驰、奥迪，同一套工艺标准。

缺点：无法进行个性定制化。

定义一个标准工艺，也就是实现一个 Car 接口。

public interface Car {
    String  getName();
}

生产奥迪车，同一个工厂，相同的标准

public class Audi implements Car{
    public String getName() {
        return "Audi";
    }
}

生产奔驰车，同一个工厂，相同的标准

public class Benz implements Car {
    public String getName() {
        return "Benz";
    }
}

生产宝马车，同一个工厂，相同的标准

public class Bmw implements Car{
    public String getName() {
        return "Bmw";
    }
}

工厂开始准备加工，定义了一个工厂类

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;
        }
    }
}

根据需要的汽车开始生产，定义一个测试类

public class SimpleFactoryTest {
    public static void main(String[] args) {
        // 实现统一管理、专业化管理
        Car car = new SimpleFactory().getCar("Bmw");
        System.out.println("该工厂生产了：" + car.getName());
    }
}

工厂方法模式

解刨：定义一套公开标准，然后不同的汽车不同的厂家生产 宝马工厂生产宝马，奔驰工厂生产奔驰，有自己的个性化定制。

缺点：有的时候我们只要一家厂商，要对多家厂商进行筛选。

定义公开的标准，如质量ISO9001，定义公开的接口

public interface FunFactory {
    Car getCar();
}

宝马工厂按照公开的标准生产，然后自己做了一些定制化生产

public class BmwFactory implements FunFactory {
    public Car getCar() {
        return new Bmw();
    }
}

奔驰工厂按照公开的标准生产，然后自己做了一些定制化生产

public class BenzFactory implements FunFactory {
    public Car getCar() {
        return new Benz();
    }
}

奥迪工厂按照公开的标准生产，然后自己做了一些定制化生产

public class AudiFactory implements FunFactory {
    public Car getCar() {
        return new Audi();
    }
}

不同的工厂生产不同的汽车。

public class FunFactoryTest {
    public static void main(String[] args) {
        FunFactory factory = new AudiFactory();
        System.out.println(factory.getCar().getName());
        factory = new BmwFactory();
        System.out.println(factory.getCar().getName());
        factory = new BenzFactory();
        System.out.println(factory.getCar().getName());
    }
}

抽象工厂模式

解刨：第三代理品牌，代理了三家汽车制造公司，然后卖给4S店，赚取中间差价。

第三方代理工厂，给你默认推荐和定制化生产

// 代理工厂
public abstract class AbstractFactory {
    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 DefaultFactory extends  AbstractFactory{
    private AudiFactory factory=new AudiFactory();
    Car getCar() {
        return factory.getCar();
    }
}

奔驰工厂

public class BenzFactory extends AbstractFactory {
    public Car getCar() {
        return new Benz();
    }
}

宝马工厂

public class BmwFactory extends AbstractFactory {
    public Car getCar() {
        return new Bmw();
    }
}

奥迪工厂

public class AudiFactory extends AbstractFactory {
    public Car getCar() {
        return new Audi();
    }
}