浅谈Java常见设计模式及实例

前言

Java 中常用的设计模式有很多种，其实平常用到的还比较少，但是还是有必要了解一下，可以按照实际情况运用到我们的代码中。按照类型可以基本分解为，创建型模式、结构型模式和行为型模式。

创建型模式 (Creational Patterns)

1. 工厂方法模式 (Factory Method Pattern):

定义一个创建对象的接口，但是将实际的创建工作交给子类来实现。
考虑一个简单的工厂方法，生产不同类型的形状对象：

  interface Shape {
         void draw();
     }
     
     class Circle implements Shape {
         @Override
         public void draw() {
             System.out.println("Inside Circle::draw() method.");
         }
     }
     
     class Rectangle implements Shape {
         @Override
         public void draw() {
             System.out.println("Inside Rectangle::draw() method.");
         }
     }
     
     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;
         }
     }

2. 抽象工厂模式 (Abstract Factory Pattern)

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
考虑一个抽象工厂，生产不同类型的形状和颜色对象的组合：

   interface Shape {
         void draw();
     }
     
     interface Color {
         void fill();
     }
     
     class Rectangle implements Shape {
         @Override
         public void draw() {
             System.out.println("Inside Rectangle::draw() method.");
         }
     }
     
     class Blue implements Color {
         @Override
         public void fill() {
             System.out.println("Inside Blue::fill() method.");
         }
     }
     
     abstract class AbstractFactory {
         abstract Shape getShape(String shapeType);
         abstract Color getColor(String colorType);
     }
     
     class ShapeFactory extends AbstractFactory {
         @Override
         Shape getShape(String shapeType) {
             if (shapeType.equalsIgnoreCase("RECTANGLE")) {
                 return new Rectangle();
             }
             return null;
         }
     
         @Override
         Color getColor(String colorType) {
             return null;
         }
     }
     
     class ColorFactory extends AbstractFactory {
         @Override
         Shape getShape(String shapeType) {
             return null;
         }
     
         @Override
         Color getColor(String colorType) {
             if (colorType.equalsIgnoreCase("BLUE")) {
                 return new Blue();
             }
             return null;
         }
     }

3. 建造者模式 (Builder Pattern)

将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
考虑一个简单的食物构建器，可以构建汉堡和冷饮：

    class Burger {
         private String size;
         private boolean cheese;
         private boolean pepperoni;
         private boolean lettuce;
     
         public Burger(BurgerBuilder builder) {
             this.size = builder.size;
             this.cheese = builder.cheese;
             this.pepperoni = builder.pepperoni;
             this.lettuce = builder.lettuce;
         }
     
         static class BurgerBuilder {
             private String size;
             private boolean cheese;
             private boolean pepperoni;
             private boolean lettuce;
     
             public BurgerBuilder(String size) {
                 this.size = size;
             }
     
             public BurgerBuilder cheese(boolean cheese) {
                 this.cheese = cheese;
                 return this;
             }
     
             public BurgerBuilder pepperoni(boolean pepperoni) {
                 this.pepperoni = pepperoni;
                 return this;
             }
     
             public BurgerBuilder lettuce(boolean lettuce) {
                 this.lettuce = lettuce;
                 return this;
             }
     
             public Burger build() {
                 return new Burger(this);
             }
         }
     }

4. 单例模式 (Singleton Pattern)

确保一个类只有一个实例，并提供一个全局访问点。
实现一个线程安全的懒汉式单例：

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

 

结构型模式 (Structural Patterns)

1.适配器模式 (Adapter Pattern)

将一个类的接口转换成客户端希望的另一个接口。
使用适配器让美国插头可以插入英国插座：

 interface UKPlug {
         void provideElectricity();
     }
     
     class UKSocket implements UKPlug {
         @Override
         public void provideElectricity() {
             System.out.println("Providing electricity with UK plug.");
         }
     }
     
     interface USPlug {
         void supplyElectricity();
     }
     
     class USPlugConnector implements USPlug {
         @Override
         public void supplyElectricity() {
             System.out.println("Supplying electricity with US plug.");
         }
     }
     
     class USPlugAdapter implements UKPlug {
         private USPlug plug;
         
         public USPlugAdapter(USPlug plug) {
             this.plug = plug;
         }
         
         @Override
         public void provideElectricity() {
             plug.supplyElectricity();
         }
     }

2. 桥接模式 (Bridge Pattern)

