java设计模式(二)——工厂模式

1、基本概念

工厂模式属于创造型模式，对象不再用户去调用，而是交由工厂去创建。

例如：我们想要吃烤鸭，如果自己做的话，那么需要买鸭，处理鸭，烤，放作料等一些列过程。

而如果我们去餐厅去买的话，我们就不需要关心怎么去做的，由饭店给我们做，它给我们做好的鸭子即可。

2、工厂类型

工厂模式属于创造型的模式，三种形式：简单工厂，工厂方法，抽象工厂，

 每种工厂都有它的优缺点，看合适的场景去使用。

2.1、简单工厂

适用于创建对象少，不经常变，用户无需在意对象的创建过程，简单容易理解。

案例：

 类图：

 接口：Icource

/**
 * @date 2020/6/30
 */
public interface Icource {

    //备课
    void prepareCource();

    //教学
    void teach();

    //批改作业
    void correctiveWork();

}

实现类：MathCource 

/**
 * @date 2020/6/30
 */
public class MathCource implements Icource {
    @Override
    public void prepareCource() {
        System.out.println("备数学课");
    }

    @Override
    public void teach() {
        System.out.println("数学教学");
    }

    @Override
    public void correctiveWork() {
        System.out.println("批改数学作业");
    }
}

实现类：EnglishCource 

/**
 * @date 2020/6/30
 */
public class EnglishCource implements Icource {
    @Override
    public void prepareCource() {
        System.out.println("备英语课");
    }

    @Override
    public void teach() {
        System.out.println("英语教学");
    }

    @Override
    public void correctiveWork() {
        System.out.println("批改英语作业");
    }
}

简单工厂：

/**
 * @date 2020/6/30
 */
public class CourceSimpleFactory {

    public  static Icource  createCource(String  type){
        Icource icource = null;
        if("math".equals(type)){
            icource = new MathCource();
        }else if("english".equals(type)){
            icource = new EnglishCource();
        }
        return icource;
    }
}

测试类：

/**
 * @date 2020/6/30
 */
public class Test {
    public static void main(String[] args) {
        Icource icource = CourceSimpleFactory.createCource("math");
        icource.prepareCource();
        icource.teach();
        icource.correctiveWork();
    }
}

2.2、工厂方法

上面的简单工厂虽然用法简单，但不利于扩展。当我们新增一个语文课时，我们需要修改简单工厂的代码，这不符合开闭原则，而且当

简单工厂创建的对象经常改变，种类繁多时，也就不符合单一职责。这时候工厂方法就有了，它符合开闭原则，职能单一原则。

创建的对象多，让系统代码结构更为复杂。

案例：

类图：

课程接口Icource ：

/**
 * @date 2020/6/30
 */
public interface Icource {

    //备课
    void prepareCource();

    //教学
    void teach();

    //批改作业
    void correctiveWork();

}

实现类MathCource ：

/**
 * @date 2020/6/30
 */
public class MathCource implements Icource {
    @Override
    public void prepareCource() {
        System.out.println("备数学课");
    }

    @Override
    public void teach() {
        System.out.println("数学教学");
    }

    @Override
    public void correctiveWork() {
        System.out.println("批改数学作业");
    }
}

实现类EnglishCource ：

/**
 * @date 2020/6/30
 */
public class EnglishCource implements Icource {
    @Override
    public void prepareCource() {
        System.out.println("备英语课");
    }

    @Override
    public void teach() {
        System.out.println("英语教学");
    }

    @Override
    public void correctiveWork() {
        System.out.println("批改英语作业");
    }
}

工厂接口IcourceFactory ：

/**
 * @date 2020/6/30
 */
public interface IcourceFactory {

    Icource createInstance();

}

实现工厂接口类EnglishFactory  ：

/**
 * @date 2020/6/30
 */
public class EnglishFactory  implements IcourceFactory{

    @Override
    public Icource createInstance() {
        return new EnglishCource();
    }
}

实现工厂接口类：MathFacotry 

/**
 * @date 2020/6/30
 */
public class MathFacotry implements IcourceFactory {

    @Override
    public Icource createInstance() {
        return new MathCource();
    }
}

测试类：

/**
 * @date 2020/6/30
 */
public class Test {
    public static void main(String[] args) {
        IcourceFactory icourceFactory = new EnglishFactory();
        Icource instance = icourceFactory.createInstance();
        instance.correctiveWork();
    }
}

2.3、抽象工厂

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类，适用于产品族

缺点：结构较复杂，理解难度大，当工厂新增一个产品时，需要修改工厂的方法，不符合开闭原则。

案例：现有三个工厂类：小米工厂，格力工厂，美的工厂

小米工厂：生产空调，洗衣机，榨汁机，这三个就可以是一个产品族了

