给对象讲工厂模式，必须易懂易会

目录

前言：

概述

三种工厂模式比较

1.简单工厂模式

优点

缺点

使用场景

2.工厂模式

优点

缺点

使用场景

抽象工厂模式

优点

缺点

使用场景

传送门：策略模式，工作中你用上了吗？

---

前言：

概述

• 设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码的可靠性。
• 设计模式共有23种，其中工厂模式是 Java 中最常用的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
• 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

三种工厂模式比较

• 简单工厂模式：专门定义一个类来创建其他类的示例，被创建的实例通常有相同的父亲
• 工厂模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实例化延迟到子类
• 抽象工厂模式：提供一个创建一系列相关或者相互依赖的接口，或无需指定他们具体的类

1.简单工厂模式

• 简单工厂模式是属于创建型模式，又叫做静态工厂方法模式，但不属于23种java设计模式之一。
• 简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

优点

• 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责。
• 客户端无需知道所创建具体产品的类名，只需知道参数即可。

缺点

1. 简单工厂模式代码简单，但不符合OCP（开闭原则）：一个软件的实体应当对扩展开放，对修改关闭；它所能创建的类只能是事先考虑到的，如果需要添加新的类，就需要改变工厂类了。
2. 使用简单工厂模式会增加系统中类的个数，增加系统的复杂度和理解难度。

使用场景

以造车为例：

//首先有个车接口，有个跑的方法
public interface Car {
    void run();
}

//然后有两个实现类：
public class Audi implements Car {
    @Override
    public void run(){
        System.out.println("奥迪在跑");
    }

}
public class Byd implements Car {
    @Override
    public void run(){
        System.out.println("比亚迪在跑");
    }
}
//车工厂
public class CarFactory {
    public static Car getCar(String type){
        if("奥迪".equals(type)){
            return new Audi();
        }else if("比亚迪".equals(type)){
            return new Byd();
        }else{
            return null;
        }
    }
}
//调用
public class Test {
    public static void main(String[] arg){
        CarFactory carFactory = new CarFactory();
        Car car1 = carFactory.getCar("奥迪");
        Car car2 = carFactory.getCar("比亚迪");
        car1.run();
        car2.run();
    }
}

2.工厂模式

• 工厂方法模式是简单工厂模式的衍生，完全符合“开闭原则”，实现了可扩展；其次它更复杂的层次结构，可以应用于产品结果复杂的场合。

优点

1. 屏蔽产品的具体实现，调用者只关心产品的接口。
2. 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

缺点

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景

//车接口
public interface Car {
    void run();
}

//两个实现类
public class Audi implements Car {
    @Override
    public void run(){
        System.out.println("奥迪在跑");
    }

}
public class Byd implements Car {
    @Override
    public void run(){
        System.out.println("比亚迪在跑");
    }
}
//车工厂接口
public interface CarFactory1 {
    Car1 getCar();
}
//两个车对应的车工厂实现类
public class BcFactory implements CarFactory1 {
    @Override
    public Car1 getCar(){
        return new Bc();
    }
}
public class DzFactory implements CarFactory1 {
    @Override
    public Car1 getCar(){
        return new Dz();
    }
//调用
public class Test1 {
    public static void main(String[] arg){
        Car1 car3 = new BcFactory().getCar();
        Car1 car4 = new DzFactory().getCar();
        car3.run();
        car4.run();
    }
}

抽象工厂模式

• 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
• 抽象工厂对于新增产品无能为力，只能新增产品族；新增产品还是交给简单工厂或工厂模式。

优点

• 抽象工厂模式隔离了具体类的生成， 使得客户并不需要知道什么被创建。 由于这种隔离，更换一个具体工厂就变得相对容易， 所有的具体工厂都实现了抽象工厂中定义的那些公共接口， 因此只需改变具体工厂的实例， 就可以在某种程度上改变整个软件系统的行为。
• 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

缺点

难以支持新种类的产品。因为抽象工厂接口确定了可以被创建的产品集合，所以难以扩展抽象工厂以生产新种类的产品。

使用场景

/**
 * 生产轮胎
 */
public interface Tyre {
    void revolve();
}
//高端
class LuxuryTyre implements Tyre{
    @Override
    public void revolve() {
        System.out.println("磨损慢");
    }
}
//低端
class LowTyre implements Tyre{
    @Override
    public void revolve() {
        System.out.println("磨损快");
    }
}
/**
 * 生产座椅
 */
public interface Seat {
    void sit();
}
//高端
class  LuxurySeat implements Seat{
    @Override
    public void sit() {
        System.out.println("座椅可以按摩");
    }
}
//低端
class  LowSeat implements Seat{
    @Override
    public void sit() {
        System.out.println("座椅不可以按摩");
    }
}
/**
 * 生产发动机
 */
public interface Engine {
    void run();
    void start();
}
//高端
class LuxuryEngine implements Engine{
 
    @Override
    public void run() {
        System.out.println("跑得快");
    }
 
    @Override
    public void start() {
        System.out.println("启动快");
    }
}
//低端
class LowEngine implements Engine{
 
    @Override
    public void run() {
        System.out.println("跑得慢");
    }
 
    @Override
    public void start() {
        System.out.println("启动慢");
    }
}
//车工厂接口
public interface CarFactory4 {
    Tyre getTyre();
    Seat getSeat();
    Engine getEngine();
}
//实现类：
//低端车
public class LowCarFactory implements CarFactory4{
    @Override
    public Tyre getTyre() {
        return new LowTyre();
    }
    @Override
    public Seat getSeat() {
        return new LowSeat();
    }
    @Override
    public Engine getEngine() {
        return new LowEngine();
    }
}
//高端车
public class LuxuryCarFactory implements CarFactory4{
    @Override
    public Tyre getTyre() {
        return new LowTyre();
    }
    @Override
    public Seat getSeat() {
        return new LowSeat();
    }
    @Override
    public Engine getEngine() {
        return new LowEngine();
    }
}
//调用
public class Test2 {
    public static void main(String arg[]){
        CarFactory2 factory = new LuxuryCarFactory();

        Tyre tyre = factory.getTyre();
        Seat seat = factory.getSeat();
        Engine engine = factory.getEngine();
        tyre.revolve();
        seat.sit();
        engine.start();
        engine.run();        
    }
}

传送门：

策略模式，工作中你用上了吗？