Java泛型与委托

Java泛型

1. 泛型的基本概念

泛型是Java 5引入的特性，允许在编译时提供类型安全检查，避免类型转换异常。

泛型应用：

public class Result<T> {  // T是类型参数
    private T data;       // T可以是任何类型
    
    public static <T> Result<T> success(T data) {  // 泛型方法
        // ...
    }
}

2. 泛型的核心语法

类型参数命名约定

// 常用的类型参数名
T - Type（类型）
E - Element（元素，集合中使用）
K - Key（键）
V - Value（值）
N - Number（数值类型）
? - 通配符

泛型类

// 单个类型参数
public class Box<T> {
    private T content;
    
    public void set(T content) {
        this.content = content;
    }
    
    public T get() {
        return content;
    }
}

// 多个类型参数
public class Pair<K, V> {
    private K key;
    private V value;
    
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
}

// 使用示例
Box<String> stringBox = new Box<>();
Pair<String, Integer> nameAge = new Pair<>("张三", 25);

泛型方法

public class Utility {
    // 泛型方法的语法：<T> 返回类型 方法名(参数)
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    
    // 有界类型参数
    public static <T extends Number> double sum(T[] numbers) {
        double sum = 0.0;
        for (T num : numbers) {
            sum += num.doubleValue();
        }
        return sum;
    }
}

3. 通配符和有界类型

通配符 ?

// 无限定通配符
List<?> list = new ArrayList<String>();

// 上界通配符 extends
List<? extends Number> numbers = new ArrayList<Integer>();

// 下界通配符 super
List<? super Integer> integers = new ArrayList<Number>();

Result类

public class Result<T> {
    private Integer code;
    private String message;
    private T data;
    
    // 使用有界通配符，更灵活的错误方法
    public static <T> Result<T> error(String message, T data) {
        Result<T> result = new Result<>();
        result.setCode(500);
        result.setMessage(message);
        result.setData(data);
        return result;
    }
    
    // 创建不同错误码的方法
    public static <T> Result<T> error(Integer code, String message) {
        Result<T> result = new Result<>();
        result.setCode(code);
        result.setMessage(message);
        result.setData(null);
        return result;
    }
}

4. 泛型的优势

// 不使用泛型（Java 5之前）
List list = new ArrayList();
list.add("Hello");
String str = (String) list.get(0); // 需要强制转换，可能出现ClassCastException

// 使用泛型
List<String> stringList = new ArrayList<>();
stringList.add("Hello");
String str = stringList.get(0); // 类型安全，无需转换

Java委托模式

Java没有像C#那样的内置委托关键字，但可以通过以下方式实现委托模式：

1. 接口委托（最常用）

// 定义处理器接口
public interface DataProcessor {
    void process(String data);
}

// 委托类
public class DataHandler {
    private DataProcessor processor;
    
    public DataHandler(DataProcessor processor) {
        this.processor = processor;
    }
    
    public void handleData(String data) {
        // 委托给处理器执行
        processor.process(data);
    }
}

// 使用示例
public class Example {
    public static void main(String[] args) {
        // 使用Lambda表达式
        DataHandler handler = new DataHandler(data -> 
            System.out.println("处理数据: " + data)
        );
        
        handler.handleData("Hello World");
        
        // 使用匿名内部类
        DataHandler handler2 = new DataHandler(new DataProcessor() {
            @Override
            public void process(String data) {
                System.out.println("另一种处理: " + data);
            }
        });
    }
}

2. 函数式接口委托（Java 8+）

import java.util.function.*;

public class Calculator {
    // 使用函数式接口作为委托
    public static double calculate(double a, double b, BinaryOperator<Double> operation) {
        return operation.apply(a, b);
    }
    
    public static void main(String[] args) {
        // 委托给不同的计算逻辑
        double sum = calculate(10, 5, (x, y) -> x + y);
        double product = calculate(10, 5, (x, y) -> x * y);
        
        System.out.println("Sum: " + sum);      // 15.0
        System.out.println("Product: " + product); // 50.0
    }
}

3. 方法引用委托

public class StringProcessor {
    public static String toUpperCase(String str) {
        return str.toUpperCase();
    }
    
    public static String toLowerCase(String str) {
        return str.toLowerCase();
    }
}

public class TextHandler {
    private Function<String, String> processor;
    
    public TextHandler(Function<String, String> processor) {
        this.processor = processor;
    }
    
    public String handle(String text) {
        return processor.apply(text);
    }
    
    public static void main(String[] args) {
        // 使用方法引用作为委托
        TextHandler upperHandler = new TextHandler(StringProcessor::toUpperCase);
        TextHandler lowerHandler = new TextHandler(StringProcessor::toLowerCase);
        
        System.out.println(upperHandler.handle("hello")); // HELLO
        System.out.println(lowerHandler.handle("WORLD")); // world
    }
}

委托应用

// 定义结果处理器
@FunctionalInterface
public interface ResultProcessor<T> {
    void process(Result<T> result);
}

// 扩展Result类支持委托处理
public class EnhancedResult<T> extends Result<T> {
    
    public static <T> Result<T> success(T data, ResultProcessor<T> processor) {
        Result<T> result = success(data);
        if (processor != null) {
            processor.process(result);
        }
        return result;
    }
    
    public static <T> Result<T> error(String message, ResultProcessor<T> processor) {
        Result<T> result = error(message);
        if (processor != null) {
            processor.process(result);
        }
        return result;
    }
}

// 使用示例
public class ApiController {
    public Result<String> getData() {
        return EnhancedResult.success("数据获取成功", result -> {
            // 委托处理：记录日志
            System.out.println("成功响应: " + result.getMessage());
        });
    }
    
    public Result<String> getErrorData() {
        return EnhancedResult.error("数据获取失败", result -> {
            // 委托处理：错误报告
            System.err.println("错误响应: " + result.getMessage());
        });
    }
}

总结

1. 泛型提供了编译时类型安全，避免了类型转换异常，让代码更加健壮和可读。
2. 委托模式在Java中通过接口、函数式接口和方法引用实现，提供了行为的动态分配能力。