设计模式(二)——创建型模式

1、简单工厂模式

简单工厂模式又叫静态工厂方法模式。属于创建型模式，在简单的工厂模式中可以根据参数的不同返回不同的实例。

简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

Factory:工厂角色——负责实现创建所有实例的内部逻辑

Product：抽象产品角色——所创建的所有对象的父类，负责描述所有实例共有的公共接口

ConceretProduct：具体的产品角色——创建的目标，所有创建对象都充当这个角色的某个具体类的实例。

public interface Annimals {
    void eat();
}

public class Cat implements Annimals {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Dog implements Annimals {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

public class AnnimalFactory {
    public Annimals getAnnimals(String annimal){

        if(annimal == null){
            return null;
        }
        if (annimal.equalsIgnoreCase("cat")){
            return new Cat();
        }else if (annimal.equalsIgnoreCase("dog")){
            return new Dog();
        }
        return null;
    }
}

public class Main {
    public static void main(String[] args) {
        AnnimalFactory annimalFactory = new AnnimalFactory();
        annimalFactory.getAnnimals("dog").eat();
    }
}

2、工厂方法模式

又称工厂模式或多态工厂模式，属于创建型模式。在该模式中父类负责创建产品的公共接口，子类负责负责具体的产品实现。将产品的实例化操作延迟到子类中。

将上列中的AnnimalFactory类改为：

public class AnnimalFactory {
    /*public Annimals getAnnimals(String annimal){

        if(annimal == null){
            return null;
        }
        if (annimal.equalsIgnoreCase("cat")){
            return new Cat();
        }else if (annimal.equalsIgnoreCase("dog")){
            return new Dog();
        }
        return null;
    }*/
    public Annimals catEat(){
        return new Cat();
    }
    public Annimals dogEat(){
        return new Dog();
    }
}

3、抽象工厂模式

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

形状接口以及形状实体类

public interface Shape {
    void draw();
}

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("画方");
    }
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("画圆");
    }
}

颜色接口以及实体类

public interface Color {
    void fill();
}

public class Red implements Color{
    @Override
    public void fill() {
        System.out.println("涂红");
    }
}

public class Green implements Color {
    @Override
    public void fill() {
        System.out.println("涂绿");
    }
}

为颜色和形状创建抽象类来获取工厂

public abstract class AbstractFactory {
    abstract Color getColor(String color);
    abstract Shape getShape(String shape);
}

扩展AbstractFactory的工厂

public class ShapeFactory extends AbstractFactory {
    @Override
    Color getColor(String color) {
        return null;
    }

    @Override
    Shape getShape(String shape) {
        if (shape == null){
            return null;
        }
        if(shape.equalsIgnoreCase("circle")){
            return new Circle();
        }else if (shape.equalsIgnoreCase("square")){
            return new Square();
        }
        return null;
    }
}

public class ColorFactory extends AbstractFactory {

    @Override
    Color getColor(String color) {
        if (color == null){
            return null;
        }
        if (color.equalsIgnoreCase("red")){
            return new Red();
        }else if (color.equalsIgnoreCase("green")){
            return new Green();
        }
        return null;
    }

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

创建工厂生成器，通过传递颜色和形状信息来创建工厂

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

public class Main {
    public static void main(String[] args) {
        AbstractFactory shape = FactoryProducer.getFactory("shape");
        shape.getShape("circle").draw();
        AbstractFactory color = FactoryProducer.getFactory("color");
        color.getColor("red").fill();
    }
}

4、建造者模式

将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。

创建表示食物条目和事务包装的接口

public interface Item {
    public String name();
    public Package packing();
    public float price();
}

public interface Packing {
    public String pack();
}

包装接口的实现类

public class Wrapper implements Packing {
    @Override
    public String pack() {
        return "Wrapper";
    }
}

public class Bottle implements Packing{

    @Override
    public String pack() {
        return "Bottle";
    }
}

包装条目的抽象实现类

public abstract class Burger implements Item{
    @Override
    public Packing packing() {
        return new Wrapper();
    }

    @Override
    public abstract float price() ;
}

public abstract class ColdDrink implements Item{
    @Override
    public Packing packing() {
        return new Bottle();
    }

    @Override
    public abstract float price() ;
}

扩展了Burger和ColdDrink的实现类

public class VegBurger extends Burger {
    @Override
    public String name() {
        return "Veg Burger";
    }

    @Override
    public float price() {
        return 25.0f;
    }
}

public class ChickenBurger extends Burger{
    @Override
    public String name() {
        return "Chicken Burger";
    }

    @Override
    public float price() {
        return 50.5f;
    }
}

public class Coke extends ColdDrink {
    @Override
    public String name() {
        return "Coke";
    }

