创建型模式（工厂模式）

Posted 2021-07-07 伍妖捌

• 工厂模式
• • 简单工厂模式（静态工厂模式）
  • • 作用：用来生产同一等级结构中的任意产品。
    • 优点：实现简单
    • 缺点：对于增加新的产品，需要覆盖已有代码
    • 特点：在一个工厂中生产不同的产品
    • 方法一
    • 方法二
  • 工厂方法模式
  • • 作用：用来生产同一等级结构中的固定产品。
    • 优点：支持增加任意产品
    • 缺点：增加产品不需要修改原有代码，需要创建新的类，类会越来越多
    • 特点：在一个工厂中生产相同的产品
    • 实现
  • 抽象工厂模式
  • • 作用：用来生产同一产品族中的固定产品
    • 优点：在产品确定的情况下，比较稳定
    • 缺点：不易增加新产品。
    • 特点：在一个工厂中生产不同的产品，围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。
    • 实现

工厂模式

工厂模式实现了创建者和调用者的分离

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

作用：用来生产同一等级结构中的任意产品。

优点：实现简单

缺点：对于增加新的产品，需要覆盖已有代码

特点：在一个工厂中生产不同的产品

方法一

1.产品的接口类
创建一个形状接口，定义了一个形状方法；

public interface Shape {
    String shape();
}

创建产品类，比如圆，并且实现相应的方法

public class Circle implements Shape {
    @Override
    public String shape() {
        return "圆";
    }
}

创建产品类，比如矩形，并且实现相应的方法

public class Rectangle implements Shape {
    @Override
    public String shape() {
        return "矩形";
    }
}

2.创建工厂类

public class ShapeFactory {
    public static Shape draw(String type) {
        if ("circle".equals(type)) {
            return new Circle();
        } else if ("rectangle".equals(type)) {
            return new Rectangle();
        }
        return null;
    }
}

3.通过客户端调用

public class Client {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.draw("circle");
        System.out.println(circle.shape());
        Shape rectangle = ShapeFactory.draw("rectangle");
        System.out.println(rectangle.shape());
    }
}

客户端使用的时候不需要自己创建对象，通过工厂获取对象

方法二

1.产品的接口类
创建一个形状接口，定义了一个形状方法；

public interface Shape {
    String shape();
}

创建产品类，比如圆，并且实现相应的方法

public class Circle implements Shape {
    @Override
    public String shape() {
        return "圆";
    }
}

创建产品类，比如矩形，并且实现相应的方法

public class Rectangle implements Shape {
    @Override
    public String shape() {
        return "矩形";
    }
}

2.创建工厂类

public class ShapeFactory {
    public static Shape getCircle() {
    	return new Circle();
	}

	public static Shape getRectangle() {
    	return new Rectangle();
	}
}

3.通过客户端调用

public class Client {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.getCircle();
        System.out.println(circle.shape());
        Shape rectangle = ShapeFactory.getRectangle();
        System.out.println(rectangle.shape());
    }
}

客户端使用的时候不需要自己创建对象，通过工厂获取对象

工厂方法模式

作用：用来生产同一等级结构中的固定产品。

优点：支持增加任意产品

缺点：增加产品不需要修改原有代码，需要创建新的类，类会越来越多

特点：在一个工厂中生产相同的产品

实现

1.需要两个接口（一个是产品接口，一个是工厂接口）

public interface Shape {
    String shape();
}

public interface MethodFactory {
    Shape draw();
}

2.创建两个产品类，并实现产品接口

public class Circle implements Shape {
    @Override
    public String shape() {
        return "圆";
    }
}

public class Rectangle implements Shape {
    @Override
    public String shape() {
        return "矩形";
    }
}

3.创建两个工厂类

public class CircleFactory implements MethodFactory {
    @Override
    public Shape draw() {
        return new Circle();
    }
}

public class RectangleFactory implements MethodFactory {
    @Override
    public Shape draw() {
        return new Rectangle();
    }
}

4.客户端使用

public class Client {
    public static void main(String[] args) {
        MethodFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.draw();
        System.out.println(circle.shape());

        MethodFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.draw();
        System.out.println(rectangle.shape());
    }
}

抽象工厂模式

作用：用来生产同一产品族中的固定产品

优点：在产品确定的情况下，比较稳定

缺点：不易增加新产品。

特点：在一个工厂中生产不同的产品，围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。

实现

1.创建两个产品接口
矩形接口

public interface Rectangle {
    String shape();
}

圆形接口

public interface Circle {
    String shape();
}

2.创建产品类

public class GreenCircle implements Circle{
    @Override
    public String shape() {
        return "绿色的圆";
    }
}

public class GreenRectangle implements Rectangle {
    @Override
    public String shape() {
        return "绿色的矩形";
    }
}

public class RedCircle implements Circle {
    @Override
    public String shape() {
        return "红色的圆";
    }
}

public class RedRectangle implements Rectangle {
    @Override
    public String shape() {
        return "红色的矩形";
    }
}

3.创建一个抽象的超级工厂

public interface AbstractFactory {
    Circle circle();

    Rectangle rectangle();
}

4.创建工厂

public class RedFactory implements AbstractFactory {
    @Override
    public Circle circle() {
        return new RedCircle();
    }

    @Override
    public Rectangle rectangle() {
        return new RedRectangle();
    }
}

public class GreenFactory implements AbstractFactory {
    @Override
    public Circle circle() {
        return new GreenCircle();
    }

    @Override
    public Rectangle rectangle() {
        return new GreenRectangle();
    }
}

5.在客户端中使用

public class Client {
    public static void main(String[] args) {
        GreenFactory greenFactory = new GreenFactory();
        Circle greenCircle = greenFactory.circle();
        Rectangle greenRectangle = greenFactory.rectangle();

        RedFactory redFactory = new RedFactory();
        Circle redCircle = redFactory.circle();
        Rectangle redRectangle = redFactory.rectangle();

        System.out.println(greenCircle.shape());
        System.out.println(greenRectangle.shape());

        System.out.println(redCircle.shape());
        System.out.println(redRectangle.shape());
    }
}