工厂模式学习总结

工厂模式

1. 工厂模式主要用于创建对象，使用工厂方法替代直接的new操作
2. 简单工厂模式：直接将创建对象的代码进行抽取封装成工厂类
3. 工厂方法模式：由于简单工厂模式不方便与扩展，所以对在简单工厂模式中创建对象的操作进行抽象，由不同的子类做具体的实现；只是对某个方法抽象
4. 抽象工厂模式：对于整个工厂类进行抽象，具体的创建对象的操作由工厂类的实现类完成
   一句话概括工厂模式
   简单工厂：一个工厂类，一个产品抽象类。
   工厂方法：多个工厂类，一个产品抽象类。
   抽象工厂：多个工厂类，多个产品抽象类。

简单工厂

package day01_FactoryMode;
/*
我们将创建一个 Shape 接口和实现 Shape 接口的实体类。下一步是定义工厂类 ShapeFactory。

FactoryPatternDemo，我们的演示类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory
传递信息（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。
 */
public class FactoryModeDemo {
    public static void main(String[] args) {
        ShapeFactory factory = new ShapeFactory();
        Shape shape = factory.getShape("Juxing");
        shape.Draw();

        Shape shape1 = factory.getShape("Circle");
        shape1.Draw();

        Shape shape2 = factory.getShape("Qiu");
        shape2.Draw();

        Shape shape3 = factory.getShape("");
        shape3.Draw();//NullPointerException
    }
}

interface Shape{
    void Draw();
}

class JuXingShapeImpl implements Shape{

    @Override
    public void Draw() {
        System.out.println("画一个矩形出来");
    }
}

class CircleShapeImpl implements Shape{
    @Override
    public void Draw() {
        System.out.println("画一个圆出来");
    }
}

class QiuShapeImpl implements Shape{
    @Override
    public void Draw() {
        System.out.println("画一个球出来");
    }
}

//创建一个工厂，生成基于给定信息的实体类的对象
class ShapeFactory{
    public Shape getShape(String shapeType){
        if (shapeType == null){
            return null;
        }
        if (shapeType == "Qiu"){
            return new QiuShapeImpl();
        }else if (shapeType == "Juxing"){
            return new JuXingShapeImpl();
        }else if (shapeType == "Circle"){
            return new CircleShapeImpl();
        }
        return null;
    }
}

抽象工厂

package day01_FactoryMode;
/*
我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。
接着定义工厂类 ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。

AbstractFactoryPatternDemo，我们的演示类使用 FactoryProducer 来获取 AbstractFactory 对象。
它将向 AbstractFactory 传递形状信息 Shape（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。
同时它还向 AbstractFactory 传递颜色信息 Color（RED / GREEN / BLUE），以便获取它所需对象的类型。
 */
public class AbstractFactoryModeDemo {
    public static void main(String[] args) {
        XingZhuangFactory xingZhuangFactory = new XingZhuangFactory();
        XingZhuang circle = xingZhuangFactory.getXingZhuang("circle");
        circle.Drow();
        XingZhuang qiu = xingZhuangFactory.getXingZhuang("qiu");
        qiu.Drow();
        XingZhuang juxing = xingZhuangFactory.getXingZhuang("juxing");
        juxing.Drow();

        ColorFactory colorFactory = new ColorFactory();
        Color red = colorFactory.getColor("red");
        red.fill();
    }
}

//为形状创建一个接口
interface XingZhuang{
    void Drow();
}

//创建实现接口的实体类。
class Juxing implements XingZhuang{
    @Override
    public void Drow() {
        System.out.println("这是一个矩形");
    }
}
class Cricle implements XingZhuang{
    @Override
    public void Drow() {
        System.out.println("这是一个圆");
    }
}
class Qiu implements XingZhuang{
    @Override
    public void Drow() {
        System.out.println("这是一个球");
    }
}

//为颜色创建一个接口。
interface Color{
    void fill();
}
//创建实现颜色接口的实现类
class Red implements Color{
    @Override
    public void fill() {
        System.out.println("填充了红色");
    }
}
class Green implements Color{
    @Override
    public void fill() {
        System.out.println("填充了绿色");
    }
}
class Blue implements Color{
    @Override
    public void fill() {
        System.out.println("填充了蓝色");
    }
}

//将形状和颜色抽象成一个抽象工厂
abstract class AbstractFactory{
    public abstract XingZhuang getXingZhuang(String xingzhuang);
    public abstract Color getColor(String color);
}

class XingZhuangFactory extends AbstractFactory{
    @Override
    public XingZhuang getXingZhuang(String xingzhuang) {
        if (xingzhuang == null){
            return null;
        }
        if (xingzhuang.equalsIgnoreCase("circle")){
            return new Cricle();
        }else if (xingzhuang.equalsIgnoreCase("juxing")){
            return new Juxing();
        }else if (xingzhuang.equalsIgnoreCase("qiu")){
            return new Qiu();
        }
        return null;
    }

    @Override
    public Color getColor(String color) {
        return null;
    }
}

class ColorFactory extends AbstractFactory{
    @Override
    public XingZhuang getXingZhuang(String xingzhuang) {
        return null;
    }

    @Override
    public Color getColor(String color) {
        if (color == null){
            return null;
        }
        if (color.equalsIgnoreCase("red")){
            return new Red();
        }else if (color.equalsIgnoreCase("green")){
            return new Green();
        }else if (color.equalsIgnoreCase("blue")){
            return new Blue();
        }
        return null;
    }
}

生活中的工厂模式

简单工厂类：一个麦当劳店，可以生产多种汉堡。
工厂方法类：一个麦当劳店，可以生产多种汉堡。一个肯德基店，也可以生产多种汉堡。
抽象工厂类：百胜餐饮集团下有肯德基和百事公司，肯德基生产汉堡，百事公司生成百事可乐。则百胜餐饮集团就是抽象工厂