Java面试知识点（七十八）设计模式之工厂模式

ゝ一纸荒年。 2021-09-20 20:32 261阅读 0赞

***工厂模式：工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。***

--------------------

### 一、简单工厂模式： ###

实例化对象的时候**不再使用 new Object () 形式**，可以根据用户的选择条件来实例化相关的类。对于客户端来说，去除了具体的类的依赖。只需要给出具体实例的**描述**给工厂，工厂就会自动返回具体的实例对象。

【未使用工厂模式】

public abstract class Car { 
    
        public abstract void run();
    }
    
    public class Benz extends Car { 
    
        @Override
        public void run() { 
            System.out.println("开奔驰");
        }
    
    }
    
    public class Bmw extends Car{ 
    
        @Override
        public void run() { 
            System.out.println("开宝马");
        }
    
    }
    
    public class Client { 
    
        public static void main(String[] args) { 
            Car car1 = new Benz();
            car1.run();
            
            Car car2 = new Bmw();
            car2.run();
        }
    }

在 Client 类中既有创建对象逻辑又有调用方法逻辑，且与多个类发生耦合。违背了单一职责原则和迪米特法则。

*  单一职责原则（SRP）：就一个类而言，应该仅有一个引起它变化的原因。即一个类中应该只有一类逻辑。
 *  迪米特法则：如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一个类的某一方法的话，可以通过第三者转发这个调用

--------------------

简单工厂模式属于类的创建型模式，又叫做**静态工厂方法模式**。通过**专门定义一个类来负责创建其他类的实例**，被创建的实例通常都具有共同的父类。

【简单工厂模式】

// 创建生产工厂类
    package designpatterns.factory.simple;
    
    public class CarFactory { 
        public Car createCar(String name) { 
            Car car = null;
            switch (name) { 
                case "benz":
                    car = new Benz();
                    break;
                case "bmw":
                    car = new Bmw();
                    break;
            }
            return car;
        }
    }
    
    // 测试环境
    package designpatterns.factory.simple;
    
    public class Client { 
        public static void main(String[] args) { 
            CarFactory carFactory = new CarFactory();
            Car car = carFactory.createCar("benz");
            car.run();
            Car car1 = carFactory.createCar("bmw");
            car1.run();
        }
    }

Client 类与 Car 的子类解耦，它不需要知道 Car 实例具体创建细节，只需要通知工厂类需要怎样的实例。这样，减少了与外部类（Car 的子类）的通信，遵循了迪米特法则。我们可以对创建的对象进行一些 “加工” ，而且客户端并不知道，因为工厂隐藏了这些细节。如果，没有工厂的话，那我们是不是就得自己在客户端上写这些代码，这就好比本来可以在工厂里生产的东西，拿来自己手工制作，不仅麻烦以后还不好维护。

但是缺点也很明显：如果需要在方法里写很多与对象创建有关的业务代码，而且需要的创建的对象还不少的话，我们要在这个简单工厂类里编写很多个方法，每个方法里都得写很多相应的业务代码，而每次**增加子类或者删除子类对象的创建都需要打开这简单工厂类来进行修改**。这会导致这个简单工厂类很庞大臃肿、耦合性高，而且**增加、删除某个子类对象的创建都需要打开简单工厂类来进行修改代码也违反了开 - 闭原则**。

--------------------

### 二、工厂模式 ###

这时候就需要使用工厂模式了。**工厂方法模式是对简单工厂模式进一步的解耦**，因为**在工厂方法模式中是一个子类对应一个工厂类，而这些工厂类都实现于一个抽象接口**。这相当于是把原本会因为业务代码而庞大的简单工厂类，拆分成了一个个的工厂类，这样代码就不会都耦合在同一个类里了。

// 工厂抽象类
    package designpatterns.factory.general;
    
    public interface CarFactory { 
        Car createCar();
    }
    
    //工厂抽象类的实现
    package designpatterns.factory.general;
    
    public class CreateBenz implements CarFactory { 
        @Override
        public Car createCar() { 
            Car car = new Benz();
            return car;
        }
    }
    
    package designpatterns.factory.general;
    
    public class CreateBmw implements CarFactory { 
        @Override
        public Car createCar() { 
            Car car = new Bmw();
            return car;
        }
    }
    
    // 测试环境
    package designpatterns.factory.general;
    
    public class Client { 
        public static void main(String[] args) { 
            CarFactory carBenz = new CreateBenz();
            Car car1 = carBenz.createCar();
            car1.run();
    
            CarFactory carBmw = new CreateBmw();
            Car car2 = carBmw.createCar();
            car2.run();
    
        }
    }

工厂模式中，要增加产品类时也要相应地增加工厂类，客户端的代码也增加了不少。**工厂方法把简单工厂的内部逻辑判断转移到了客户端代码来进行**。违背责任单一原则。