    @Override
    public float price() {
        return 30.3f;
    }
}

public class Pepsi extends ColdDrink {
    @Override
    public String name() {
        return "Pepsi";
    }

    @Override
    public float price() {
        return 30.5f;
    }
}

创建一个Meal类带有上面定义的Item对象

pubealic class Meal {
    private List<Item> items = new ArrayList<Item>();

    public void addItem(Item item){
        items.add(item);
    }

    public float getCost(){
        float cost = 0.0f;
        for (Item item: items) {
            cost += item.price();
        }
        return cost;
    }

    public void showItems(){
        for (Item item:items) {
            System.out.println("Item: "+item.name());
            System.out.println(",Packing: "+item.packing());
            System.out.println(",Price: "+item.price());
        }
    }
}

创建一个MealBuilder类，实际的builder类负责创建Meal对象

public class MealBuilder {
    public Meal prepareVegMeal(){
        Meal meal = new Meal();
        meal.addItem(new VegBurger());
        meal.addItem(new Coke());
        return meal;
    }
    public Meal prepareNonVegMeal(){
        Meal meal = new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        return meal;
    }
}

使用MealBuilder来演示创建者模式

public class Main {
    public static void main(String[] args) {
        MealBuilder builder = new MealBuilder();

        Meal vegMeal = builder.prepareVegMeal();
        System.out.println("vegMeal");
        vegMeal.showItems();
        System.out.println("Total Cost: "+vegMeal.getCost());

        Meal nonMeal = builder.prepareNonVegMeal();
        System.out.println("nonMeal");
        nonMeal.showItems();
        System.out.println("Total Cost: "+nonMeal.getCost());
    }

}

5、单例模式

Java中最简单的的设计模式之一，单例模式确保某一个类只有一个实例，并且自行实例化并向整个系统提供这个实例。

创建一个Singleton类

public class SingletonObject {
    //创建SingletonObject的一个对象
    private static SingletonObject instance = new SingletonObject();
    //让构造函数为private，这样该类就不会被实例化
    private SingletonObject(){}
    //获取唯一可用的对象
    public static SingletonObject getInstance(){
        return instance;
    }
    public void showInstance(){
        System.out.println("HelloWorld");
    }
}

从singleton类获取唯一的对象

public class Main {
    public static void main(String[] args) {
        //不合法的构造函数，编译时错误：SingletonObject是不可见的。
        //SingletonObject ob = new SingletonObject();

        //获取唯一可用的对象
        SingletonObject object = SingletonObject.getInstance();
        object.showInstance();
    }
}

单例模式几种实现方式：

1）、懒汉式，线程不安全，没枷锁，不支持多线程

public class SingletonObject {
    //创建SingletonObject的一个对象
    private static SingletonObject instance;
    //让构造函数为private，这样该类就不会被实例化
    private SingletonObject(){}
    //获取唯一可用的对象
    public static SingletonObject getInstance(){
        if (instance == null){
            instance = new SingletonObject();
        }
        return instance;
    }

2）、懒汉式，线程安全，支持多线程，但是效率低

public class SingletonObject {
    //创建SingletonObject的一个对象
    private static SingletonObject instance;
    //让构造函数为private，这样该类就不会被实例化
    private SingletonObject(){}
    //获取唯一可用的对象
    public static synchronized SingletonObject getInstance(){
        if (instance == null){
            instance = new SingletonObject();
        }
        return instance;
    }

3）、饿汉式，多线程安全，基于ClassLoader避免了多线程同步问题，没加锁，效率比较高

public class SingletonObject {
    //创建SingletonObject的一个对象
    private static SingletonObject instance = new SingletonObject();
    //让构造函数为private，这样该类就不会被实例化
    private SingletonObject(){}
    //获取唯一可用的对象
    public static SingletonObject getInstance(){
        return instance;
    }

4）、双检锁/双重校验锁（DCL）：较复杂，但是安全且在多线程下能够保持高性能

public class SingletonObject {
    //创建SingletonObject的一个对象
    private volatile static SingletonObject instance ;
    //让构造函数为private，这样该类就不会被实例化
    private SingletonObject(){}
    //获取唯一可用的对象
    public static SingletonObject getInstance(){
        synchronized (SingletonObject.class){
            if (instance == null){
                instance = new SingletonObject();
            }
        }
        return instance;
    }

5）、登记式/静态内部类：能达到双检锁方式一样的功效，但实现更简单

public class SingletonObject {
    private static class SingletonHolder{
        private static final SingletonObject INSTANCE = new SingletonObject();
        private SingletonHolder(){}
        private static final SingletonObject getInstance(){
            return SingletonHolder.INSTANCE;
        }
    }

6）、枚举：简洁，线程安全，自动支持序列化机制，绝对防止多次实例化

public enum Singleton {
    INSTANCE;
    public void Method(){
        
    }
}