五类常见的创建型模式。

 1、单例模式：懒汉式（线程安全，使用双重检查锁定）

package com.model.Singleton;

public class Singleton {
	
	private volatile static Singleton instance;

	private Singleton() {
	}

	public static Singleton getInstance() {
		if (instance == null) {
			synchronized (Singleton.class) {
				if (instance == null) {
					instance = new Singleton();
				}
			}
		}
		return instance;
	}

	public void showMessage() {
		
		System.out.println("Hello, I am a singleton object.");
	}

	public class Main {

		public static void main(String[] args) {

			Singleton singleton = Singleton.getInstance();

			singleton.showMessage();
		}

	}
}

 2、建造者模式：

Pizza 类是需要被建造的对象。它的属性包括 crust（面团）、 sauce（酱料）、 cheese（奶酪）和 topping（配料）。Pizza 类的构造函数是私有的，通过一个 Builder 类来构建 Pizza 对象。

Builder 类包含用于设置 Pizza 属性的方法，每个方法返回 Builder 对象本身，以便可以进行链式调用。最后，build 方法用于实际构建 Pizza 对象并返回。

在 main 方法中，我们可以使用链式调用来构建自定义属性的 Pizza 对象，并将其打印输出。

package com.model.builder;
public class Pizza {
    private String crust;
    private String sauce;
    private String cheese;
    private String topping;

    private Pizza(Builder builder) {
        this.crust = builder.crust;
        this.sauce = builder.sauce;
        this.cheese = builder.cheese;
        this.topping = builder.topping;
    }

    @Override
    public String toString() {
        return "Pizza [crust=" + crust + ", sauce=" + sauce + ", cheese=" + cheese + ", topping=" + topping + "]";
    }

    public static class Builder {
        private String crust;
        private String sauce;
        private String cheese;
        private String topping;

        public Builder crust(String crust) {
            this.crust = crust;
            return this;
        }

        public Builder sauce(String sauce) {
            this.sauce = sauce;
            return this;
        }

        public Builder cheese(String cheese) {
            this.cheese = cheese;
            return this;
        }

        public Builder topping(String topping) {
            this.topping = topping;
            return this;
        }

        public Pizza build() {
            return new Pizza(this);
        }
    }

    public static void main(String[] args) {
        Pizza pizza = new Pizza.Builder()
                .crust("Thin crust")
                .sauce("Tomato sauce")
                .cheese("Mozzarella cheese")
                .topping("Pepperoni")
                .build();

        System.out.println(pizza);
    }
}

3、 抽象工厂模式：

本例中有两个产品族：汽车（Car）和SUV（SUV）。每个产品族有不同的具体产品：Toyota工厂生产的是SedanCar和SUVCar，而Ford工厂生产的也是SedanCar和SUVCar。

为了实现抽象工厂模式，我们首先定义了两个接口：Car和SUV。然后我们创建了两个具体产品类：SedanCar和SUVCar，它们实现了对应的接口。

接下来，我们定义了一个抽象工厂接口CarFactory，它声明了创建Car和SUV的方法。

然后我们创建了两个具体工厂类：ToyotaFactory和FordFactory，它们分别实现了CarFactory接口，并对应的方法具体实现。

最后，在Main类中，我们可以使用具体工厂来创建对应的产品。通过调用工厂的方法，我们可以得到具体的产品实例，并调用相关方法来操作这些产品。

package com.model.abstractfactory;

public interface Car {
    void drive();
}

package com.model.abstractfactory;

public interface CarFactory {
    Car createCar();
    SUV createSUV();
}

package com.model.abstractfactory;

public class FordFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SedanCar();
    }

    @Override
    public SUV createSUV() {
        return new SUVCar();
    }
}

package com.model.abstractfactory;

public interface SUV {
    void drive();
}

 

package com.model.abstractfactory;

public class SUVCar implements SUV {
    @Override
    public void drive() {
        System.out.println("Driving an SUV car");
    }
}

package com.model.abstractfactory;

public class SedanCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving a Sedan car");
    }
}

package com.model.abstractfactory;

public class ToyotaFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SedanCar();
    }

    @Override
    public SUV createSUV() {
        return new SUVCar();
    }
}

package com.model.abstractfactory;

public class Main {
    public static void main(String[] args) {
        CarFactory toyotaFactory = new ToyotaFactory();
        CarFactory fordFactory = new FordFactory();

        Car toyotaCar = toyotaFactory.createCar();
        SUV toyotaSUV = toyotaFactory.createSUV();

        Car fordCar = fordFactory.createCar();
        SUV fordSUV = fordFactory.createSUV();

        toyotaCar.drive();
        toyotaSUV.drive();
        fordCar.drive();
        fordSUV.drive();
    }
}

 

4、工厂方法模式：

我们有一个产品：Car。Car有两个具体实现类：SedanCar和SUVCar。

为了实现工厂方法模式，我们定义了一个CarFactory接口，它有一个方法createCar()，用于创建Car实例。

然后，我们创建了两个具体工厂类：SedanCarFactory和SUVCarFactory。它们实现了CarFactory接口，并分别实现了createCar()方法来创建具体的Car实例。

在Main类中，我们可以使用具体工厂来创建对应的产品。通过调用工厂的createCar()方法，我们可以得到具体的Car实例，并调用相关方法来操作这些产品

package com.model.factorymethod;

public interface Car {
    void drive();
}

 

package com.model.factorymethod;

public interface CarFactory {
    Car createCar();
}

package com.model.factorymethod;

public class SedanCarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SedanCar();
    }
}

 

package com.model.factorymethod;

public class SUVCarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SUVCar();
    }
}

 

package com.model.factorymethod;

public class SedanCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving a Sedan car");
    }
}

 

 

package com.model.factorymethod;

public class SUVCar implements Car {
    @Override
    public void drive() {
        System.out.println("Driving an SUV car");
    }
}

 

package com.model.factorymethod;

public class Main {
    public static void main(String[] args) {
        CarFactory sedanCarFactory = new SedanCarFactory();
        CarFactory suvCarFactory = new SUVCarFactory();

        Car sedanCar = sedanCarFactory.createCar();
        Car suvCar = suvCarFactory.createCar();

        sedanCar.drive();
        suvCar.drive();
    }
}

 5、静态工厂模式：

本例中，Car类有一个私有的构造方法，通过静态的createSedanCar()和createSUVCar()方法来创建Car实例。这些静态方法隐藏了对象的创建细节，而且可以根据不同的参数返回不同的对象。在Main类中，我们使用静态方法来创建Car实例，并调用相关方法来操作这些对象。

package com.model.staticfactory;

public class Car {
    private String type;
    private String color;

    private Car(String type, String color) {
        this.type = type;
        this.color = color;
    }

    public static Car createSedanCar(String color) {
        return new Car("Sedan", color);
    }

    public static Car createSUVCar(String color) {
        return new Car("SUV", color);
    }

    public void drive() {
        System.out.println("Driving a " + color + " " + type + " car");
    }
}

 

package com.model.staticfactory;

public class Main {
    public static void main(String[] args) {
        Car sedanCar = Car.createSedanCar("blue");
        Car suvCar = Car.createSUVCar("red");

        sedanCar.drive();
        suvCar.drive();
    }
}