【设计模式之工厂模式】

工厂模式概念

简单工厂 ： 使用一个工厂对象用来生产同一等级结构中的任意产品。（不支持拓展增加产品）
工厂方法 ： 使用多个工厂对象用来生产同一等级结构中对应的固定产品。（支持拓展增加产品）
抽象工厂 ： 使用多个工厂对象用来生产不同产品族的全部产品。（不支持拓展增加产品；支持增加产品族）

简单工厂模式

public class SimpleFactoryTest {
    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();
        shapeFactory.getShape("Circle");
        shapeFactory.getShape("Rectangle");
    }
}


interface Shape {
}

class Circle implements Shape {
    Circle(){System.out.println("Circle...");}
}

class Rectangle implements Shape {
    Rectangle(){System.out.println("Rectangle...");}
}

class ShapeFactory {
    Shape getShape(String shape) {
        switch (shape.toLowerCase()) {
            case "circle":
                new Circle();
                break;
            case "rectangle":
                new Rectangle();
                break;
        }
        return null;
    }
}

工厂方法

public class FunctionFactoryTest {
    public static void main(String[] args) {
        CircleFactory circleFactory = new CircleFactory();
        circleFactory.getShape();
        RectangleFactory rectangleFactory = new RectangleFactory();
        rectangleFactory.getShape();
    }
}


interface Shape {}
class Circle implements Shape {
    Circle(){System.out.println("Circle");    }
}
class Rectangle implements Shape {
    Rectangle() {System.out.println("Rectangle");}
}


interface ShapeFactory{
    Shape getShape();
}
class CircleFactory implements ShapeFactory{

    @Override
    public Shape getShape() {
        return new Circle();
    }
}
class RectangleFactory implements ShapeFactory{
    @Override
    public Shape getShape() {
        return new Rectangle();
    }
}

运行结果

抽象工厂

public class FactoryTest1 {
    public static void main(String[] args) {
        RealFactory realFactory = new RealFactory();
        realFactory.getBook("circleBook");
        realFactory.getBook("rectangleBook");


        realFactory.getShape("circle");
        realFactory.getShape("rectangle");
    }
}

interface Shape {}
class Circle implements Shape {
    Circle() {
        System.out.println("Circle");
    }
}
class Rectangle implements Shape {
    Rectangle() {
        System.out.println("Rectangle");
    }
}

interface Book {}
class CircleBook implements Book {
    CircleBook() {
        System.out.println("CircleBook");
    }
}
class RectangleBook implements Book {
    RectangleBook() {
        System.out.println("RectangleBook");
    }
}


interface AbstractFactory {
    // 图形的工厂
    Shape getShape(String shape);

    // 书的工厂
    Book getBook(String book);
}

class RealFactory implements AbstractFactory {

    @Override
    public Shape getShape(String shape) {
        switch (shape) {
            case "circle":
                new Circle();
                break;
            case "rectangle":
                new Rectangle();
                break;
        }
        return null;
    }

    @Override
    public Book getBook(String book) {
        switch (book) {
            case "circleBook":
                new CircleBook();
                break;
            case "rectangleBook":
                new RectangleBook();
                break;
        }
        return null;
    }
}