你想要加功能，本来是改工厂类的，而现在是修改客户端。而且各个不同功能的实例对象的创建代码，也没有耦合在同一个工厂类里，这也是工厂方法模式对简单工厂模式解耦的一个体现。工厂方法模式克服了简单工厂会违背开 - 闭原则的缺点，又保持了封装对象创建过程的优点。

但工厂方法模式的**缺点是每增加一个产品类，就需要增加一个对应的工厂类，增加了额外的开发量**。

--------------------

### 三、抽象工厂模式 ###

抽象工厂模式是所有形态的工厂模式中最为抽象的。抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型（不是指实现类）的情况下，能够创建多个产品族的产品对象。

抽象工厂模式用于产品族，例如高端车和低端车

【发动机接口及实现】

public interface Engine { 
    
        void run();
    }
    
    class HighEndEngine implements Engine { 
    
        @Override
        public void run() { 
            System.out.println("高端发动机，启动快");
        }
        
    }
    
    class LowEndEngine implements Engine { 
        @Override
        public void run() { 
            System.out.println("低端发动机，启动慢");
        }
    }

【轮胎接口及实现】

public interface Tyre { 
    
        void use();
    }
    
    class HighEndTyre implements Tyre { 
    
        @Override
        public void use() { 
            System.out.println("高端轮胎，耐磨防滑");
        }
        
    }
    
    class LowEndTyre implements Tyre { 
    
        @Override
        public void use() { 
            System.out.println("低端轮胎，磨损大，易打滑");
        }
        
    }

【座椅接口及实现】

public interface Seat { 
    
        void feel();
    }
    
    class HighEndSeat implements Seat { 
    
        @Override
        public void feel() { 
            System.out.println("高端座椅，坐着舒适");
        }
        
    }
    
    class LowEndSeat implements Seat { 
    
        @Override
        public void feel() { 
            System.out.println("低端座椅，坐旧难受");
        }
        
    }

**1.使用工厂模式**

public interface EngineFactory { 
        Engine createEngine();
    }
    
    public interface TyreFactory { 
        Tyre createTyre();
    }
    
    public interface SeatFactory{ 
        Seat createSeat();
    }
    ...
    
    
    public class Client { 
    
        public static void main(String[] args) { 
            EngineFactory ef = new HighEndEngineFactory();
            Engine engine = ef.createEngine();
    
            TyreFactory tf = new HighEndTyreFactory();
            Tyre tyre = tf.createTyre();
            
            SeatFactory sf = new HighEndEngineSeatFactory();
            Seat seat = sf.createSeat();
            
        }
    }

如果需要拼装一辆高端的轿车，客户端需要创建 3 个高端的工厂获取发动机、轮胎和座椅才能完成需求。这样客户端就与多个类进行耦合，违反了迪米特法则。假设，高端产品族新增一个安全锁的产品，我们又要新建相应的抽象工厂和子类工厂，项目结构的复杂度大大增加。因此，简单工厂模式和工厂方法模式只适用于创建某一类对象，对于产品族维度划分的产品创建的操作就显得繁琐了。

--------------------

**2.使用抽象工厂模式**

【工厂接口】

public interface CarFactory { 
    
        Engine createEngine();
        
        Tyre createTyre();
        
        Seat createSeat();
    }

【工厂实现类】

public class HighEndCarFactory implements CarFactory { 
    
        @Override
        public Engine createEngine() { 
            return new HighEndEngine();
        }
    
        @Override
        public Tyre createTyre() { 
            return new HighEndTyre();
        }
    
        @Override
        public Seat createSeat() { 
            return new HighEndSeat();
        }
    
    
    }
    
    public class LowEndCarFactory implements CarFactory { 
    
        @Override
        public Engine createEngine() { 
            return new LowEndEngine();
        }
    
        @Override
        public Tyre createTyre() { 
            return new LowEndTyre();
        }
    
        @Override
        public Seat createSeat() { 
            return new LowEndSeat();
        }
    
    }

【客户端调用】

public class Client { 
    
        public static void main(String[] args) { 
            CarFactory cf = new HighEndCarFactory();
            
            Engine engine = cf.createEngine();
            
            Tyre tyre = cf.createTyre();
            
            Seat seat = cf.createSeat();
        }
    }

这种实现方式对应上文的内容：客户端在不必指定产品的具体类型（发动机、轮胎、座椅）的情况下，能够创建多个产品族的产品对象。当产品族中新增几个产品，只需创建产品类以及在对应的工厂类中添加对应的方法即可。

**优点：**

1.  抽象工厂模式最大的好处是易于交换产品系列，由于具体工厂类，在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。不管是任何人的设计都无法去完全防止需求的更改，或者项目的维护，那么我们的理想便是让改动变得最小、最容易。
2.  抽象工厂模式的另一个好处就是它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操作实例，产品实现类的具体类名也被具体的工厂实现类分离，不会出现在客户端代码中。