六大常用软件设计模式—工厂模式

当当当当~~~~欢迎大家阅读，今天我们学习六大常用软件设计模式中的工厂模式​​​​​​​

工厂模式 （Factory Pattern）

一：工厂模式的定义

就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

二：工厂模式的实现方式

1、 抽象产品类（也可以是接口）

2、多个具体的产品类

3、 工厂类（包括创建a的实例的方法）

简单工厂模式

一：定义

一个抽象的接口，多个抽象接口的实现类，一个工厂类，用来实例化抽象的接口

二：介绍

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

A实例调用B实例的方法，称为A依赖于B。如果使用new关键字来创建一个B实例（硬编码耦合），然后调用B实例的方法。一旦系统需要重构：需要使用C类来代替B类时，程序不得不改写A类代码。而用工厂模式则不需要关心B对象的实现、创建过程。

三：简单工厂的优缺点

1、优点

简单工厂方式包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象。通过使用工厂类，外界可以从直接创建具体产品对象的尴尬局面摆脱出来，仅仅需要负责“消费”对象。而不必管这些对象究竟如何创建及如何组织的。明确了各自的职责和权利，有利于整个软件体系结构的优化。

2、缺点

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

四：代码实现

// 抽象产品类
interface Car {
    public void run();
    public void stop();
}
 
// 具体实现类
class Benz implements Car {
    public void run() {
        System.out.println("特斯拉开始启动了。。。。。");
    }
    public void stop() {
        System.out.println("特斯拉停车了。。。。。");
    }
}
 
class Ford implements Car {
    public void run() {
        System.out.println("奔驰开始启动了。。。");
    }
    public void stop() {
        System.out.println("奔驰停车了。。。。");
    }
}
// 工厂类
class Factory {
    public static Car getCarInstance(String type) {
        Car c = null;
        if ("Benz".equals(type)) {
            c = new Benz();
        }
        if ("Ford".equals(type)) {
            c = new Ford();
        }
        return c;
    }
}
 
public class Test {
    public static void main(String[] args) {
        Car c = Factory.getCarInstance("Benz");
        if (c != null) {
            c.run();
            c.stop();
        } else {
            System.out.println("造不了这种汽车。。。");
        }
    }
}

工厂方法模式

一：定义

定义一个创建对象的工厂接口，让子类决定实例化哪一个类，将实际创建工作推迟到子类当中。创建对象的接口，让子类决定具体实例化的对象，把简单的内部逻辑判断移动到客户端。

二：介绍

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

有四个角色：抽象工厂类，具体工厂类，抽象产品角色，具体产品角色。
不再是由一个工厂类去实例化具体的产品，而是由抽象工厂的子类去实例化产品。

三：代码实现

// 抽象产品角色
interface Moveable {
    void run();
}

// 具体产品角色
class Plane implements Moveable {
    public void run() {
        System.out.println("plane....");
    }
}

class Broom implements Moveable {
    public void run() {
        System.out.println("broom.....");
    }
}

// 抽象工厂
abstract class VehicleFactory {
    abstract Moveable create();
}

// 具体工厂
class PlaneFactory extends VehicleFactory {
    public Moveable create() {
        return new Plane();
    }
}

class BroomFactory extends VehicleFactory {
    public Moveable create() {
        return new Broom();
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        VehicleFactory factory = new BroomFactory();
        Moveable m = factory.create();//接口和抽象类都不能实例化，但可以定义接口类型和抽象类的引用
        m.run();
    }
}

四：抽象工厂与工厂方法的比较

简单工厂模式：要增加具体产品时也要相应地修改工厂类，客户端的代码也增加了不少。

工厂方法：把简单工厂的内部逻辑判断转移到了客户端代码来进行。

1、你想要加功能，本来是改工厂类的，而现在是修改客户端。

2、而且各个不同功能的实例对象的创建代码，也没有耦合在同一个工厂类里，这也是工厂方法模式对简单工厂模式解耦的一个体现。

3、工厂方法模式克服了简单工厂会违背开-闭原则的缺点，又保持了封装对象创建过程的优点。

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

抽象工厂模式

一：介绍

抽象工厂是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

二：定义

是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

三：示例图

是海尔工厂和 TCL 工厂所生产的电视机与空调对应的关系图。

 四：使用抽象工厂模式要满足的条件

(1)可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。

(2)当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。

(3)抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

五：抽象工厂模式的优缺点

1、优点

(1)抽象工厂模式最大的好处是易于交换产品系列，由于具体工厂类，在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。

(2)抽象工厂模式的另一个好处就是它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操作实例，产品实现类的具体类名也被具体的工厂实现类分离，不会出现在客户端代码中。
2、缺点

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

六：抽象工厂模式的结构

抽象工厂模式同工厂方法模式一样，也是由抽象工厂、具体工厂、抽象产品和具体产品等 4 个要素构成，但抽象工厂中方法个数不同，抽象产品的个数也不同。现在我们来分析其基本结构。

1、主要角色

(1)抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。

(2)具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。

(3)抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。

(4)具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

2、结构图

七：代码实现

//抽象产品类
interface Vehicle{
    public void run();
}
interface Weapon{
    public void shoot();
}
interface Food{
    public void printName();
}

//具体产品类
class Car implements Vehicle{
    public void run(){
        System.out.println("car is running....");
    }
}
class AK47 implements Weapon{
    public void shoot(){
        System.out.println("bomm....");
    }
}
class Apple implements Food{
    public void printName(){
 System.out.println("it is an apple...");
    }
}

//抽象工厂类
abstract class AbstractFactory {
    public abstract Vehicle createVehicle();
    public abstract Weapon createWeapon();
    public abstract Food createFood();
}
//具体工厂类，其中Food,Vehicle，Weapon是抽象类，
class DefaultFactory extends AbstractFactory{
    @Override
    public Food createFood() {
        return new Apple();
    }
    @Override
    public Vehicle createVehicle() {
        return new Car();
    }
 @Override
    public Weapon createWeapon() {
        return new AK47();
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        AbstractFactory f = new DefaultFactory();
        Vehicle v = f.createVehicle();
        v.run();
        Weapon w = f.createWeapon();
        w.shoot();
        Food a = f.createFood();
        a.printName();
    }
}

以上就是六大常用软件设计模式中工厂模式的内容啦，希望我的文章对你有所帮助，如果有错误的地方还望大家批评指正，谢谢大家阅读!