简单工厂模式、工厂方法模式、抽象方法模式理解

下面例子中鼠标为产品，惠普，戴尔为工厂。

简单工厂模式：

简单工厂模式又叫做静态工厂方法，但不属于23种设计模式之一。简而言之，就是有一个专门生产某个产品的类。

比如鼠标工厂，专业生产鼠标，给参数 0，生产戴尔鼠标，给参数 1，生产惠普鼠标。

（1）定义一个产品为鼠标，创建两个类去实现这个鼠标接口，一个是戴尔鼠标，一个是惠普鼠标。

//鼠标产品
public interface Mouse {
    String sayHi();
}

//具体产品
public class DellMouse implements Mouse {
    @Override
    public String sayHi() {
        return "DellMouse";
    }
}

//具体产品
public class HpMouse implements Mouse {
    @Override
    public String sayHi() {
        return "HpMouse";
    }
}

public class SimpleFactory {
    public Mouse create(int i){
        if(i==0){
            return new DellMouse();
        }else if(i==1){
            return new HpMouse();
        }else{
            return null;
        }
    }
}

我们想要什么样的产品就得给什么样的参数

public class Test {
    public static void main(String[] args) {
        //鼠标工厂，专业生产鼠标,给你参数，给你啥你就生产啥
        SimpleFactory factory = new SimpleFactory();
        System.out.println(factory.create(1).sayHi());
    }
}

工厂模式：

工厂模式也就是鼠标工厂是个父类，有生产鼠标这个接口。

戴尔鼠标工厂，惠普鼠标工厂继承它，可以分别生产戴尔鼠标，惠普鼠标。

生产哪种鼠标不再由参数决定，而是创建鼠标工厂时，由戴尔鼠标工厂创建。

后续直接调用鼠标工厂.生产鼠标()

//鼠标工厂 是父类，有生产鼠标的接口
public interface MouseFactory {
    Mouse createMouse();
}

//继承鼠标工厂生产惠普鼠标
public class HpMouseFactory implements MouseFactory{
    @Override
    public Mouse createMouse() {
        return new HpMouse();
    }
}

//继承鼠标工厂生产戴尔鼠标
public class DellMouseFactory implements MouseFactory {
    @Override
    public Mouse createMouse() {
        return new DellMouse();
    }
}

public class Test {
    public static void main(String[] args) {
        MouseFactory factory = new DellMouseFactory();
        System.out.println(factory.createMouse().sayHi());
    }
}

抽象工厂：

当产品只有一个的时候，抽象工厂模式即变成工厂模式，当工厂模式的产品为多个时，工厂模式即变成抽象工厂模式

//抽象工厂不只能生产鼠标还能进行扩展
//PC 厂商是个父类，有生产鼠标的接口,也可能还有其他的接口
//当产品只有一个的时候，抽象工厂模式即变成工厂模式，当工厂模式的产品为多个时，工厂模式即变成抽象工厂模式
public abstract class PcAbstractFactory {
    abstract Mouse create();
}

//惠普工厂继承pc工厂
public class HpFactory extends PcAbstractFactory {
    @Override
    Mouse create() {
        return new HpMouse();
    }
}

//戴尔工厂继承pc工厂
public class DellFactory extends PcAbstractFactory {
    @Override
    Mouse create() {
        return new DellMouse();
    }
}

public class Test {
    public static void main(String[] args) {
        DellFactory dellFactory = new DellFactory();
        System.out.println(dellFactory.create().sayHi());
    }
}

我们现在需要增加一个产品 键盘；

//键盘产品
public interface KeyBo {
   public String sayHi();
}

public class HpKeyBo implements KeyBo {
    @Override
    public String sayHi() {
        return "HpKeyBo";
    }
}

public class DellKeyBo implements KeyBo {
    @Override
    public String sayHi() {
        return "DellKeyBo";
    }
}

 增加键盘工厂

//增加键盘工厂
public interface KeyBoFactory {
    KeyBo createKeyBo();
}

//继承键盘工厂生产戴尔键盘
public class DellKeyBoFactory implements KeyBoFactory{
    @Override
    public KeyBo createKeyBo() {
        return new DellKeyBo();
    }
}

//继承键盘工厂生产惠普键盘
public class HpKeyBoFactory implements KeyBoFactory {
    @Override
    public KeyBo createKeyBo() {
        return new HpKeyBo();
    }
}

public class Test {
    public static void main(String[] args) {
        KeyBoFactory factory = new DellKeyBoFactory();
        System.out.println(factory.createKeyBo().sayHi());
    }
}

PC 厂商是个父类，这回有生产鼠标，生产键盘两个接口。

//抽象工厂不只能生产鼠标还能进行扩展
//PC 厂商是个父类，有生产鼠标，生产键盘两个接口。
//当产品只有一个的时候，抽象工厂模式即变成工厂模式，当工厂模式的产品为多个时，工厂模式即变成抽象工厂模式
public abstract class PcAbstractFactory {
    abstract Mouse createMouse();
    abstract KeyBo cteateKeyBo();
}

//惠普工厂继承pc工厂 可以生产和惠普鼠标+惠普键盘。
public class HpFactory extends PcAbstractFactory {
    @Override
    Mouse createMouse() {
        return new HpMouse();
    }

    @Override
    KeyBo cteateKeyBo() {
        return new HpKeyBo();
    }
}

//戴尔工厂继承pc工厂 生产戴尔鼠标+戴尔键盘
public class DellFactory extends PcAbstractFactory {
    @Override
    Mouse createMouse() {
        return new DellMouse();
    }

    @Override
    KeyBo cteateKeyBo() {
        return new DellKeyBo();
    }
}

public class Test {
    public static void main(String[] args) {
        DellFactory dellFactory = new DellFactory();
        System.out.println(dellFactory.createMouse().sayHi());
        System.out.println(dellFactory.cteateKeyBo().sayHi());
    }
}

在抽象工厂模式中，假设我们需要增加一个工厂，下面不上代码了...

假设我们增加华硕工厂，则我们需要增加华硕工厂，和戴尔工厂一样，继承 PC 厂商。

之后创建华硕鼠标，继承鼠标类。创建华硕键盘，继承键盘类即可。

 在抽象工厂模式中，假设我们需要再增加一个产品

假设我们增加耳麦这个产品，则首先我们需要增加耳麦这个父类，再加上戴尔耳麦，惠普耳麦这两个子类。

之后在PC厂商这个父类中，增加生产耳麦的接口。最后在戴尔工厂，惠普工厂这两个类中，分别实现生产戴尔耳麦，惠普耳麦的功能。

嗯，应该差不多了