Java中的设计模式：从入门到精通

大家好，我是微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！设计模式是软件开发中重要的概念，它提供了解决常见设计问题的经验和模板，能够帮助开发者编写出可复用、可维护的高质量代码。本文将深入探讨Java中常见的设计模式，从基础到高级应用，让您从入门到精通设计模式。

一、设计模式概述

1. 什么是设计模式？

设计模式是解决特定问题的一套经过反复验证的解决方案。它们描述了在特定情境下如何解决设计问题，提供了通用的设计蓝图。

2. 设计模式的分类

设计模式按照用途和目的可以分为创建型模式、结构型模式和行为型模式三大类。

  • 创建型模式：处理对象的创建，包括工厂方法、抽象工厂、建造者、原型、单例等。
  • 结构型模式：处理类或对象的组合，包括适配器、桥接、装饰者、外观、享元、代理等。
  • 行为型模式：处理对象之间的交互，包括模板方法、命令、迭代器、观察者、中介者、状态、策略、访问者等。

二、常见设计模式详解

1. 单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供全局访问点。

package cn.juwatech.singleton;

public class Singleton {

    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
2. 工厂方法模式（Factory Method Pattern）

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。

package cn.juwatech.factory;

public interface Product {
    void produce();
}

public class ConcreteProduct implements Product {
    @Override
    public void produce() {
        System.out.println("Producing concrete product.");
    }
}

public interface Factory {
    Product createProduct();
}

public class ConcreteFactory implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProduct();
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
3. 观察者模式（Observer Pattern）

观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。

package cn.juwatech.observer;

import java.util.ArrayList;
import java.util.List;

interface Observer {
    void update(String message);
}

class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received message: " + message);
    }
}

interface Subject {
    void addObserver(Observer observer);

    void removeObserver(Observer observer);

    void notifyObservers(String message);
}

class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();

    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
4. 适配器模式（Adapter Pattern）

适配器模式将一个类的接口转换成客户希望的另一个接口，使得原本不兼容的类可以一起工作。

package cn.juwatech.adapter;

// 目标接口
interface Target {
    void request();
}

// 需要适配的类
class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee specific request.");
    }
}

// 适配器类
class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.

三、设计模式的应用场景

设计模式在软件开发中有广泛的应用场景，可以有效地解决各种设计问题，提高代码的复用性、可读性和可维护性。例如：

  • 单例模式：全局资源访问控制。
  • 工厂方法模式：灵活生成对象实例。
  • 观察者模式：事件驱动系统中的消息通知。
  • 适配器模式：系统接口的兼容性升级。

四、总结

设计模式是软件工程中非常重要的一部分，通过本文的介绍和示例，希望读者能够深入理解Java中常见的设计模式，从入门到精通，灵活运用于实际项目中，提升代码质量和开发效率。