设计模式之-工厂模式

工厂模式详解

特点：

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

工厂模式有三种：

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

我们以汽车制造来说，假如一个4S店需要选购一批汽车，从宝马、奔驰、奥迪生产厂家拿到这些汽车。
我们通过工厂模式来实现，4S店选购到这些汽车。

简单工厂模式

解刨：从一个厂家拿到宝马、奔驰、奥迪，同一套工艺标准。
缺点：无法进行个性定制化。

定义工艺标准，也就是实现一个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());
        factory=new BmwFactory();
        System.out.println(factory.getCar());
        factory=new BenzFactory();
        System.out.println(factory.getCar());

    }
}

抽象工厂模式

解刨：第三代理品牌，代理了三家汽车制造公司，然后卖给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();
    }
}