工厂设计模式

1. 简单工厂模式（静态工厂模式）

工厂中直接给出了具体的实现，根据调用工厂的调用端不同的需求给出不同的返回对象。

1. 优点

使用简单，使用者只需要传入对应参数就可以获得需要的对象，不需要关心创建的过程与实现的细节

2. 缺点

当需要添加新对象时需要对工厂的具体创建对象的过程进行修改

3.特点

简单工厂模式不在23种设计模式
简单工厂模式可以根据传入的参数不同返回需要的对象

/**
 * 简单工厂模式
 * 1.简单工厂模式不在23种设计模式
 * 2.简单工厂模式可以根据传入的参数不同返回需要的对象
 *
 * 优点：使用简单，使用者只需要传入对应参数就可以获得需要的对象，不需要关心创建的过程与实现的细节
 * 缺点：当需要添加新对象时需要对工厂的具体创建对象的过程进行修改
 *
 * @author : 可乐
 * @version : 1.0
 * @since : 2021/7/17 21:41
 */
public class SimpleFactory {

    /**
     * 工厂方法，根据传入的参数返回需要的对象
     *
     * 例如：假设获取一种交通工具
     *       1.定义一个交通工具抽象类
     *       2.将需要的交通工具的名字告诉工厂
     *       3.工厂直接返回传入的参数名字对应的交通工具
     *
     * @param name 根据传入的参数返回不同对象 汽车：car  飞机：palne
     * @return     具体的返回对象
     */
    public static Transportation factory(String name) {
        if ("car".equals(name))
            return new Car();
        else
            return new Plane();
    }

    public static void main(String[] args) {
        // 给car返回车
        Transportation car = SimpleFactory.factory("car");
        // 给plane返回飞机
        Transportation plane = SimpleFactory.factory("plane");
        
        System.out.println(car);
        System.out.println(plane);
    }
}

/**
 * 交通工具抽象类
 */
class Transportation {
    public Transportation(){
        System.out.println("交通工具");
    }
}

/**
 * 汽车类
 */
class Car extends Transportation {
    public Car(){
        System.out.println("汽车");
    }
}

/**
 * 飞机类
 */
class Plane extends Transportation {
    public Plane(){
        System.out.println("飞机");
    }
}

2. 工厂方法模式

工厂方法（FactoryMethod）不提供具体的实现将具体的实现交给子类，子类可以根据客户不同的需求做出不同的实现。

1. 工厂方法模式的优缺点

1. 优点

从下面图中可以看出，在需要给工厂添加新的实现时只需要进行添加新的实现类即可，不需要像简单工厂模式那样修改工厂类中的方法。

2. 缺点

当需要进行实现的具体工厂方法非常多时，整个的实现类就会变得非常庞大。

2. 工厂方法模式图

3. 工厂方法模式代码模拟

/**
 * 工厂方法模式
 * @author : 可乐
 * @version : 1.0
 * @since : 2021/7/18 10:18
 */
public abstract class FactoryMethod {

     // 定义抽象方法，此抽象方法需要子类根据需要进行具体的实现
     public abstract Transportation factory();

}

/**
 * 交通工具抽象类
 */
abstract class Transportation {

    // 定义一个抽象方法，具体实现交给子类去完成
    public abstract void CreatedTransportation();

}

/**
 * 汽车类
 */
class Car extends Transportation {

    /**
     * 重写父类中的抽象方法
     */
    @Override
    public void CreatedTransportation() {
        System.out.println("汽车");
    }
}

/**
 * 飞机类
 */
class Plane extends Transportation {

    @Override
    public void CreatedTransportation() {
        System.out.println("飞机");
    }
}

/**
 * 实际使用的交通工具，继承工厂类
 */
class UseTransportation extends FactoryMethod {

    /**
     * 实现工厂的抽象方法
     * @return  实际使用的对象
     */
    @Override
    public Transportation factory() {
        return new Car();
    }

