设计模式-（单例，简单工厂，工厂，抽象工厂）

单例模式

概念：

确保一个类只有一个实例，而且自行实例化并向震哥哥系统提供这个实例

应用：

无状态的，一般以工具类形式，进行提供

代码：

懒汉式，双重检查锁

java">class Singleton {
	private static volatile Singleton instance = null;
	private Singleton() {}
	public static Singleton getInstance() {
		if (instance == null) {
			synchronized (Singleton.class) {
				if (instance == null) {
					instance = new Singleton();
				}
			}
		}
		return instance;
	}
}

备注：使用volatile修饰，是因为new Singleton()可以拆解为3步：

1、分配内存

2、初始化对象

3、指向刚分配的地址

若发生重排序，假设A线程执行了1和3，还没有执行2，B线程来到判断NULL时，不为NULL，B线程就会直接返回还没有初始化的instance了。volatile可以避免重排序

简单工厂模式

概念：

又称为静态工厂方法模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同，返回不同类的实例，简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

应用：

不够灵活，新增产品需要修改工厂类；

优点在于实现对象的创建和使用分离

代码：

java">public class SimpleFactory {
    public static Product createProduct(String type){
        if (type.equals("A")){
            return new ProductA();
        } else {
            return new ProductB();
        }
    }

    public static void main(String[] args) {
        Product p = SimpleFactory.createProduct("A");
        p.print();
    }
}

abstract class Product{
    public abstract void print();
}

class ProductA extends Product{
    @Override
    public void print(){
        System.out.println("A");
    }

}

class ProductB extends Product{
    @Override
    public void print(){
        System.out.println("B");
    }
}

工厂模式

概念：

定义一个用于创建对象的接口，让子类决定实例化哪个类，工厂方法使一个类的实例化延迟到其子类

应用：

代码：

java">// 定义产品接口
interface Shape {
    void draw();
}

// 具体产品1
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

// 具体产品2
class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Square");
    }
}

// 定义工厂接口
interface ShapeFactory {
    Shape createShape();
}

// 具体工厂1
class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

// 具体工厂2
class SquareFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Square();
    }
}

// 客户端代码
public class FactoryMethodDemo {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw();

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

抽象工厂模式

概念：

一种更高级的工厂模式，用于创建相关或依赖对象的家族，而无需明确指定具体类

代码：

java">// 定义产品接口1
interface Shape {
    void draw();
}

// 定义产品接口2
interface Color {
    void fill();
}

// 具体产品1
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

// 具体产品2
class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Square");
    }
}

// 具体产品3
class RedColor implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with Red Color");
    }
}

// 具体产品4
class BlueColor implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with Blue Color");
    }
}

// 定义抽象工厂接口
interface AbstractFactory {
    Shape getShape(String shapeType);
    Color getColor(String colorType);
}

// 具体工厂1
class ShapeFactory implements AbstractFactory {
    @Override
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }

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

// 具体工厂2
class ColorFactory implements AbstractFactory {
    @Override
    public Shape getShape(String shapeType) {
        return null;
    }

    @Override
    public Color getColor(String colorType) {
        if (colorType == null) {
            return null;
        }
        if (colorType.equalsIgnoreCase("RED")) {
            return new RedColor();
        } else if (colorType.equalsIgnoreCase("BLUE")) {
            return new BlueColor();
        }
        return null;
    }
}

// 工厂生成器
class FactoryProducer {
    public static AbstractFactory getFactory(String choice) {
        if (choice == null) {
            return null;
        }
        if (choice.equalsIgnoreCase("SHAPE")) {
            return new ShapeFactory();
        } else if (choice.equalsIgnoreCase("COLOR")) {
            return new ColorFactory();
        }
        return null;
    }
}

// 客户端代码
public class AbstractFactoryDemo {
    public static void main(String[] args) {
        AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
        Shape shape1 = shapeFactory.getShape("CIRCLE");
        shape1.draw();

        Shape shape2 = shapeFactory.getShape("SQUARE");
        shape2.draw();

        AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
        Color color1 = colorFactory.getColor("RED");
        color1.fill();

        Color color2 = colorFactory.getColor("BLUE");
        color2.fill();
    }
}