Head First设计模式学习笔记

Head First设计模式学习笔记

大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！今天我们将深入探讨《Head First设计模式》这本经典的学习笔记，帮助您理解和应用软件设计中的关键概念。

为什么要学习设计模式？

设计模式是在软件设计中反复出现的问题的解决方案，它们被广泛应用于提高代码的重用性、灵活性和可维护性。掌握设计模式不仅可以帮助我们更好地理解优秀的软件设计实践，还能够提高我们的设计能力和编码水平。

设计模式的分类

设计模式可以分为三类：创建型模式、结构型模式和行为型模式。我们将介绍每一类模式，并结合Java代码来说明它们的具体应用。

1. 创建型模式

创建型模式关注对象的创建机制，帮助我们更加灵活地创建对象，同时尽量减少耦合。

工厂方法模式（Factory Method Pattern）

工厂方法模式通过定义一个创建对象的接口，但让子类决定实例化哪个类。这样，工厂方法模式让一个类的实例化延迟到其子类。

package cn.juwatech.factoryexample;

// 抽象产品
interface Product {
    void operation();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA operation");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operation");
    }
}

// 抽象工厂
abstract class Factory {
    abstract Product createProduct();
}

// 具体工厂A
class ConcreteFactoryA extends Factory {
    @Override
    Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB extends Factory {
    @Override
    Product createProduct() {
        return new ConcreteProductB();
    }
}

public class FactoryPatternDemo {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.operation();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.operation();
    }
}

2. 结构型模式

结构型模式关注如何将类或对象结合在一起形成更大的结构。

适配器模式（Adapter Pattern）

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

package cn.juwatech.adapterexample;

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

// 需要适配的类（被适配者）
class Adaptee {
    void specificRequest() {
        System.out.println("Adaptee specificRequest");
    }
}

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

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

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}

public class AdapterPatternDemo {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target adapter = new Adapter(adaptee);
        adapter.request();
    }
}

3. 行为型模式

行为型模式关注对象之间的通信，帮助我们更好地分配职责和定义对象之间的交互模式。

观察者模式（Observer Pattern）

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

package cn.juwatech.observeexample;

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

// 主题接口
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 具体主题
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private int state;

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }

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

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

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
}

// 观察者接口
interface Observer {
    void update(int state);
}

// 具体观察者A
class ConcreteObserverA implements Observer {
    @Override
    public void update(int state) {
        System.out.println("ConcreteObserverA updated with state: " + state);
    }
}

// 具体观察者B
class ConcreteObserverB implements Observer {
    @Override
    public void update(int state) {
        System.out.println("ConcreteObserverB updated with state: " + state);
    }
}

public class ObserverPatternDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();

        Observer observerA = new ConcreteObserverA();
        Observer observerB = new ConcreteObserverB();

        subject.registerObserver(observerA);
        subject.registerObserver(observerB);

        subject.setState(10);
        subject.setState(20);

        subject.removeObserver(observerA);

        subject.setState(30);
    }
}

总结

本文介绍了《Head First设计模式》中的部分设计模式，包括工厂方法模式、适配器模式和观察者模式，并提供了相应的Java代码示例。设计模式是软件开发中非常重要的一部分，它们帮助我们解决常见问题，并促进代码的重用和维护。