格力工厂：生产空调，洗衣机，榨汁机

美的工厂：生产空调，洗衣机，榨汁机

抽象工厂：定义三个抽象方法

类图：

 抽象工厂AbstractFactory ：

/**
 * @date 2020/6/30
 */
public abstract class AbstractFactory {

    protected  abstract  IAirConditioning createAirConditioning();

    protected  abstract  IJuicer createJuicer();

    protected  abstract  IWashingMachine createWashingMachine();
}

抽象工厂继承类XiaomiFactory ：

/**
 * @date 2020/6/30
 */
public class XiaomiFactory extends AbstractFactory {
    @Override
    protected IAirConditioning createAirConditioning() {
        return new XiaomiAirConditioning();
    }

    @Override
    protected IJuicer createJuicer() {
        return new XiaomiJuicer();
    }

    @Override
    protected IWashingMachine createWashingMachine() {
        return new XiaomiWashingMachine();
    }
}

抽象工厂继承类MideaFactory：

/**
 * @date 2020/6/30
 */
public class MideaFactory extends AbstractFactory {
    @Override
    protected IAirConditioning createAirConditioning() {
        return new MideaAirConditioning();
    }

    @Override
    protected IJuicer createJuicer() {
        return new MideaJuicer();
    }

    @Override
    protected IWashingMachine createWashingMachine() {
        return new MideaWashingMachine();
    }
}

抽象工厂继承类GreenFactory：

/**
 * @date 2020/6/30
 */
public class GreenFactory extends AbstractFactory {
    @Override
    protected IAirConditioning createAirConditioning() {
        return new GreenAirConditioning();
    }

    @Override
    protected IJuicer createJuicer() {
        return new GreenJuicer();
    }

    @Override
    protected IWashingMachine createWashingMachine() {
        return new GreenWashingMachine();
    }
}

空调接口IAirConditioning ：

/**
 * @date 2020/6/30
 */
public interface IAirConditioning {

    void  refrigeration();


}

其实现类XiaomiAirConditioning ：

/**
 * @date 2020/6/30
 */
public class XiaomiAirConditioning implements IAirConditioning {
    @Override
    public void refrigeration() {
        System.out.println("小米空调");
    }
}

其实现类MideaAirConditioning ：

/**
 * @date 2020/6/30
 */
public class MideaAirConditioning implements IAirConditioning {
    @Override
    public void refrigeration() {
        System.out.println("美的空调");
    }
}

其实现类GreenAirConditioning ：

/**
 * @date 2020/6/30
 */
public class GreenAirConditioning implements IAirConditioning {
    @Override
    public void refrigeration() {
        System.out.println("格力空调");
    }
}

洗衣机接口IWashingMachine ：

/**
 * @date 2020/6/30
 */
public interface IWashingMachine {

    void washClothes();
}

其实现类XiaomiWashingMachine ：

/**
 * @date 2020/6/30
 */
public class XiaomiWashingMachine implements IWashingMachine {
    @Override
    public void washClothes() {
        System.out.println("小米洗衣机");
    }
}

其实现类MideaWashingMachine ：

/**
 * @date 2020/6/30
 */
public class MideaWashingMachine implements IWashingMachine {
    @Override
    public void washClothes() {
        System.out.println("美的洗衣机");
    }
}

其实现类GreenWashingMachine ：

/**
 * @date 2020/6/30
 */
public class GreenWashingMachine implements IWashingMachine {
    @Override
    public void washClothes() {
        System.out.println("格力洗衣机");
    }
}

榨汁机接口IJuicer ：

/**
 * @date 2020/6/30
 */
public interface IJuicer {

    void juicing();
}

其实现类XiaomiJuicer ：

/**
 * @date 2020/6/30
 */
public class XiaomiJuicer implements IJuicer {
    @Override
    public void juicing() {
        System.out.println("小米榨汁机");
    }
}

其实现类MideaJuicer ：

/**
 * @date 2020/6/30
 */
public class MideaJuicer implements IJuicer {
    @Override
    public void juicing() {
        System.out.println("美的空调");
    }
}

其实现类MideaJuicer ：

/**
 * @date 2020/6/30
 */
public class GreenJuicer implements IJuicer {
    @Override
    public void juicing() {
        System.out.println("格力榨汁机");
    }
}

其实现类GreenJuicer ：

/**
 * @date 2020/6/30
 */
public class GreenJuicer implements IJuicer {
    @Override
    public void juicing() {
        System.out.println("格力榨汁机");
    }
}

测试类：

/**
 * @date 2020/6/30
 */
public class Test {
    public static void main(String[] args) {
        AbstractFactory factory = new GreenFactory();
        factory.createAirConditioning().refrigeration();
    }
}