静态类与Java装饰器模式的结合

静态类和Java装饰器模式可以结合使用，以提供更灵活和强大的功能。装饰器模式是一种结构型设计模式，它允许在不修改原始类代码的情况下，动态地给对象添加新的功能或行为。而静态类则是一种特殊的类，它在编译时就已经存在，并且不能被实例化。

下面是一个简单的示例，展示了如何将静态类和Java装饰器模式结合使用：

1. 首先，定义一个接口或抽象类，作为被装饰类和装饰器类的基类：

public interface Component {
    void operation();
}

2. 创建一个具体的组件类，实现上述接口或抽象类：

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

3. 定义一个静态类，用于存储装饰器类的集合：

public static class DecoratorRegistry {
    private static Map<Class<? extends Component>, List<Component>> decorators = new HashMap<>();

    public static <T extends Component> void register(Class<T> componentType, T component) {
        decorators.computeIfAbsent(componentType, k -> new ArrayList<>()).add(component);
    }

    public static <T extends Component> List<T> getDecorators(Class<T> componentType) {
        return decorators.getOrDefault(componentType, Collections.emptyList());
    }
}

在这个示例中，DecoratorRegistry静态类用于存储装饰器类的集合。register方法用于注册装饰器类，getDecorators方法用于获取指定类型的装饰器列表。

4. 创建一个抽象装饰器类，实现上述接口或抽象类，并添加一个用于存储子装饰器的成员变量：

public abstract class Decorator implements Component {
    protected final Component component;

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

    @Override
    public void operation() {
        component.operation();
    }
}

在这个示例中，Decorator抽象装饰器类实现了Component接口，并添加了一个用于存储子装饰器的成员变量component。

5. 创建具体的装饰器类，继承自抽象装饰器类，并在其中添加新的功能或行为：

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

    @Override
    public void operation() {
        System.out.println("ConcreteDecoratorA before operation");
        super.operation();
        System.out.println("ConcreteDecoratorA after operation");
    }
}

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

    @Override
    public void operation() {
        System.out.println("ConcreteDecoratorB before operation");
        super.operation();
        System.out.println("ConcreteDecoratorB after operation");
    }
}

在这个示例中，ConcreteDecoratorA和ConcreteDecoratorB是具体的装饰器类，它们继承自抽象装饰器类Decorator，并在其中添加了新的功能或行为。

6. 使用装饰器模式给对象添加新的功能或行为：

public class Main {
    public static void main(String[] args) {
        // 创建一个具体组件对象
        Component component = new ConcreteComponent();

        // 使用装饰器模式给对象添加新的功能或行为
        Decorator decoratorA = new ConcreteDecoratorA(component);
        Decorator decoratorB = new ConcreteDecoratorB(decoratorA);
        component = decoratorB;

        // 调用对象的方法
        component.operation();
    }
}

在这个示例中，我们首先创建了一个具体组件对象component，然后使用装饰器模式给它添加了两个新的功能或行为ConcreteDecoratorA和ConcreteDecoratorB。最后，我们调用对象的方法operation()，可以看到新添加的功能或行为被执行了。