Java中常用的设计模式详解

# 1. 介绍设计模式的概念与作用

## 什么是设计模式

设计模式是在面向对象软件设计过程中针对特定问题的可重复使用的解决方案。它是经过反复使用和验证的，被广泛认可的解决问题的方式。设计模式不是一段特定的代码，而是一种解决问题的思路，它描述了在特定情境下的解决方案。

## 设计模式的作用与优势

设计模式的作用主要体现在以下几个方面：
- 提高软件的可维护性和可复用性
- 促进代码的灵活性和扩展性
- 促进设计思想的传播和沉淀

使用设计模式能够使代码更易于理解和维护，降低系统耦合度，提高代码的灵活性和可重用性。

## 设计模式在Java中的应用场景

在Java开发中，设计模式广泛应用于各种场景，如单例模式用于线程池、工厂模式用于对象创建、观察者模式用于事件监听等。设计模式在Java中的应用能够更好地组织代码，提高代码质量和可维护性。

# 2. 创建型设计模式

创建型设计模式主要关注对象的实例化过程，旨在找到更好的方法来创建对象。下面是几种常见的创建型设计模式：

#### 单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。这在需要控制资源访问、配置设置等场景中非常有用。以下是一个简单的单例模式示例：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

##### 场景及应用
单例模式适合需要全局访问点的情况，比如线程池、日志记录器、配置文件等。

#### 工厂模式

工厂模式用于创建对象，而不是在代码中直接实例化对象。这样做可以隐藏创建对象的逻辑，并提供更高的灵活性。以下是一个简单的工厂模式示例：

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

public class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

##### 场景及应用
工厂模式适合在需要根据指定条件创建不同对象的情况，比如在图形绘制程序中根据用户选择创建不同的图形对象。

#### 抽象工厂模式

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。以下是一个简单的抽象工厂模式示例：

public interface Color {
    void fill();
}

public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Inside Red::fill() method.");
    }
}

public class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Inside Blue::fill() method.");
    }
}

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

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

public class ShapeFactory extends AbstractFactory {
    @Override
    public Color getColor(String color) {
        return null;
    }
    @Override
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

public class ColorFactory extends AbstractFactory {
    @Override
    public Color getColor(String color) {
        if (color == null) {
            return null;
        }
        if (color.equalsIgnoreCase("RED")) {
            return new Red();
        } else if (color.equalsIgnoreCase("BLUE")) {
            return new Blue();
        }
        return null;
    }
    @Override
    public Shape getShape(String shape) {
        return null;
    }
}

##### 场景及应用
抽象工厂模式适合在需要创建一系列相关对象的情况，比如在图形界面工具包中需要创建不同操作系统风格的界面元素。

#### 建造者模式

建造者模式用于构建一个复杂对象，将构建过程与表示分离，使得同样的构建过程可以创建不同的表示。以下是一个简单的建造者模式示例：

public class Meal {
    private String burger;
    private String drink;

    public String getBurger() {
        return burger;
    }
    public void setBurger(String burger) {
        this.burger = burger;
    }
    public String getDrink() {
        return drink;
    }
    public void setDrink(String drink) {
        this.drink = drink;
    }
}

public interface MealBuilder {
    void buildBurger();
    void buildDrink();
    Meal getMeal();
}

public class VegMealBuilder implements MealBuilder {
    private Meal meal = new Meal();
    @Override
    public void buildBurger() {
        meal.setBurger("Veg Burger");
    }
    @Override
    public void buildDrink() {
        meal.setDrink("Coke");
    }
    @Override
    public Meal getMeal() {
        return meal;
    }
}

public class NonVegMealBuilder implements MealBuilder {
    private Meal meal = new Meal();
    @Override
    public void buildBurger() {
        meal.setBurger("Chicken Burger");
    }
    @Override
    public void buildDrink() {
        meal.setDrink("Pepsi");
    }
    @Override
    public Meal getMeal() {
        return meal;
    }
}

public class MealDirector {
    public Meal createMeal(MealBuilder mealBuilder) {
        mealBuilder.buildBurger();
        mealBuilder.buildDrink();
        return mealBuilder.getMeal();
    }
}

##### 场景及应用
建造者模式适合在创建对象的构建步骤比较复杂且有多种表示时应用，比如在制作套餐时，需要根据顾客选择的不同组合构建复杂的套餐对象。

#### 原型模式

原型模式用于创建复杂对象，通过复制现有对象的方式创建新对象。以下是一个简单的原型模式示例：

import java.util.Hashtable;

public abstract class Shape implements Cloneable {
    private String id;
    protected String type;

    abstract void draw();

    public String getType() {
        return type;
    }
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
}

public class Circle extends Shape {
    public Circle() {
        type = "Circle";
    }