泛型类在Java中的设计模式

在Java中，泛型类是一种具有类型参数的类。泛型类的主要目的是提高代码的重用性和类型安全。通过使用泛型，您可以编写一个适用于各种数据类型的通用类，而无需为每种数据类型创建单独的类。

以下是在Java中使用泛型类的一些设计模式：

1. 单例模式（Singleton Pattern）：

单例模式确保一个类只有一个实例，并提供一个全局访问点。泛型类可以用于实现单例模式，以便为特定类型提供单个实例。

public class Singleton<T> {
    private static Singleton<T> instance;
    private T data;

    private Singleton() {}

    public static <T> Singleton<T> getInstance(Class<T> clazz) {
        if (instance == null) {
            instance = new Singleton<>();
        }
        return (Singleton<T>) instance;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

2. 工厂模式（Factory Pattern）：

工厂模式是一种创建型设计模式，它提供了一种在不指定具体类的情况下创建对象的方法。泛型类可以用于实现工厂模式，以便为特定类型创建对象。

public class GenericFactory<T> {
    public T create(Class<T> clazz) {
        try {
            return clazz.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException("Failed to create instance of type: " + clazz.getName(), e);
        }
    }
}

3. 适配器模式（Adapter Pattern）：

适配器模式是一种结构型设计模式，它允许将一个类的接口转换为客户端期望的另一个接口。泛型类可以用于实现适配器模式，以便为特定类型提供适配器。

public class GenericAdapter<T, R> {
    private T target;

    public GenericAdapter(T target) {
        this.target = target;
    }

    public R adapt() {
        // 在这里实现适配器逻辑，将target对象转换为R类型
        return null;
    }
}

4. 装饰器模式（Decorator Pattern）：

装饰器模式是一种结构型设计模式，它允许在不修改原始类的情况下向对象添加新功能。泛型类可以用于实现装饰器模式，以便为特定类型提供装饰器。

public class GenericDecorator<T> implements Iterable<T> {
    private T item;
    private List<GenericDecorator<T>> decorators;

    public GenericDecorator(T item) {
        this.item = item;
        this.decorators = new ArrayList<>();
    }

    public void addDecorator(GenericDecorator<T> decorator) {
        decorators.add(decorator);
    }

    public T getItem() {
        return item;
    }

    @Override
    public Iterator<T> iterator() {
        return new Iterator<T>() {
            private Iterator<GenericDecorator<T>> iterator = decorators.iterator();

            @Override
            public boolean hasNext() {
                return iterator.hasNext();
            }

            @Override
            public T next() {
                return iterator.next().getItem();
            }
        };
    }
}

这些设计模式可以通过使用泛型类来实现，从而提高代码的可重用性和类型安全。