    /**
     * 测试工厂方法模式
     */
    public static void main(String[] args) {
        // 创建调用实例对象
        UseTransportation useTransportation = new UseTransportation();
        // 获取工厂返回的对象，转换为自己想要的对象
        Car car = (Car)useTransportation.factory();
        car.CreatedTransportation();
    }

}

3. 抽象工厂模式

1. 特点

抽象工厂模式是工厂方法模式的一个增强版，原来的工厂方法模式只能加工一类产品，而抽象工厂模式能加工多类产品

2. 优点

在需要增加新种类的产品时可以不必修改工厂中的抽象方法，先创建对应的工厂再增加对应的大类继承抽象出来的顶级产品类如何添加对应实现即可。

3. 缺点

和工厂方法模式一样，添加有了新的产品实现之后，还是需要对象抽象工厂的子类进行修改

package com.kl.desginMode.factory;

/**
 * 抽象工厂模式
 * 能为该工厂创建多个种类的实例
 * 例如：
 * 之前的将工厂和工厂方法模式只能返回交通工具对象，
 * 现在抽象工厂模式能返回电子产品和交通工具等主要的对象，将可以创建的对象进行再抽象
 * @author : 可乐
 * @version : 1.0
 * @since : 2021/7/18 14:19
 */
@SuppressWarnings("all")
public abstract class AbstractFactory {

    // 定义抽象方法，此抽象方法需要子类根据需要进行具体的实现
    public abstract Product factory();

    /**
     * 测试抽象工厂方法
     */
    public static void main(String[] args) {

        // 1. 华为手机
        CreatedProduct createdProduct1 = new CreatedProduct();
        HuaWei huaWei = (HuaWei)createdProduct1.factory();
        huaWei.CreatedProduct();

        // 2. 苹果手机
        CreatedProduct createdProduct2 = new CreatedProduct();
        Iphone iphone = (Iphone)createdProduct2.factory();
        iphone.CreatedProduct();


        // 3. 汽车
        CreatedProduct createdProduct3 = new CreatedProduct();
        Car car = (Car)createdProduct3.factory();
        car.CreatedProduct();

        // 4. 飞机
        CreatedProduct createdProduct4 = new CreatedProduct();
        Plane plane = (Plane)createdProduct4.factory();
        plane.CreatedProduct();
    }

}

/**
 * 创建抽象工厂类的子类，继承抽象工厂模式,做出具体实现，决定生产那个产品
 */
class CreatedProduct extends AbstractFactory {

    /**
     * 决定生产那个产品的核心方法
     * @return  返回的具体对象
     */
    @Override
    public Product factory() {

        // 1. 华为手机
        return new HuaWei();

        // 2. 苹果手机
        //return new Iphone();

        // 3. 汽车
        //return new Car();

        // 4. 飞机
        //return new Plane();
    }
}

/**
 * 产品抽象类
 */
abstract class Product {

    // 创建一个抽象方法，用于生产产品
    public abstract void CreatedProduct();

}

/**
 * 创建一个手机抽象类，继承抽象产品类
 */
abstract class Phone extends Product {}

/**
 * 创建华为手机类，继承手机抽象类
 */
class HuaWei extends Phone {

    /**
     * 实现工厂类中的生产产品方法，生产华为手机
     */
    @Override
    public void CreatedProduct() {
        System.out.println("华为手机");
    }
}

/**
 * 创建苹果手机，继承手机抽象类
 */
class Iphone extends Phone {

    /**
     * 实现工厂类中的生产产品方法，生产苹果手机
     */
    @Override
    public void CreatedProduct() {
        System.out.println("苹果手机");
    }
}

/**
 * 创建一个交通工具抽象类，继承抽象产品类
 */
abstract class Transportation extends Product {}

/**
 * 汽车类，继承交通工具抽象类
 */
class Car extends Transportation {

    /**
     * 生产具体的交通工具，汽车
     */
    @Override
    public void CreatedProduct() {
        System.out.println("汽车");
    }
}

/**
 * 飞机类，继承交通工具抽象类
 */
class Plane extends Transportation {

    /**
     * 生产具体的交通工具，飞机
     */
    @Override
    public void CreatedProduct() {
        System.out.println("飞机");
    }
}