设计模式---工厂模式

在设计模式中，工厂模式可以大致分为三类：简单工厂模式、工厂方法模式和抽象工厂模式。

 

1.简单工厂模式

1.1定义

简单工厂模式是由一个工厂对象根据收到的消息决定要创建哪一个类的对象实例。

 

1.2例子

/**
 * 形状接口，定义draw()方法
 */
public interface Shape {

    void draw();

}

 

/**
 * 圆形
 */
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("This is Circle: draw()...");
    }
}

 

/**
 * 矩形
 */
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("This is Rectangle: draw()...");
    }
}

 

/**
 * 正方形
 */
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("This is Square: draw()...");
    }
}

 

/**
 * 简单工厂类
 */
public class ShapeFactory {

    public static Shape getShape(String shapeType) {
        if ("circle".equalsIgnoreCase(shapeType)) {
            return new Circle();
        } else if ("rectangle".equalsIgnoreCase(shapeType)) {
            return new Rectangle();
        } else if ("square".equalsIgnoreCase(shapeType)) {
            return new Square();
        }

        return null;
    }

}

 

public class SimpleFactoryDemo {

    public static void main(String[] args) {
        Shape circle = ShapeFactory.getShape("circle");
        circle.draw();
        Shape rectangle = ShapeFactory.getShape("rectangle");
        rectangle.draw();
        Shape square = ShapeFactory.getShape("square");
        square.draw();
    }

}

 

2.工厂方法模式

2.1定义

提供一个用于创建对象的接口(工厂接口)，让其实现类(工厂实现类)决定实例化哪一个类(产品类)，并且由该实现类创建对应类的实例。

 

2.2例子

/**
 * 工厂接口
 */
public interface ShapeFactory {

    Shape getShape();

}

 

/**
 * 圆形工厂类
 */
public class CircleFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        return new Circle();
    }
}

 

/**
 * 矩形工厂类
 */
public class RectangleFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        return new Rectangle();
    }
}

 

/**
 * 正方形工厂类
 */
public class SquareFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        return new Square();
    }
}

 

public class MethodFactoryDemo {

    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.getShape();
        circle.draw();

        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.getShape();
        rectangle.draw();

        ShapeFactory squareFactory = new SquareFactory();
        Shape square = squareFactory.getShape();
        square.draw();
    }

}

工厂方法模式与简单工厂模式的区别在于，工厂方法模式定义了一个工厂接口，所有的工厂类（子类）都继承此接口，程序需要指明具体工厂类并且创建来获取产品对象。

 

3.抽象工厂模式

3.1定义

抽象工厂是围绕一个超级工厂创建其他工厂，该超级工厂又称为其他工厂的工厂。提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

 

3.2例子

添加颜色接口

/**
 * 颜色接口
 */
public interface Color {

    void fill();

}

 

/**
 * 红色
 */
public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("This is Red: fill()...");
    }
}

 

/**
 * 绿色
 */
public class Green implements Color {
    @Override
    public void fill() {
        System.out.println("This is Green: fill()...");
    }
}

 

/**
 * 蓝色
 */
public class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("This is Blue: fill()...");
    }
}

 

/**
 * 抽象工厂类
 */
public abstract class AbstractFactory {

    public abstract Color getColor(String colorType);
    public abstract Shape getShape(String shapeType) ;

}

 

/**
 * 形状工厂类
 */
public class ShapeFactory extends AbstractFactory {
    @Override
    public Color getColor(String colorType) {
        return null;
    }

    @Override
    public Shape getShape(String shapeType) {
        if ("circle".equalsIgnoreCase(shapeType)) {
            return new Circle();
        } else if ("rectangle".equalsIgnoreCase(shapeType)) {
            return new Rectangle();
        } else if ("square".equalsIgnoreCase(shapeType)) {
            return new Square();
        }

        return null;
    }
}

 

/**
 * 颜色工厂类
 */
public class ColorFactory extends AbstractFactory {
    @Override
    public Color getColor(String colorType) {
        if ("red".equalsIgnoreCase(colorType)) {
            return new Red();
        } else if ("green".equalsIgnoreCase(colorType)) {
            return new Green();
        } else if ("blue".equalsIgnoreCase(colorType)) {
            return new Blue();
        }

        return null;
    }

    @Override
    public Shape getShape(String shapeType) {
        return null;
    }
}

 

/**
 * 工厂创造器，用于获取特定工厂类
 */
public class FactoryProducer {

    public static AbstractFactory getFactory(String factoryType) {
        if ("shape".equalsIgnoreCase(factoryType)) {
            return new ShapeFactory();
        } else if ("color".equalsIgnoreCase(factoryType)) {
            return new ColorFactory();
        }

        return null;
    }

}

 

public class AbstractFactoryDemo {

    public static void main(String[] args) {
        AbstractFactory shapeFactory = FactoryProducer.getFactory("shape");
        Shape circle = shapeFactory.getShape("circle");
        circle.draw();

        AbstractFactory colorFactory = FactoryProducer.getFactory("color");
        Color red = colorFactory.getColor("red");
        red.fill();

    }

}

抽象工厂模式和工厂方法模式相似，只不过抽象工厂更加强调父类工厂（超级工厂），通过父类工厂来获取特定子类工厂，再得到产品对象。