将抽象部分与它的实现部分分离，使它们可以独立地变化。
将不同颜色的笔与不同类型的绘图设备连接起来：

  interface DrawAPI {
         void draw();
     }
     
     abstract class Shape {
         protected DrawAPI drawAPI;
         
         protected Shape(DrawAPI drawAPI) {
             this.drawAPI = drawAPI;
         }
         
         abstract void draw();
     }
     
     class Circle extends Shape {
         private int x, y, radius;
         
         public Circle(int x, int y, int radius, DrawAPI drawAPI) {
             super(drawAPI);
             this.x = x;
             this.y = y;
             this.radius = radius;
         }
         
         @Override
         void draw() {
             drawAPI.draw();
         }
     }

3. 组合模式 (Composite Pattern)

将对象组合成树形结构以表示“部分-整体”的层次结构。
用组合模式表示员工的层级结构：

     import java.util.ArrayList;
     import java.util.List;
     
     class Employee {
         private String name;
         private String dept;
         private int salary;
         private List subordinates;
     
         public Employee(String name, String dept, int sal) {
             this.name = name;
             this.dept = dept;
             this.salary = sal;
             subordinates = new ArrayList();
         }
     
         public void add(Employee e) {
             subordinates.add(e);
         }
     
         public void remove(Employee e) {
             subordinates.remove(e);
         }
     
         public List getSubordinates() {
             return subordinates;
         }
     
         @Override
         public String toString() {
             return ("Employee :[ Name : " + name + ", dept : " + dept + ", salary :" + salary + " ]");
         }
     }

行为型模式 (Behavioral Patterns)

1. 观察者模式 (Observer Pattern)

定义对象间的一对多依赖关系，当一个对象状态发生改变时，它的所有依赖者都会收到通知并自动更新。
实现一个简单的气象站，当气象数据发生变化时，通知所有注册的观察者：

  import java.util.ArrayList;
     import java.util.List;
     
     interface Observer {
         void update(float temperature, float humidity, float pressure);
     }
     
     interface Subject {
         void registerObserver(Observer observer);
         void removeObserver(Observer observer);
         void notifyObservers();
     }
     
     class WeatherData implements Subject {
         private List observers;
         private float temperature;
         private float humidity;
         private float pressure;
     
         public WeatherData() {
             observers = new ArrayList<>();
         }
     
         public void registerObserver(Observer observer) {
             observers.add(observer);
         }
     
         public void removeObserver(Observer observer) {
             observers.remove(observer);
         }
     
         public void notifyObservers() {
             for (Observer observer : observers) {
                 observer.update(temperature, humidity, pressure);
             }
         }
     
         public void measurementsChanged() {
             notifyObservers();
         }
     
         public void setMeasurements(float temperature, float humidity, float pressure) {
             this.temperature = temperature;
             this.humidity = humidity;
             this.pressure = pressure;
             measurementsChanged();
         }
     }

2. 状态模式 (State Pattern)

允许对象在内部状态改变时改变它的行为。
使用状态模式实现一个简单的电梯控制系统：
 

   interface State {
         void doAction(Context context);
     }
     
     class Context {
         private State state;
     
         public void setState(State state) {
             this.state = state;
         }
     
         public State getState() {
             return state;
         }
     }
     
     class StartState implements State {
         public void doAction(Context context) {
             System.out.println("Player is in start state");
             context.setState(this);
         }
     
         public String toString() {
             return "Start State";
         }
     }

3. 策略模式 (Strategy Pattern)

定义一系列算法，将每一个算法封装起来，并使它们可以互相替换。
实现一个简单的排序器，可以根据不同的策略选择不同的排序算法：
 

   import java.util.List;
     
     interface SortStrategy {
         > void sort(List items);
     }
     
     class BubbleSortStrategy implements SortStrategy {
         public > void sort(List items) {
             // 实现冒泡排序算法
         }
     }
     
     class QuickSortStrategy implements SortStrategy {
         public > void sort(List items) {
             // 实现快速排序算法
         }
     }
     
     class Sorter {
         private SortStrategy strategy;
     
         public Sorter(SortStrategy strategy) {
             this.strategy = strategy;
         }
     
         public > void sort(List items) {
             strategy.sort(items);
         }
     }

这只是一些常见的设计模式，Java一共有23种设计模式，实际掌握几种设计模式就可以帮助你更好地组织代码、提高代码的可维护性和可扩展性。