妈妈再也不用担心我的工厂模式

1.简单工厂模式（小公司经营模式：一个工厂生产所有产品）

概要

1. 一个抽象产品类
2. 具体产品类
3. 一个工厂

优点

1. 简单易于实现
2. 把类的实例化交给工厂,易于解耦

缺点

1.添加具体产品需要修改工厂 违反OCP开放封闭原则

/**
 * @author cuishifeng
 * @create 2018-07-09
 **/
interface Car {

    /**
     * 我有一辆什么车
     */
    void myCar();
}

/**
 * @author cuishifeng
 * @create 2018-07-09
 **/

class BenChiCar implements Car {


    @Override
    public void myCar() {
        System.out.println("我有一辆奔驰车！");
    }
}
class FerrariCar implements Car {

    @Override
    public void myCar() {
        System.out.println("我有一辆法拉利！");
    }
}
class LamborghiniCar implements Car {
    @Override
    public void myCar() {
        System.out.println("我有一辆兰博基尼！");
    }
}
public class CarFactory {

    public static Car createCar(String carName){
        if (carName == null){
            return null;
        }
        switch (carName){
            case "BenChiCar":
                return new BenChiCar();
            case "FerrariCar":
                return new FerrariCar();
            case "LamborghiniCar":
                return new LamborghiniCar();
            default:
                return null;
        }
    }
}

2.工厂方法模式（规模化：一个工厂负责生产对应的产品，工厂产品一对一）

概要

1. 一个抽象产品类
2. 多个具体产品类
3. 一个抽象工厂
4. 多个具体工厂 - 每一个具体产品对应一个具体工厂
5. 符合 - OCP开放封闭原则

优点：
1.降低了代码耦合度,对象的生成交给子类（工厂类）去完成
2.实现了开放封闭原则-每次添加子产品不需要修改原有代码
缺点：
1.增加了代码量，每个具体产品都需要一个具体工厂
2.当增加抽象产品也就是添加一个其他产品族需要修改工厂违背OCP

/**
 * @author cuishifeng
 * @create 2018-08-02
 **/
interface Computer {

    /**
     * 生产电脑
     */
    void createComputer();
}

/**
 * @author cuishifeng
 * @create 2018-08-02
 **/
class Cpu implements Computer {

    @Override
    public void createComputer() {
        System.out.println("生产cpu");
    }
}

/**
 * @author cuishifeng
 * @create 2018-08-02
 **/
class Disk implements Computer {

    @Override
    public void createComputer() {
        System.out.println("生产磁盘disk");
    }
}

/**
 * @author cuishifeng
 * @create 2018-08-02
 **/
interface ComputerFactory {

    /**
     * 工厂方法模式的抽象工厂
     * @return
     */
    Computer getProduct();
}
/**
 * @author cuishifeng
 * @create 2018-08-02
 **/
class CpuFactory implements ComputerFactory {

    @Override
    public Computer getProduct() {
        return new Cpu();
    }
}
/**
 * @author cuishifeng
 * @create 2018-08-02
 **/
class DiskFactory implements ComputerFactory{
    @Override
    public Computer getProduct() {
        return new Disk();
    }
}
/**
 * 客户端
 * @author cuishifeng
 * @create 2018-08-02
 **/
public class Test {

    public static void main(String[] args) {
        ComputerFactory computerFactory = new CpuFactory();
        computerFactory.getProduct().createComputer();

        System.out.println("---------------------------- ");

        computerFactory = new DiskFactory();
        computerFactory.getProduct().createComputer();

        System.out.println("---------------------------- ");



    }
}

3.抽象工厂模式（工厂模式的扩展，每个工厂生产一组产品）

概要

1. 多个抽象产品类
2. 具体产品类
3. 抽象工厂类 - 声明(一组)返回抽象产品的方法
4. 具体工厂类 - 生成(一组)具体产品

优点

1. 代码解耦
2. 实现多个产品族(相关联产品组成的家族)，而工厂方法模式的单个产品,可以满足更多的生产需求
3. 很好的满足OCP开放封闭原则
4. 抽象工厂模式中我们可以定义实现不止一个接口，一个工厂也可以生成不止一个产品类 对于复杂对象的生产相当灵活易扩展

缺点

1.扩展产品族相当麻烦 而且扩展产品族会违反OCP,因为要修改所有的工厂，例如我们有电脑和鼠标组成的一个产品族，我们写完代码再去添加一个键盘就会很麻烦，看完下面代码就会理解了

2.由于抽象工厂模式是工厂方法模式的扩展 总体的来说 很笨重

/**
 * 计算机-抽象产品类
 * @author cuishifeng
 * @create 2018-08-02
 **/
abstract class Computer {

    /**
     * 生产计算机
     */
    public abstract void productComputer();
}
/**
 * 鼠标 - 抽象产品类
 * @author cuishifeng
 * @create 2018-08-02
 **/
abstract class Mouse {

    /**
     * 生产鼠标
     */
    public abstract void productMouse();
}
/**
 * PC计算机具体产品类
 * @author cuishifeng
 * @create 2018-08-02
 **/
class PcComputer extends Computer {

    @Override
    public void productComputer() {
        System.out.println("PC端计算机");
    }
}
/**
 * @author cuishifeng
 * @create 2018-08-02
 **/
class ServerComputer extends Computer {

    @Override
    public void productComputer() {
        System.out.println("Server端计算机");
    }
}
/**
 * @author cuishifeng
 * @create 2018-08-02
 **/
class GameMouse extends Mouse {

    @Override
    public void productMouse() {
        System.out.println("游戏鼠标");
    }
}
/**
 * @author cuishifeng
 * @create 2018-08-02
 **/
class OfficeMouse extends Mouse {

    @Override
    public void productMouse() {
        System.out.println("办公鼠标");
    }
}
/**
 * @author cuishifeng
 * @create 2018-08-02
 **/
interface IFactory {

    /**
     * 获取计算机
     * @return
     */
    Computer getComputer();

    /**
     * 获取鼠标
     * @return
     */
    Mouse getMouse();

}
/**
 * @author cuishifeng
 * @create 2018-08-02
 **/
class ProductFactoryA implements IFactory {

    @Override
    public Computer getComputer() {
        return new PcComputer();
    }

    @Override
    public Mouse getMouse() {
        return new OfficeMouse();
    }
}

/**
 * @author cuishifeng
 * @create 2018-08-02
 **/
class ProductFactoryB implements IFactory {
    @Override
    public Computer getComputer() {
        return new ServerComputer();
    }

    @Override
    public Mouse getMouse() {
        return new GameMouse();
    }
}

 

标签：author,create,工厂,cuishifeng,妈妈,2018,再也,class,public
来源： https://blog.csdn.net/qq_40315429/article/details/118087457