Head First设计模式：深入理解常见设计模式的应用

最新推荐文章于 2024-09-15 22:03:14 发布

卿无讳

最新推荐文章于 2024-09-15 22:03:14 发布

阅读量11

点赞数

文章标签：设计模式单例模式

Head First设计模式：深入理解常见设计模式的应用

大家好，我是微赚淘客返利系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！

设计模式简介

设计模式是软件工程中常见的解决特定问题的模板。它们是经过验证的解决方案，可以提高代码的可维护性和可扩展性。

创建型模式

创建型模式主要关注对象的创建过程，确保实例化过程的封装和解耦。

单例模式

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

package cn.juwatech.creational.singleton;

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

工厂方法模式

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

package cn.juwatech.creational.factory;

interface Product {
    void use();
}

class ConcreteProduct implements Product {
    public void use() {
        System.out.println("Using ConcreteProduct");
    }
}

abstract class Creator {
    abstract Product factoryMethod();
}

class ConcreteCreator extends Creator {
    @Override
    Product factoryMethod() {
        return new ConcreteProduct();
    }
}

结构型模式

结构型模式主要关注对象的组合，通过简单方式实现对象间的协作。

装饰者模式

装饰者模式允许用户在不修改对象的基础上，动态地给对象添加额外的职责。

package cn.juwatech.structural.decorator;

interface Component {
    void operate();
}

class ConcreteComponent implements Component {
    public void operate() {
        System.out.println("ConcreteComponent operate()");
    }
}

abstract class Decorator implements Component {
    protected Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    public void operate() {
        component.operate();
    }
}

class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    public void operate() {
        super.operate();
        // Add behavior
        System.out.println("ConcreteDecoratorA operate()");
    }
}

行为型模式

行为型模式主要关注对象间的通信，通过定义对象间的相互作用来实现功能。

观察者模式

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

package cn.juwatech.behavioral.observer;

interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

interface Observer {
    void update();
}

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

    public void registerObserver(Observer o) {
        observers.add(o);
    }

    public void removeObserver(Observer o) {
        observers.remove(o);
    }

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

class ConcreteObserver implements Observer {
    public void update() {
        System.out.println("Observer notified");
    }
}