Java 特殊特性详解

概述

本文档详细介绍 Java 语言中的高级特性和核心概念，包括反射、枚举、类与对象、接口、注解、泛型、内部类等内容。这些特性是 Java 面向对象编程的核心，也是理解 Java 框架和高级编程技巧的基础。

1. 类与对象

1.1 类的定义与结构

java

// 基本类定义
public class Person {
    // 成员变量（字段）
    private String name;
    private int age;
    private static int count = 0; // 静态变量
    
    // 静态代码块
    static {
        System.out.println("Person 类被加载");
    }
    
    // 实例代码块
    {
        count++;
        System.out.println("创建 Person 实例");
    }
    
    // 构造方法
    public Person() {
        this("Unknown", 0);
    }
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 实例方法
    public void introduce() {
        System.out.println("我是 " + name + "，今年 " + age + " 岁");
    }
    
    // 静态方法
    public static int getCount() {
        return count;
    }
    
    // Getter 和 Setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}

1.2 继承与多态

java

// 父类
public abstract class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    // 抽象方法
    public abstract void makeSound();
    
    // 具体方法
    public void sleep() {
        System.out.println(name + " 正在睡觉");
    }
    
    // final 方法，不能被重写
    public final void breathe() {
        System.out.println(name + " 正在呼吸");
    }
}

// 子类
public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, String breed) {
        super(name); // 调用父类构造方法
        this.breed = breed;
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " 汪汪叫");
    }
    
    // 方法重载
    public void play() {
        System.out.println(name + " 在玩耍");
    }
    
    public void play(String toy) {
        System.out.println(name + " 在玩 " + toy);
    }
}

// 使用示例
public class InheritanceDemo {
    public static void main(String[] args) {
        Animal dog = new Dog("旺财", "金毛");
        dog.makeSound(); // 多态调用
        dog.sleep();
        dog.breathe();
        
        // 类型转换
        if (dog instanceof Dog) {
            Dog realDog = (Dog) dog;
            realDog.play();
            realDog.play("球");
        }
    }
}

1.3 访问修饰符

java

public class AccessModifierDemo {
    public String publicField = "公共字段";        // 任何地方都可访问
    protected String protectedField = "受保护字段"; // 同包或子类可访问
    String packageField = "包字段";               // 同包可访问
    private String privateField = "私有字段";      // 仅本类可访问
    
    public void demonstrateAccess() {
        System.out.println(publicField);
        System.out.println(protectedField);
        System.out.println(packageField);
        System.out.println(privateField); // 只有在本类中才能访问
    }
}

2. 接口

2.1 接口定义与实现

java

// 基本接口
public interface Drawable {
    // 常量（默认 public static final）
    String DEFAULT_COLOR = "黑色";
    
    // 抽象方法（默认 public abstract）
    void draw();
    void setColor(String color);
}

// 扩展接口
public interface Colorable extends Drawable {
    void changeColor(String newColor);
}

// 接口实现
public class Circle implements Colorable {
    private String color = DEFAULT_COLOR;
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public void draw() {
        System.out.println("绘制一个半径为 " + radius + " 的 " + color + " 圆形");
    }
    
    @Override
    public void setColor(String color) {
        this.color = color;
    }
    
    @Override
    public void changeColor(String newColor) {
        System.out.println("将颜色从 " + color + " 改为 " + newColor);
        this.color = newColor;
    }
}

2.2 默认方法和静态方法（Java 8+）

java

public interface ModernInterface {
    // 抽象方法
    void abstractMethod();
    
    // 默认方法
    default void defaultMethod() {
        System.out.println("这是默认方法");
        privateHelper();
    }
    
    // 静态方法
    static void staticMethod() {
        System.out.println("这是静态方法");
    }
    
    // 私有方法（Java 9+）
    private void privateHelper() {
        System.out.println("私有辅助方法");
    }
}

public class ModernClass implements ModernInterface {
    @Override
    public void abstractMethod() {
        System.out.println("实现抽象方法");
    }
    
    // 可以选择重写默认方法
    @Override
    public void defaultMethod() {
        System.out.println("重写的默认方法");
        ModernInterface.super.defaultMethod(); // 调用接口的默认方法
    }
}

2.3 函数式接口

java

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
    
    // 可以有默认方法
    default void printResult(int a, int b) {
        System.out.println("结果: " + calculate(a, b));
    }
}

// 使用示例
public class FunctionalInterfaceDemo {
    public static void main(String[] args) {
        // Lambda 表达式实现
        Calculator add = (a, b) -> a + b;
        Calculator multiply = (a, b) -> a * b;
        
        System.out.println("加法: " + add.calculate(5, 3));
        System.out.println("乘法: " + multiply.calculate(5, 3));
        
        add.printResult(5, 3);
    }
}

3. 枚举

3.1 基本枚举

java

// 简单枚举
public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

// 使用枚举
public class EnumBasicDemo {
    public static void main(String[] args) {
        Day today = Day.MONDAY;
        
        // 枚举比较
        if (today == Day.MONDAY) {
            System.out.println("今天是周一");
        }
        
        // switch 语句
        switch (today) {
            case MONDAY:
                System.out.println("周一，新的开始");
                break;
            case FRIDAY:
                System.out.println("周五，快到周末了");
                break;
            default:
                System.out.println("普通的一天");
        }
        
        // 枚举方法
        System.out.println("枚举名称: " + today.name());
        System.out.println("枚举序号: " + today.ordinal());
        
        // 遍历所有枚举值
        for (Day day : Day.values()) {
            System.out.println(day);
        }
    }
}

3.2 复杂枚举

java

public enum Planet {
    MERCURY(3.303e+23, 2.4397e6),
    VENUS(4.869e+24, 6.0518e6),
    EARTH(5.976e+24, 6.37814e6),
    MARS(6.421e+23, 3.3972e6);
    
    private final double mass;   // 质量（千克）
    private final double radius; // 半径（米）
    
    // 枚举构造方法
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    
    // 枚举方法
    public double getMass() { return mass; }
    public double getRadius() { return radius; }
    
    // 计算表面重力
    public double surfaceGravity() {
        final double G = 6.67300E-11;
        return G * mass / (radius * radius);
    }
    
    // 计算在该星球上的重量
    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

// 使用复杂枚举
public class PlanetDemo {
    public static void main(String[] args) {
        double earthWeight = 75.0; // 地球上的重量
        
        for (Planet planet : Planet.values()) {
            double weight = planet.surfaceWeight(earthWeight);
            System.out.printf("在 %s 上的重量: %.2f kg%n", 
                            planet.name(), weight);
        }
    }
}

3.3 枚举实现接口

java

public interface Operation {
    double apply(double x, double y);
}

public enum BasicOperation implements Operation {
    PLUS("+") {
        @Override
        public double apply(double x, double y) { return x + y; }
    },
    MINUS("-") {
        @Override
        public double apply(double x, double y) { return x - y; }
    },
    TIMES("*") {
        @Override
        public double apply(double x, double y) { return x * y; }
    },
    DIVIDE("/") {
        @Override
        public double apply(double x, double y) { return x / y; }
    };
    
    private final String symbol;
    
    BasicOperation(String symbol) {
        this.symbol = symbol;
    }
    
    @Override
    public String toString() {
        return symbol;
    }
}

// 使用示例
public class OperationDemo {
    public static void main(String[] args) {
        double x = 10.0, y = 3.0;
        
        for (BasicOperation op : BasicOperation.values()) {
            System.out.printf("%.1f %s %.1f = %.2f%n", 
                            x, op, y, op.apply(x, y));
        }
    }
}

4. 反射

4.1 Class 对象

java

import java.lang.reflect.*;

public class ReflectionBasics {
    public static void main(String[] args) throws Exception {
        // 获取 Class 对象的三种方式
        Class<?> clazz1 = String.class;
        Class<?> clazz2 = "Hello".getClass();
        Class<?> clazz3 = Class.forName("java.lang.String");
        
        System.out.println("类名: " + clazz1.getName());
        System.out.println("简单类名: " + clazz1.getSimpleName());
        System.out.println("包名: " + clazz1.getPackage().getName());
        System.out.println("是否为接口: " + clazz1.isInterface());
        System.out.println("是否为数组: " + clazz1.isArray());
        System.out.println("父类: " + clazz1.getSuperclass());
        
        // 获取实现的接口
        Class<?>[] interfaces = clazz1.getInterfaces();
        System.out.println("实现的接口:");
        for (Class<?> intf : interfaces) {
            System.out.println("  " + intf.getName());
        }
    }
}

4.2 反射操作字段

java

import java.lang.reflect.Field;

public class Student {
    private String name;
    public int age;
    protected String grade;
    static String school = "清华大学";
    
    public Student(String name, int age, String grade) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }
    
    @Override
    public String toString() {
        return String.format("Student{name='%s', age=%d, grade='%s'}", 
                           name, age, grade);
    }
}

public class FieldReflectionDemo {
    public static void main(String[] args) throws Exception {
        Student student = new Student("张三", 20, "大二");
        Class<?> clazz = student.getClass();
        
        System.out.println("=== 获取所有字段 ===");
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            System.out.printf("字段: %s, 类型: %s, 修饰符: %s%n",
                            field.getName(), 
                            field.getType().getSimpleName(),
                            Modifier.toString(field.getModifiers()));
        }
        
        System.out.println("\n=== 操作私有字段 ===");
        Field nameField = clazz.getDeclaredField("name");
        nameField.setAccessible(true); // 设置可访问私有字段
        
        String originalName = (String) nameField.get(student);
        System.out.println("原始姓名: " + originalName);
        
        nameField.set(student, "李四");
        System.out.println("修改后: " + student);
        
        System.out.println("\n=== 操作静态字段 ===");
        Field schoolField = clazz.getDeclaredField("school");
        System.out.println("学校: " + schoolField.get(null)); // 静态字段传入 null
    }
}

4.3 反射操作方法

java

import java.lang.reflect.Method;

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    private String formatResult(String operation, int result) {
        return String.format("%s 的结果是: %d", operation, result);
    }
    
    public static void printInfo() {
        System.out.println("这是一个计算器类");
    }
    
    // 重载方法
    public double add(double a, double b) {
        return a + b;
    }
}

public class MethodReflectionDemo {
    public static void main(String[] args) throws Exception {
        Calculator calc = new Calculator();
        Class<?> clazz = calc.getClass();
        
        System.out.println("=== 获取所有方法 ===");
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.printf("方法: %s, 返回类型: %s, 参数: %s%n",
                            method.getName(),
                            method.getReturnType().getSimpleName(),
                            java.util.Arrays.toString(method.getParameterTypes()));
        }
        
        System.out.println("\n=== 调用公共方法 ===");
        Method addMethod = clazz.getMethod("add", int.class, int.class);
        int result = (int) addMethod.invoke(calc, 5, 3);
        System.out.println("5 + 3 = " + result);
        
        System.out.println("\n=== 调用私有方法 ===");
        Method formatMethod = clazz.getDeclaredMethod("formatResult", String.class, int.class);
        formatMethod.setAccessible(true);
        String formatted = (String) formatMethod.invoke(calc, "加法", result);
        System.out.println(formatted);
        
        System.out.println("\n=== 调用静态方法 ===");
        Method staticMethod = clazz.getMethod("printInfo");
        staticMethod.invoke(null); // 静态方法传入 null
    }
}

4.4 反射操作构造方法

java

import java.lang.reflect.Constructor;

public class Person {
    private String name;
    private int age;
    
    public Person() {
        this("Unknown", 0);
    }
    
    public Person(String name) {
        this(name, 0);
    }
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    private Person(int age) {
        this("Private", age);
    }
    
    @Override
    public String toString() {
        return String.format("Person{name='%s', age=%d}", name, age);
    }
}

public class ConstructorReflectionDemo {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Person.class;
        
        System.out.println("=== 获取所有构造方法 ===");
        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.printf("构造方法: %s, 参数: %s%n",
                            constructor.getName(),
                            java.util.Arrays.toString(constructor.getParameterTypes()));
        }
        
        System.out.println("\n=== 使用不同构造方法创建对象 ===");
        
        // 无参构造方法
        Constructor<?> defaultConstructor = clazz.getConstructor();
        Person person1 = (Person) defaultConstructor.newInstance();
        System.out.println("无参构造: " + person1);
        
        // 单参构造方法
        Constructor<?> nameConstructor = clazz.getConstructor(String.class);
        Person person2 = (Person) nameConstructor.newInstance("张三");
        System.out.println("单参构造: " + person2);
        
        // 双参构造方法
        Constructor<?> fullConstructor = clazz.getConstructor(String.class, int.class);
        Person person3 = (Person) fullConstructor.newInstance("李四", 25);
        System.out.println("双参构造: " + person3);
        
        // 私有构造方法
        Constructor<?> privateConstructor = clazz.getDeclaredConstructor(int.class);
        privateConstructor.setAccessible(true);
        Person person4 = (Person) privateConstructor.newInstance(30);
        System.out.println("私有构造: " + person4);
    }
}

4.5 反射工具类

java

import java.lang.reflect.*;
import java.util.*;

public class ReflectionUtils {
    
    /**
     * 获取对象的所有字段值
     */
    public static Map<String, Object> getFieldValues(Object obj) {
        Map<String, Object> fieldValues = new HashMap<>();
        Class<?> clazz = obj.getClass();
        
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                Object value = field.get(obj);
                fieldValues.put(field.getName(), value);
            } catch (IllegalAccessException e) {
                fieldValues.put(field.getName(), "无法访问");
            }
        }
        
        return fieldValues;
    }
    
    /**
     * 复制对象（浅拷贝）
     */
    public static <T> T copyObject(T source) throws Exception {
        Class<?> clazz = source.getClass();
        
        @SuppressWarnings("unchecked")
        T target = (T) clazz.getDeclaredConstructor().newInstance();
        
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            Object value = field.get(source);
            field.set(target, value);
        }
        
        return target;
    }
    
    /**
     * 调用对象的方法
     */
    public static Object invokeMethod(Object obj, String methodName, 
                                    Class<?>[] paramTypes, Object... args) 
                                    throws Exception {
        Class<?> clazz = obj.getClass();
        Method method = clazz.getDeclaredMethod(methodName, paramTypes);
        method.setAccessible(true);
        return method.invoke(obj, args);
    }
    
    /**
     * 打印类的详细信息
     */
    public static void printClassInfo(Class<?> clazz) {
        System.out.println("=== 类信息: " + clazz.getSimpleName() + " ===");
        
        // 字段信息
        System.out.println("\n字段:");
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            System.out.printf("  %s %s %s%n",
                            Modifier.toString(field.getModifiers()),
                            field.getType().getSimpleName(),
                            field.getName());
        }
        
        // 构造方法信息
        System.out.println("\n构造方法:");
        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.printf("  %s %s(%s)%n",
                            Modifier.toString(constructor.getModifiers()),
                            constructor.getName(),
                            Arrays.toString(constructor.getParameterTypes()));
        }
        
        // 方法信息
        System.out.println("\n方法:");
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.printf("  %s %s %s(%s)%n",
                            Modifier.toString(method.getModifiers()),
                            method.getReturnType().getSimpleName(),
                            method.getName(),
                            Arrays.toString(method.getParameterTypes()));
        }
    }
}

// 使用示例
public class ReflectionUtilsDemo {
    public static void main(String[] args) throws Exception {
        Student student = new Student("王五", 22, "大三");
        
        // 获取字段值
        Map<String, Object> fieldValues = ReflectionUtils.getFieldValues(student);
        System.out.println("字段值: " + fieldValues);
        
        // 复制对象
        Student copy = ReflectionUtils.copyObject(student);
        System.out.println("复制的对象: " + copy);
        
        // 打印类信息
        ReflectionUtils.printClassInfo(Student.class);
    }
}

5. 注解

5.1 内置注解

java

// 使用内置注解
public class BuiltInAnnotationsDemo {
    
    @Deprecated
    public void oldMethod() {
        System.out.println("这是一个过时的方法");
    }
    
    @Override
    public String toString() {
        return "BuiltInAnnotationsDemo";
    }
    
    @SuppressWarnings("unchecked")
    public void suppressWarningsMethod() {
        @SuppressWarnings("rawtypes")
        List list = new ArrayList();
        list.add("item");
    }
    
    @SafeVarargs
    public final void safeVarargsMethod(List<String>... lists) {
        for (List<String> list : lists) {
            System.out.println(list);
        }
    }
}

5.2 自定义注解

java

import java.lang.annotation.*;

// 方法级注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Timer {
    String value() default "";
    boolean enabled() default true;
}

// 类级注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Component {
    String name() default "";
    String version() default "1.0";
}

// 字段级注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Inject {
    String value() default "";
    boolean required() default true;
}

// 参数级注解
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface NotNull {
}

// 多目标注解
@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Validate {
    String pattern() default "";
    int min() default 0;
    int max() default Integer.MAX_VALUE;
}

5.3 注解处理器

java

import java.lang.reflect.Method;
import java.lang.reflect.Field;

@Component(name = "UserService", version = "2.0")
public class UserService {
    
    @Inject("userRepository")
    private String repository;
    
    @Validate(min = 1, max = 100)
    private int userId;
    
    @Timer("getUserById")
    public String getUserById(@NotNull String id) {
        return "User: " + id;
    }
    
    @Timer(value = "getAllUsers", enabled = false)
    public void getAllUsers() {
        System.out.println("获取所有用户");
    }
}

// 注解处理器
public class AnnotationProcessor {
    
    public static void processClass(Class<?> clazz) {
        System.out.println("=== 处理类: " + clazz.getSimpleName() + " ===");
        
        // 处理类级注解
        if (clazz.isAnnotationPresent(Component.class)) {
            Component component = clazz.getAnnotation(Component.class);
            System.out.printf("组件名称: %s, 版本: %s%n", 
                            component.name(), component.version());
        }
        
        // 处理字段注解
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Inject.class)) {
                Inject inject = field.getAnnotation(Inject.class);
                System.out.printf("注入字段: %s, 值: %s, 必需: %s%n",
                                field.getName(), inject.value(), inject.required());
            }
            
            if (field.isAnnotationPresent(Validate.class)) {
                Validate validate = field.getAnnotation(Validate.class);
                System.out.printf("验证字段: %s, 最小值: %d, 最大值: %d%n",
                                field.getName(), validate.min(), validate.max());
            }
        }
        
        // 处理方法注解
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(Timer.class)) {
                Timer timer = method.getAnnotation(Timer.class);
                System.out.printf("计时方法: %s, 名称: %s, 启用: %s%n",
                                method.getName(), timer.value(), timer.enabled());
            }
        }
    }
    
    public static void main(String[] args) {
        processClass(UserService.class);
    }
}

5.4 注解驱动的简单框架

java

import java.lang.reflect.*;
import java.util.*;

// 简单的依赖注入容器
public class SimpleContainer {
    private Map<String, Object> beans = new HashMap<>();
    
    public void registerBean(String name, Object bean) {
        beans.put(name, bean);
    }
    
    public <T> T getBean(String name, Class<T> type) {
        return type.cast(beans.get(name));
    }
    
    public void injectDependencies(Object target) throws Exception {
        Class<?> clazz = target.getClass();
        Field[] fields = clazz.getDeclaredFields();
        
        for (Field field : fields) {
            if (field.isAnnotationPresent(Inject.class)) {
                Inject inject = field.getAnnotation(Inject.class);
                String beanName = inject.value().isEmpty() ? 
                                field.getName() : inject.value();
                
                Object dependency = beans.get(beanName);
                if (dependency != null) {
                    field.setAccessible(true);
                    field.set(target, dependency);
                    System.out.println("注入依赖: " + beanName + " -> " + field.getName());
                } else if (inject.required()) {
                    throw new RuntimeException("找不到必需的依赖: " + beanName);
                }
            }
        }
    }
    
    public Object executeWithTimer(Object target, String methodName, 
                                 Class<?>[] paramTypes, Object... args) 
                                 throws Exception {
        Method method = target.getClass().getDeclaredMethod(methodName, paramTypes);
        
        if (method.isAnnotationPresent(Timer.class)) {
            Timer timer = method.getAnnotation(Timer.class);
            if (timer.enabled()) {
                long startTime = System.nanoTime();
                Object result = method.invoke(target, args);
                long endTime = System.nanoTime();
                
                String timerName = timer.value().isEmpty() ? 
                                 methodName : timer.value();
                System.out.printf("方法 %s 执行时间: %.2f ms%n", 
                                timerName, (endTime - startTime) / 1_000_000.0);
                return result;
            }
        }
        
        return method.invoke(target, args);
    }
}

// 使用示例
public class FrameworkDemo {
    public static void main(String[] args) throws Exception {
        SimpleContainer container = new SimpleContainer();
        
        // 注册依赖
        container.registerBean("userRepository", "UserRepositoryImpl");
        
        // 创建服务并注入依赖
        UserService userService = new UserService();
        container.injectDependencies(userService);
        
        // 执行带计时的方法
        container.executeWithTimer(userService, "getUserById", 
                                 new Class[]{String.class}, "123");
        container.executeWithTimer(userService, "getAllUsers", new Class[]{});
    }
}

6. 泛型

6.1 泛型基础

java

// 泛型类
public class Box<T> {
    private T content;
    
    public Box(T content) {
        this.content = content;
    }
    
    public T getContent() {
        return content;
    }
    
    public void setContent(T content) {
        this.content = content;
    }
    
    @Override
    public String toString() {
        return "Box{content=" + content + "}";
    }
}

// 泛型接口
public interface Comparable<T> {
    int compareTo(T other);
}

// 实现泛型接口
public class Student implements Comparable<Student> {
    private String name;
    private int score;
    
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
    
    @Override
    public int compareTo(Student other) {
        return Integer.compare(this.score, other.score);
    }
    
    // getters and toString...
    public String getName() { return name; }
    public int getScore() { return score; }
    
    @Override
    public String toString() {
        return String.format("Student{name='%s', score=%d}", name, score);
    }
}

// 使用泛型
public class GenericBasicsDemo {
    public static void main(String[] args) {
        // 泛型类使用
        Box<String> stringBox = new Box<>("Hello");
        Box<Integer> intBox = new Box<>(42);
        
        System.out.println(stringBox);
        System.out.println(intBox);
        
        // 泛型接口使用
        Student student1 = new Student("张三", 85);
        Student student2 = new Student("李四", 92);
        
        int result = student1.compareTo(student2);
        System.out.println("比较结果: " + result);
    }
}

6.2 泛型方法

java

import java.util.*;

public class GenericMethods {
    
    // 泛型方法
    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, U> void printPair(T first, U second) {
        System.out.println("第一个: " + first + ", 第二个: " + second);
    }
    
    // 有界类型参数
    public static <T extends Number> double sum(List<T> numbers) {
        double total = 0.0;
        for (T number : numbers) {
            total += number.doubleValue();
        }
        return total;
    }
    
    // 递归类型边界
    public static <T extends Comparable<T>> T max(List<T> list) {
        if (list.isEmpty()) {
            return null;
        }
        
        T max = list.get(0);
        for (T item : list) {
            if (item.compareTo(max) > 0) {
                max = item;
            }
        }
        return max;
    }
    
    public static void main(String[] args) {
        // 使用泛型方法
        String[] strings = {"a", "b", "c"};
        System.out.println("交换前: " + Arrays.toString(strings));
        swap(strings, 0, 2);
        System.out.println("交换后: " + Arrays.toString(strings));
        
        // 多个类型参数
        printPair("Hello", 42);
        printPair(3.14, true);
        
        // 有界类型参数
        List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
        List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
        
        System.out.println("整数和: " + sum(integers));
        System.out.println("小数和: " + sum(doubles));
        
        // 递归类型边界
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        System.out.println("最大字符串: " + max(words));
    }
}

6.3 通配符

java

import java.util.*;

public class WildcardsDemo {
    
    // 上界通配符 (? extends T)
    public static double sumOfNumbers(List<? extends Number> numbers) {
        double sum = 0.0;
        for (Number number : numbers) {
            sum += number.doubleValue();
        }
        return sum;
    }
    
    // 下界通配符 (? super T)
    public static void addNumbers(List<? super Integer> numbers) {
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
    }
    
    // 无界通配符 (?)
    public static void printList(List<?> list) {
        for (Object item : list) {
            System.out.println(item);
        }
    }
    
    // PECS 原则示例 (Producer Extends, Consumer Super)
    public static <T> void copy(List<? extends T> source, List<? super T> destination) {
        for (T item : source) {
            destination.add(item);
        }
    }
    
    public static void main(String[] args) {
        // 上界通配符
        List<Integer> integers = Arrays.asList(1, 2, 3);
        List<Double> doubles = Arrays.asList(1.1, 2.2, 3.3);
        
        System.out.println("整数和: " + sumOfNumbers(integers));
        System.out.println("小数和: " + sumOfNumbers(doubles));
        
        // 下界通配符
        List<Number> numbers = new ArrayList<>();
        List<Object> objects = new ArrayList<>();
        
        addNumbers(numbers);
        addNumbers(objects);
        
        System.out.println("Numbers: " + numbers);
        System.out.println("Objects: " + objects);
        
        // 无界通配符
        printList(integers);
        printList(Arrays.asList("a", "b", "c"));
        
        // PECS 示例
        List<String> source = Arrays.asList("hello", "world");
        List<Object> destination = new ArrayList<>();
        copy(source, destination);
        System.out.println("复制结果: " + destination);
    }
}

6.4 类型擦除和限制

java

import java.lang.reflect.*;
import java.util.*;

public class TypeErasureDemo {
    
    public static void demonstrateTypeErasure() {
        List<String> stringList = new ArrayList<>();
        List<Integer> intList = new ArrayList<>();
        
        // 运行时类型相同
        System.out.println("String List 类型: " + stringList.getClass());
        System.out.println("Integer List 类型: " + intList.getClass());
        System.out.println("类型相同: " + (stringList.getClass() == intList.getClass()));
    }
    
    // 泛型数组的限制
    public static void genericArrayLimitations() {
        // 编译错误: 不能创建泛型数组
        // List<String>[] stringLists = new List<String>[10];
        
        // 可以这样做
        @SuppressWarnings("unchecked")
        List<String>[] stringLists = new List[10];
        stringLists[0] = new ArrayList<>();
        
        // 或者使用 ArrayList
        List<List<String>> listOfLists = new ArrayList<>();
    }
    
    // 获取泛型信息的方法
    public static void getGenericInfo() throws Exception {
        // 通过反射获取泛型信息
        Method method = TypeErasureDemo.class.getMethod("methodWithGenericParam", List.class);
        Type[] paramTypes = method.getGenericParameterTypes();
        
        for (Type paramType : paramTypes) {
            if (paramType instanceof ParameterizedType) {
                ParameterizedType pType = (ParameterizedType) paramType;
                System.out.println("参数化类型: " + pType);
                System.out.println("原始类型: " + pType.getRawType());
                System.out.println("类型参数: " + Arrays.toString(pType.getActualTypeArguments()));
            }
        }
    }
    
    public void methodWithGenericParam(List<String> list) {
        // 方法体
    }
    
    public static void main(String[] args) throws Exception {
        demonstrateTypeErasure();
        genericArrayLimitations();
        getGenericInfo();
    }
}

7. 内部类

7.1 成员内部类

java

public class OuterClass {
    private String outerField = "外部类字段";
    private static String staticField = "静态字段";
    
    // 成员内部类
    public class InnerClass {
        private String innerField = "内部类字段";
        
        public void innerMethod() {
            // 可以访问外部类的所有成员
            System.out.println("访问外部类字段: " + outerField);
            System.out.println("访问静态字段: " + staticField);
            System.out.println("内部类字段: " + innerField);
            
            // 调用外部类方法
            outerMethod();
        }
        
        public void accessOuterThis() {
            // 访问外部类的 this 引用
            System.out.println("外部类实例: " + OuterClass.this);
        }
    }
    
    public void outerMethod() {
        System.out.println("外部类方法");
        
        // 在外部类中创建内部类实例
        InnerClass inner = new InnerClass();
        inner.innerMethod();
    }
    
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        
        // 创建内部类实例的方式
        OuterClass.InnerClass inner1 = outer.new InnerClass();
        inner1.innerMethod();
        
        // 另一种方式
        OuterClass.InnerClass inner2 = new OuterClass().new InnerClass();
        inner2.accessOuterThis();
    }
}

7.2 静态内部类

java

public class StaticInnerDemo {
    private String instanceField = "实例字段";
    private static String staticField = "静态字段";
    
    // 静态内部类
    public static class StaticInner {
        private String innerField = "静态内部类字段";
        
        public void innerMethod() {
            // 只能访问外部类的静态成员
            System.out.println("访问静态字段: " + staticField);
            System.out.println("内部类字段: " + innerField);
            
            // 编译错误：不能访问实例字段
            // System.out.println(instanceField);
        }
        
        public static void staticInnerMethod() {
            System.out.println("静态内部类的静态方法");
        }
    }
    
    public static void main(String[] args) {
        // 创建静态内部类实例（不需要外部类实例）
        StaticInner staticInner = new StaticInner();
        staticInner.innerMethod();
        
        // 调用静态内部类的静态方法
        StaticInner.staticInnerMethod();
    }
}

7.3 局部内部类

java

public class LocalInnerDemo {
    private String outerField = "外部类字段";
    
    public void methodWithLocalInner() {
        final String localVar = "局部变量";
        String effectivelyFinalVar = "实际final变量";
        
        // 局部内部类
        class LocalInner {
            private String innerField = "局部内部类字段";
            
            public void innerMethod() {
                System.out.println("外部类字段: " + outerField);
                System.out.println("局部变量: " + localVar);
                System.out.println("实际final变量: " + effectivelyFinalVar);
                System.out.println("内部类字段: " + innerField);
            }
        }
        
        // 在方法内使用局部内部类
        LocalInner localInner = new LocalInner();
        localInner.innerMethod();
        
        // effectivelyFinalVar = "修改后"; // 编译错误：会破坏 effectively final
    }
    
    public static void main(String[] args) {
        LocalInnerDemo demo = new LocalInnerDemo();
        demo.methodWithLocalInner();
    }
}

7.4 匿名内部类

java

import java.util.*;

public class AnonymousInnerDemo {
    
    // 接口
    interface Greeting {
        void sayHello(String name);
    }
    
    // 抽象类
    abstract class Animal {
        protected String name;
        
        public Animal(String name) {
            this.name = name;
        }
        
        public abstract void makeSound();
        
        public void sleep() {
            System.out.println(name + " 正在睡觉");
        }
    }
    
    public void demonstrateAnonymousClasses() {
        // 实现接口的匿名类
        Greeting greeting = new Greeting() {
            @Override
            public void sayHello(String name) {
                System.out.println("你好, " + name + "!");
            }
        };
        greeting.sayHello("张三");
        
        // 继承抽象类的匿名类
        Animal dog = new Animal("旺财") {
            @Override
            public void makeSound() {
                System.out.println(name + " 汪汪叫");
            }
        };
        dog.makeSound();
        dog.sleep();
        
        // 继承具体类的匿名类
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("匿名线程正在运行");
            }
        };
        thread.start();
        
        // 在集合操作中使用匿名类
        List<String> names = Arrays.asList("张三", "李四", "王五");
        
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s2.compareTo(s1); // 降序排列
            }
        });
        
        System.out.println("排序后: " + names);
    }
    
    public static void main(String[] args) {
        AnonymousInnerDemo demo = new AnonymousInnerDemo();
        demo.demonstrateAnonymousClasses();
    }
}

7.5 内部类的实际应用

java

import java.util.*;

// 迭代器模式的实现
public class MyList<T> {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_CAPACITY = 10;
    
    public MyList() {
        elements = new Object[DEFAULT_CAPACITY];
    }
    
    public void add(T element) {
        if (size >= elements.length) {
            resize();
        }
        elements[size++] = element;
    }
    
    @SuppressWarnings("unchecked")
    public T get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        return (T) elements[index];
    }
    
    public int size() {
        return size;
    }
    
    private void resize() {
        elements = Arrays.copyOf(elements, elements.length * 2);
    }
    
    // 成员内部类实现迭代器
    public class ListIterator implements Iterator<T> {
        private int currentIndex = 0;
        
        @Override
        public boolean hasNext() {
            return currentIndex < size;
        }
        
        @Override
        @SuppressWarnings("unchecked")
        public T next() {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            return (T) elements[currentIndex++];
        }
    }
    
    public Iterator<T> iterator() {
        return new ListIterator();
    }
    
    // 静态内部类实现构建器模式
    public static class Builder<T> {
        private MyList<T> list = new MyList<>();
        
        public Builder<T> add(T element) {
            list.add(element);
            return this;
        }
        
        public MyList<T> build() {
            return list;
        }
    }
    
    public static <T> Builder<T> builder() {
        return new Builder<>();
    }
    
    public static void main(String[] args) {
        // 使用构建器创建列表
        MyList<String> list = MyList.<String>builder()
            .add("Apple")
            .add("Banana")
            .add("Cherry")
            .build();
        
        // 使用迭代器遍历
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        
        // 增强for循环（需要实现Iterable接口）
        System.out.println("\n直接访问:");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

8. Lambda 表达式

8.1 Lambda 基础语法

java

import java.util.*;
import java.util.function.*;

public class LambdaBasics {
    
    public static void main(String[] args) {
        // 基本语法形式
        
        // 1. 无参数
        Runnable r1 = () -> System.out.println("Hello Lambda");
        r1.run();
        
        // 2. 单个参数（可省略括号）
        Consumer<String> c1 = s -> System.out.println("消费: " + s);
        Consumer<String> c2 = (s) -> System.out.println("消费: " + s);
        c1.accept("测试");
        
        // 3. 多个参数
        BinaryOperator<Integer> add = (a, b) -> a + b;
        System.out.println("加法: " + add.apply(5, 3));
        
        // 4. 多行代码块
        BinaryOperator<Integer> complex = (a, b) -> {
            System.out.println("计算 " + a + " 和 " + b + " 的和");
            int result = a + b;
            return result;
        };
        System.out.println("复杂计算: " + complex.apply(10, 20));
        
        // 5. 类型推断
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        list.forEach(item -> System.out.println(item)); // 推断 item 为 String
        
        // 6. 方法引用
        list.forEach(System.out::println); // 等价于上面的 lambda
    }
}

8.2 常用函数式接口

java

import java.util.*;
import java.util.function.*;

public class FunctionalInterfacesDemo {
    
    public static void main(String[] args) {
        // Predicate<T> - 断言型接口
        Predicate<Integer> isEven = n -> n % 2 == 0;
        Predicate<Integer> isPositive = n -> n > 0;
        
        System.out.println("4 是偶数且为正数: " + isEvenAndPositive.test(4));
        System.out.println("-2 是偶数且为正数: " + isEvenAndPositive.test(-2));
        
        // Function<T, R> - 函数型接口
        Function<String, Integer> stringLength = s -> s.length();
        Function<Integer, String> intToString = i -> "数字: " + i;
        
        System.out.println("字符串长度: " + stringLength.apply("Hello"));
        
        // 函数组合
        Function<String, String> lengthToString = stringLength.andThen(intToString);
        System.out.println(lengthToString.apply("Lambda"));
        
        // Consumer<T> - 消费型接口
        Consumer<String> printer = s -> System.out.println("打印: " + s);
        Consumer<String> logger = s -> System.out.println("日志: " + s);
        
        // 组合消费者
        Consumer<String> combined = printer.andThen(logger);
        combined.accept("测试消息");
        
        // Supplier<T> - 供给型接口
        Supplier<String> randomString = () -> "随机数: " + Math.random();
        Supplier<Date> currentTime = Date::new;
        
        System.out.println(randomString.get());
        System.out.println("当前时间: " + currentTime.get());
        
        // UnaryOperator<T> - 一元操作符
        UnaryOperator<String> toUpperCase = String::toUpperCase;
        UnaryOperator<Integer> square = x -> x * x;
        
        System.out.println("转大写: " + toUpperCase.apply("hello"));
        System.out.println("平方: " + square.apply(5));
        
        // BinaryOperator<T> - 二元操作符
        BinaryOperator<String> concat = (s1, s2) -> s1 + s2;
        BinaryOperator<Integer> max = Integer::max;
        
        System.out.println("连接: " + concat.apply("Hello", "World"));
        System.out.println("最大值: " + max.apply(10, 20));
    }
}

8.3 方法引用

java

import java.util.*;
import java.util.function.*;

public class MethodReferenceDemo {
    
    public static void staticMethod(String s) {
        System.out.println("静态方法: " + s);
    }
    
    public void instanceMethod(String s) {
        System.out.println("实例方法: " + s);
    }
    
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");
        
        // 1. 静态方法引用
        Consumer<String> staticRef = MethodReferenceDemo::staticMethod;
        list.forEach(staticRef);
        
        // 2. 实例方法引用
        MethodReferenceDemo demo = new MethodReferenceDemo();
        Consumer<String> instanceRef = demo::instanceMethod;
        list.forEach(instanceRef);
        
        // 3. 特定类型的任意对象的实例方法引用
        Function<String, Integer> lengthRef = String::length;
        list.stream().map(lengthRef).forEach(System.out::println);
        
        // 4. 构造方法引用
        Supplier<List<String>> listSupplier = ArrayList::new;
        Function<Integer, List<String>> listWithCapacity = ArrayList::new;
        
        List<String> newList1 = listSupplier.get();
        List<String> newList2 = listWithCapacity.apply(10);
        
        System.out.println("新列表1: " + newList1);
        System.out.println("新列表2容量: " + newList2.size());
        
        // 5. 数组构造方法引用
        Function<Integer, String[]> arrayCreator = String[]::new;
        String[] array = arrayCreator.apply(5);
        System.out.println("数组长度: " + array.length);
    }
}

8.4 Lambda 表达式的实际应用

java

import java.util.*;
import java.util.stream.*;

public class LambdaApplications {
    
    static class Person {
        private String name;
        private int age;
        private String city;
        
        public Person(String name, int age, String city) {
            this.name = name;
            this.age = age;
            this.city = city;
        }
        
        // getters
        public String getName() { return name; }
        public int getAge() { return age; }
        public String getCity() { return city; }
        
        @Override
        public String toString() {
            return String.format("Person{name='%s', age=%d, city='%s'}", name, age, city);
        }
    }
    
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("张三", 25, "北京"),
            new Person("李四", 30, "上海"),
            new Person("王五", 22, "北京"),
            new Person("赵六", 35, "深圳"),
            new Person("钱七", 28, "上海")
        );
        
        // 1. 排序
        System.out.println("=== 按年龄排序 ===");
        people.stream()
              .sorted((p1, p2) -> Integer.compare(p1.getAge(), p2.getAge()))
              .forEach(System.out::println);
        
        // 使用 Comparator.comparing
        System.out.println("\n=== 按姓名排序 ===");
        people.stream()
              .sorted(Comparator.comparing(Person::getName))
              .forEach(System.out::println);
        
        // 2. 过滤
        System.out.println("\n=== 年龄大于25的人 ===");
        people.stream()
              .filter(p -> p.getAge() > 25)
              .forEach(System.out::println);
        
        // 3. 映射
        System.out.println("\n=== 所有人的姓名 ===");
        people.stream()
              .map(Person::getName)
              .forEach(System.out::println);
        
        // 4. 分组
        System.out.println("\n=== 按城市分组 ===");
        Map<String, List<Person>> groupedByCity = people.stream()
            .collect(Collectors.groupingBy(Person::getCity));
        groupedByCity.forEach((city, persons) -> {
            System.out.println(city + ": " + persons.size() + " 人");
        });
        
        // 5. 聚合操作
        OptionalDouble averageAge = people.stream()
            .mapToInt(Person::getAge)
            .average();
        System.out.println("\n平均年龄: " + averageAge.orElse(0));
        
        // 6. 自定义收集器
        String names = people.stream()
            .map(Person::getName)
            .collect(Collectors.joining(", ", "[", "]"));
        System.out.println("所有姓名: " + names);
    }
}

9. 函数式接口

9.1 自定义函数式接口

java

@FunctionalInterface
public interface MathOperation {
    double operate(double a, double b);
    
    // 默认方法
    default double operateAndPrint(double a, double b) {
        double result = operate(a, b);
        System.out.println("结果: " + result);
        return result;
    }
    
    // 静态方法
    static MathOperation add() {
        return (a, b) -> a + b;
    }
    
    static MathOperation multiply() {
        return (a, b) -> a * b;
    }
}

@FunctionalInterface
public interface TriFunction<T, U, V, R> {
    R apply(T t, U u, V v);
}

public class CustomFunctionalInterfaceDemo {
    
    public static void main(String[] args) {
        // 使用 Lambda 实现
        MathOperation subtract = (a, b) -> a - b;
        MathOperation divide = (a, b) -> b != 0 ? a / b : 0;
        
        System.out.println("减法: " + subtract.operate(10, 3));
        System.out.println("除法: " + divide.operate(10, 3));
        
        // 使用默认方法
        subtract.operateAndPrint(15, 5);
        
        // 使用静态方法
        MathOperation add = MathOperation.add();
        MathOperation multiply = MathOperation.multiply();
        
        System.out.println("加法: " + add.operate(5, 3));
        System.out.println("乘法: " + multiply.operate(5, 3));
        
        // 三元函数接口
        TriFunction<String, Integer, Boolean, String> formatter = 
            (str, num, upper) -> {
                String result = str + ": " + num;
                return upper ? result.toUpperCase() : result;
            };
        
        System.out.println(formatter.apply("count", 42, true));
         System.out.println(formatter.apply("value", 100, false));
     }
 }

9.2 函数式接口组合

java

import java.util.function.*;
import java.util.*;

public class FunctionComposition {
    
    public static void main(String[] args) {
        // Function 组合
        Function<String, String> addPrefix = s -> "前缀_" + s;
        Function<String, String> addSuffix = s -> s + "_后缀";
        Function<String, String> toUpper = String::toUpperCase;
        
        // compose: 先执行参数函数，再执行当前函数
        Function<String, String> composed1 = addSuffix.compose(addPrefix);
        System.out.println("compose: " + composed1.apply("测试"));
        
        // andThen: 先执行当前函数，再执行参数函数
        Function<String, String> composed2 = addPrefix.andThen(addSuffix);
        System.out.println("andThen: " + composed2.apply("测试"));
        
        // 链式组合
        Function<String, String> pipeline = addPrefix
            .andThen(toUpper)
            .andThen(addSuffix);
        System.out.println("链式组合: " + pipeline.apply("hello"));
        
        // Predicate 组合
        Predicate<Integer> isPositive = x -> x > 0;
        Predicate<Integer> isEven = x -> x % 2 == 0;
        Predicate<Integer> isLessThan100 = x -> x < 100;
        
        // and, or, negate 组合
        Predicate<Integer> isPositiveEven = isPositive.and(isEven);
        Predicate<Integer> isPositiveOrEven = isPositive.or(isEven);
        Predicate<Integer> isNotPositive = isPositive.negate();
        
        List<Integer> numbers = Arrays.asList(-2, -1, 0, 1, 2, 3, 4, 5, 100, 101);
        
        System.out.println("\n正数且偶数:");
        numbers.stream().filter(isPositiveEven).forEach(System.out::println);
        
        System.out.println("\n复杂条件组合:");
        Predicate<Integer> complexCondition = isPositive
            .and(isEven)
            .and(isLessThan100);
        numbers.stream().filter(complexCondition).forEach(System.out::println);
        
        // Consumer 组合
        Consumer<String> print = System.out::println;
        Consumer<String> log = s -> System.err.println("LOG: " + s);
        
        Consumer<String> printAndLog = print.andThen(log);
        printAndLog.accept("测试消息");
    }
}

10. Stream API

10.1 Stream 基础操作

java

import java.util.*;
import java.util.stream.*;

public class StreamBasics {
    
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // 1. 创建 Stream
        Stream<Integer> stream1 = numbers.stream();
        Stream<Integer> stream2 = Stream.of(1, 2, 3, 4, 5);
        Stream<Integer> stream3 = Stream.iterate(0, n -> n + 2).limit(5);
        Stream<Double> stream4 = Stream.generate(Math::random).limit(3);
        
        // 2. 中间操作（惰性求值）
        System.out.println("=== 过滤和映射 ===");
        numbers.stream()
               .filter(n -> n % 2 == 0)  // 过滤偶数
               .map(n -> n * n)          // 平方
               .forEach(System.out::println);
        
        System.out.println("\n=== 去重和排序 ===");
        List<String> words = Arrays.asList("apple", "banana", "apple", "cherry", "banana");
        words.stream()
             .distinct()                    // 去重
             .sorted()                      // 排序
             .forEach(System.out::println);
        
        System.out.println("\n=== 限制和跳过 ===");
        numbers.stream()
               .skip(3)      // 跳过前3个
               .limit(4)     // 限制4个
               .forEach(System.out::println);
        
        // 3. 终端操作（触发计算）
        System.out.println("\n=== 聚合操作 ===");
        long count = numbers.stream().filter(n -> n > 5).count();
        System.out.println("大于5的数量: " + count);
        
        OptionalInt max = numbers.stream().mapToInt(Integer::intValue).max();
        System.out.println("最大值: " + max.orElse(0));
        
        int sum = numbers.stream().mapToInt(Integer::intValue).sum();
        System.out.println("总和: " + sum);
        
        OptionalDouble average = numbers.stream().mapToInt(Integer::intValue).average();
        System.out.println("平均值: " + average.orElse(0));
        
        // 4. 查找操作
        System.out.println("\n=== 查找操作 ===");
        Optional<Integer> first = numbers.stream().filter(n -> n > 5).findFirst();
        System.out.println("第一个大于5的数: " + first.orElse(-1));
        
        Optional<Integer> any = numbers.stream().filter(n -> n > 5).findAny();
        System.out.println("任意一个大于5的数: " + any.orElse(-1));
        
        // 5. 匹配操作
        boolean allPositive = numbers.stream().allMatch(n -> n > 0);
        boolean anyEven = numbers.stream().anyMatch(n -> n % 2 == 0);
        boolean noneNegative = numbers.stream().noneMatch(n -> n < 0);
        
        System.out.println("\n=== 匹配操作 ===");
        System.out.println("全部为正数: " + allPositive);
        System.out.println("存在偶数: " + anyEven);
        System.out.println("没有负数: " + noneNegative);
    }
}

10.2 Stream 高级操作

java

import java.util.*;
import java.util.stream.*;

public class StreamAdvanced {
    
    static class Student {
        private String name;
        private int age;
        private String major;
        private double score;
        
        public Student(String name, int age, String major, double score) {
            this.name = name;
            this.age = age;
            this.major = major;
            this.score = score;
        }
        
        // getters
        public String getName() { return name; }
        public int getAge() { return age; }
        public String getMajor() { return major; }
        public double getScore() { return score; }
        
        @Override
        public String toString() {
            return String.format("Student{name='%s', age=%d, major='%s', score=%.1f}", 
                               name, age, major, score);
        }
    }
    
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
            new Student("张三", 20, "计算机", 85.5),
            new Student("李四", 22, "数学", 92.0),
            new Student("王五", 21, "计算机", 78.5),
            new Student("赵六", 23, "物理", 88.0),
            new Student("钱七", 20, "数学", 95.5)
        );
        
        // 1. 分组操作
        System.out.println("=== 按专业分组 ===");
        Map<String, List<Student>> groupedByMajor = students.stream()
            .collect(Collectors.groupingBy(Student::getMajor));
        groupedByMajor.forEach((major, studentList) -> {
            System.out.println(major + ": " + studentList.size() + " 人");
        });
        
        // 2. 分组统计
        System.out.println("\n=== 按专业统计平均分 ===");
        Map<String, Double> averageScoreByMajor = students.stream()
            .collect(Collectors.groupingBy(
                Student::getMajor,
                Collectors.averagingDouble(Student::getScore)
            ));
        averageScoreByMajor.forEach((major, avgScore) -> {
            System.out.printf("%s: %.2f\n", major, avgScore);
        });
        
        // 3. 分区操作
        System.out.println("\n=== 按分数分区 ===");
        Map<Boolean, List<Student>> partitioned = students.stream()
            .collect(Collectors.partitioningBy(s -> s.getScore() >= 90));
        System.out.println("优秀学生 (>=90): " + partitioned.get(true).size());
        System.out.println("普通学生 (<90): " + partitioned.get(false).size());
        
        // 4. 自定义收集器
        System.out.println("\n=== 自定义收集 ===");
        String studentNames = students.stream()
            .map(Student::getName)
            .collect(Collectors.joining(", ", "学生名单: [", "]"));
        System.out.println(studentNames);
        
        // 5. 统计信息
        System.out.println("\n=== 分数统计 ===");
        DoubleSummaryStatistics scoreStats = students.stream()
            .collect(Collectors.summarizingDouble(Student::getScore));
        System.out.println("分数统计: " + scoreStats);
        
        // 6. 多级分组
        System.out.println("\n=== 按专业和年龄分组 ===");
        Map<String, Map<Integer, List<Student>>> multiGrouped = students.stream()
            .collect(Collectors.groupingBy(
                Student::getMajor,
                Collectors.groupingBy(Student::getAge)
            ));
        multiGrouped.forEach((major, ageMap) -> {
            System.out.println(major + ":");
            ageMap.forEach((age, studentList) -> {
                System.out.println("  年龄 " + age + ": " + studentList.size() + " 人");
            });
        });
        
        // 7. flatMap 操作
        System.out.println("\n=== flatMap 示例 ===");
        List<List<String>> nestedList = Arrays.asList(
            Arrays.asList("a", "b"),
            Arrays.asList("c", "d", "e"),
            Arrays.asList("f")
        );
        
        List<String> flatList = nestedList.stream()
            .flatMap(List::stream)
            .collect(Collectors.toList());
        System.out.println("扁平化结果: " + flatList);
        
        // 8. reduce 操作
        System.out.println("\n=== reduce 操作 ===");
        Optional<Student> topStudent = students.stream()
            .reduce((s1, s2) -> s1.getScore() > s2.getScore() ? s1 : s2);
        System.out.println("最高分学生: " + topStudent.orElse(null));
        
        double totalScore = students.stream()
             .map(Student::getScore)
             .reduce(0.0, Double::sum);
         System.out.println("总分: " + totalScore);
     }
 }

10.3 并行流

java

import java.util.*;
import java.util.stream.*;
import java.util.concurrent.*;

public class ParallelStreamExample {
    
    public static void main(String[] args) {
        List<Integer> largeList = IntStream.rangeClosed(1, 1000000)
                                          .boxed()
                                          .collect(Collectors.toList());
        
        // 串行流处理
        long startTime = System.currentTimeMillis();
        long sequentialSum = largeList.stream()
                                     .mapToLong(Integer::longValue)
                                     .sum();
        long sequentialTime = System.currentTimeMillis() - startTime;
        
        // 并行流处理
        startTime = System.currentTimeMillis();
        long parallelSum = largeList.parallelStream()
                                   .mapToLong(Integer::longValue)
                                   .sum();
        long parallelTime = System.currentTimeMillis() - startTime;
        
        System.out.println("串行流结果: " + sequentialSum + ", 耗时: " + sequentialTime + "ms");
        System.out.println("并行流结果: " + parallelSum + ", 耗时: " + parallelTime + "ms");
        
        // 并行流的线程安全问题
        System.out.println("\n=== 并行流线程安全 ===");
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // 错误示例：非线程安全
        List<Integer> unsafeResult = new ArrayList<>();
        numbers.parallelStream().forEach(unsafeResult::add); // 可能导致数据丢失
        System.out.println("非线程安全结果大小: " + unsafeResult.size());
        
        // 正确示例：使用线程安全的收集器
        List<Integer> safeResult = numbers.parallelStream()
                                         .collect(Collectors.toList());
        System.out.println("线程安全结果: " + safeResult);
        
        // 使用同步集合
        List<Integer> synchronizedList = Collections.synchronizedList(new ArrayList<>());
        numbers.parallelStream().forEach(synchronizedList::add);
        System.out.println("同步集合结果大小: " + synchronizedList.size());
        
        // 并行流的适用场景
        System.out.println("\n=== 并行流性能对比 ===");
        
        // CPU密集型任务
        List<Integer> testData = IntStream.rangeClosed(1, 10000)
                                         .boxed()
                                         .collect(Collectors.toList());
        
        // 串行处理
        startTime = System.nanoTime();
        double sequentialResult = testData.stream()
                                         .mapToDouble(n -> Math.sqrt(n * n * n))
                                         .sum();
        long sequentialNanos = System.nanoTime() - startTime;
        
        // 并行处理
        startTime = System.nanoTime();
        double parallelResult = testData.parallelStream()
                                       .mapToDouble(n -> Math.sqrt(n * n * n))
                                       .sum();
        long parallelNanos = System.nanoTime() - startTime;
        
        System.out.printf("串行处理: %.2f, 耗时: %.2fms\n", 
                         sequentialResult, sequentialNanos / 1_000_000.0);
        System.out.printf("并行处理: %.2f, 耗时: %.2fms\n", 
                         parallelResult, parallelNanos / 1_000_000.0);
        
        // 控制并行度
        System.out.println("\n=== 控制并行度 ===");
        System.out.println("可用处理器数量: " + Runtime.getRuntime().availableProcessors());
        
        // 使用自定义ForkJoinPool
        ForkJoinPool customThreadPool = new ForkJoinPool(2);
        try {
            long customResult = customThreadPool.submit(() ->
                numbers.parallelStream()
                       .mapToLong(Integer::longValue)
                       .sum()
            ).get();
            System.out.println("自定义线程池结果: " + customResult);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            customThreadPool.shutdown();
        }
    }
}

11. Optional 类

11.1 Optional 基础用法

java

import java.util.*;

public class OptionalBasics {
    
    public static void main(String[] args) {
        // 1. 创建 Optional
        Optional<String> empty = Optional.empty();
        Optional<String> nonEmpty = Optional.of("Hello");
        Optional<String> nullable = Optional.ofNullable(null);
        Optional<String> nullable2 = Optional.ofNullable("World");
        
        System.out.println("=== Optional 创建 ===");
        System.out.println("empty: " + empty);
        System.out.println("nonEmpty: " + nonEmpty);
        System.out.println("nullable: " + nullable);
        System.out.println("nullable2: " + nullable2);
        
        // 2. 检查值是否存在
        System.out.println("\n=== 检查值 ===");
        System.out.println("empty.isPresent(): " + empty.isPresent());
        System.out.println("nonEmpty.isPresent(): " + nonEmpty.isPresent());
        System.out.println("empty.isEmpty(): " + empty.isEmpty()); // Java 11+
        
        // 3. 获取值
        System.out.println("\n=== 获取值 ===");
        
        // 安全获取值
        if (nonEmpty.isPresent()) {
            System.out.println("值: " + nonEmpty.get());
        }
        
        // 使用 orElse
        String value1 = empty.orElse("默认值");
        String value2 = nonEmpty.orElse("默认值");
        System.out.println("empty.orElse(): " + value1);
        System.out.println("nonEmpty.orElse(): " + value2);
        
        // 使用 orElseGet（惰性求值）
        String value3 = empty.orElseGet(() -> "惰性默认值");
        System.out.println("empty.orElseGet(): " + value3);
        
        // 使用 orElseThrow
        try {
            String value4 = empty.orElseThrow(() -> new RuntimeException("值不存在"));
        } catch (RuntimeException e) {
            System.out.println("异常: " + e.getMessage());
        }
        
        // 4. 条件执行
        System.out.println("\n=== 条件执行 ===");
        nonEmpty.ifPresent(s -> System.out.println("值存在: " + s));
        empty.ifPresent(s -> System.out.println("这不会执行"));
        
        // Java 9+ ifPresentOrElse
        nonEmpty.ifPresentOrElse(
            s -> System.out.println("存在值: " + s),
            () -> System.out.println("值不存在")
        );
        
        empty.ifPresentOrElse(
            s -> System.out.println("这不会执行"),
            () -> System.out.println("空值处理")
        );
    }
}

11.2 Optional 高级用法

java

import java.util.*;
import java.util.stream.*;

public class OptionalAdvanced {
    
    static class Person {
        private String name;
        private Optional<String> email;
        private Optional<Address> address;
        
        public Person(String name, String email, Address address) {
            this.name = name;
            this.email = Optional.ofNullable(email);
            this.address = Optional.ofNullable(address);
        }
        
        public String getName() { return name; }
        public Optional<String> getEmail() { return email; }
        public Optional<Address> getAddress() { return address; }
    }
    
    static class Address {
        private String street;
        private String city;
        
        public Address(String street, String city) {
            this.street = street;
            this.city = city;
        }
        
        public String getStreet() { return street; }
        public String getCity() { return city; }
    }
    
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("张三", "zhang@example.com", new Address("中山路", "北京")),
            new Person("李四", null, null),
            new Person("王五", "wang@example.com", new Address("人民路", "上海"))
        );
        
        // 1. map 操作
        System.out.println("=== map 操作 ===");
        Optional<String> name = Optional.of("hello");
        Optional<String> upperName = name.map(String::toUpperCase);
        System.out.println("转大写: " + upperName.orElse("无值"));
        
        Optional<Integer> length = name.map(String::length);
        System.out.println("字符串长度: " + length.orElse(0));
        
        // 2. flatMap 操作
        System.out.println("\n=== flatMap 操作 ===");
        people.forEach(person -> {
            String email = person.getEmail()
                                .map(String::toUpperCase)
                                .orElse("无邮箱");
            System.out.println(person.getName() + " 的邮箱: " + email);
            
            String city = person.getAddress()
                               .map(Address::getCity)
                               .orElse("未知城市");
            System.out.println(person.getName() + " 的城市: " + city);
        });
        
        // 3. filter 操作
        System.out.println("\n=== filter 操作 ===");
        Optional<String> longEmail = Optional.of("very.long.email@example.com")
                                           .filter(email -> email.length() > 10);
        System.out.println("长邮箱: " + longEmail.orElse("邮箱太短"));
        
        Optional<String> shortEmail = Optional.of("a@b.com")
                                            .filter(email -> email.length() > 10);
        System.out.println("短邮箱: " + shortEmail.orElse("邮箱太短"));
        
        // 4. 链式操作
        System.out.println("\n=== 链式操作 ===");
        people.forEach(person -> {
            String result = person.getEmail()
                                 .filter(email -> email.contains("@"))
                                 .map(email -> email.substring(0, email.indexOf("@")))
                                 .map(String::toUpperCase)
                                 .orElse("无效用户名");
            System.out.println(person.getName() + " 的用户名: " + result);
        });
        
        // 5. Optional 与 Stream 结合
        System.out.println("\n=== Optional 与 Stream ===");
        List<String> emails = people.stream()
                                   .map(Person::getEmail)
                                   .filter(Optional::isPresent)
                                   .map(Optional::get)
                                   .collect(Collectors.toList());
        System.out.println("所有邮箱: " + emails);
        
        // Java 9+ 更简洁的写法
        List<String> emails2 = people.stream()
                                    .map(Person::getEmail)
                                    .flatMap(Optional::stream)
                                    .collect(Collectors.toList());
        System.out.println("所有邮箱(Java 9+): " + emails2);
        
        // 6. Optional 的组合
        System.out.println("\n=== Optional 组合 ===");
        Optional<String> firstName = Optional.of("张");
        Optional<String> lastName = Optional.of("三");
        
        // 组合两个 Optional
        Optional<String> fullName = firstName.flatMap(first ->
            lastName.map(last -> first + last)
        );
        System.out.println("全名: " + fullName.orElse("未知"));
        
        // 7. 实用工具方法
        System.out.println("\n=== 实用工具 ===");
        
        // 安全的字符串转整数
        System.out.println("字符串转整数: " + safeParseInt("123").orElse(-1));
        System.out.println("无效字符串转整数: " + safeParseInt("abc").orElse(-1));
        
        // 安全的数组访问
        String[] array = {"a", "b", "c"};
        System.out.println("数组[1]: " + safeArrayAccess(array, 1).orElse("越界"));
        System.out.println("数组[5]: " + safeArrayAccess(array, 5).orElse("越界"));
    }
    
    // 安全的字符串转整数
    public static Optional<Integer> safeParseInt(String str) {
        try {
            return Optional.of(Integer.parseInt(str));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }
    
    // 安全的数组访问
    public static <T> Optional<T> safeArrayAccess(T[] array, int index) {
        if (index >= 0 && index < array.length) {
            return Optional.ofNullable(array[index]);
        }
        return Optional.empty();
    }
}

12. 总结与最佳实践

12.1 设计原则

单一职责原则：每个类应该只有一个改变的理由
开闭原则：对扩展开放，对修改关闭
里氏替换原则：子类应该能够替换父类
接口隔离原则：不应该强迫客户依赖它们不使用的方法
依赖倒置原则：高层模块不应该依赖低层模块

12.2 编码最佳实践

java

// 1. 使用 Optional 避免 null 检查
public Optional<User> findUserById(Long id) {
    // 返回 Optional 而不是 null
    return userRepository.findById(id);
}

// 2. 使用 Stream API 进行集合操作
List<String> activeUserNames = users.stream()
    .filter(User::isActive)
    .map(User::getName)
    .collect(Collectors.toList());

// 3. 使用函数式接口提高代码可读性
Predicate<User> isAdult = user -> user.getAge() >= 18;
Function<User, String> getUserInfo = user -> 
    user.getName() + " (" + user.getAge() + ")";

// 4. 合理使用泛型
public <T extends Comparable<T>> T findMax(List<T> list) {
    return list.stream().max(Comparable::compareTo).orElse(null);
}

// 5. 使用枚举替代常量
public enum Status {
    ACTIVE("激活"),
    INACTIVE("未激活"),
    SUSPENDED("暂停");
    
    private final String description;
    
    Status(String description) {
        this.description = description;
    }
    
    public String getDescription() {
        return description;
    }
}

12.3 性能优化建议

合理使用并行流：仅在数据量大且CPU密集型任务时使用
避免过度使用反射：反射会影响性能，考虑使用注解处理器
正确使用泛型：避免类型擦除带来的性能问题
合理设计类层次：避免过深的继承层次
使用适当的集合类型：根据使用场景选择合适的集合实现

12.4 安全注意事项

避免反射安全漏洞：限制反射的使用范围
正确处理异常：不要忽略或隐藏异常
使用不可变对象：提高线程安全性
验证输入参数：使用 Optional 和断言进行参数验证
遵循最小权限原则：合理设置访问修饰符

Java 特殊特性详解 ​

概述 ​

目录 ​

1. 类与对象 ​

1.1 类的定义与结构 ​

1.2 继承与多态 ​

1.3 访问修饰符 ​

2. 接口 ​

2.1 接口定义与实现 ​

2.2 默认方法和静态方法（Java 8+） ​

2.3 函数式接口 ​

3. 枚举 ​

3.1 基本枚举 ​

3.2 复杂枚举 ​

3.3 枚举实现接口 ​

4. 反射 ​

4.1 Class 对象 ​

4.2 反射操作字段 ​

4.3 反射操作方法 ​

4.4 反射操作构造方法 ​

4.5 反射工具类 ​

5. 注解 ​

5.1 内置注解 ​

5.2 自定义注解 ​

5.3 注解处理器 ​

5.4 注解驱动的简单框架 ​

6. 泛型 ​

6.1 泛型基础 ​

6.2 泛型方法 ​

6.3 通配符 ​

6.4 类型擦除和限制 ​

7. 内部类 ​

7.1 成员内部类 ​

7.2 静态内部类 ​

7.3 局部内部类 ​

7.4 匿名内部类 ​

7.5 内部类的实际应用 ​

8. Lambda 表达式 ​

8.1 Lambda 基础语法 ​

8.2 常用函数式接口 ​

8.3 方法引用 ​

8.4 Lambda 表达式的实际应用 ​

9. 函数式接口 ​

9.1 自定义函数式接口 ​

9.2 函数式接口组合 ​

10. Stream API ​

10.1 Stream 基础操作 ​

10.2 Stream 高级操作 ​

10.3 并行流 ​

11. Optional 类 ​

11.1 Optional 基础用法 ​

11.2 Optional 高级用法 ​

12. 总结与最佳实践 ​

12.1 设计原则 ​

12.2 编码最佳实践 ​

12.3 性能优化建议 ​

12.4 安全注意事项 ​

Java 特殊特性详解

概述

目录

1. 类与对象

1.1 类的定义与结构

1.2 继承与多态

1.3 访问修饰符

2. 接口

2.1 接口定义与实现

2.2 默认方法和静态方法（Java 8+）

2.3 函数式接口

3. 枚举

3.1 基本枚举

3.2 复杂枚举

3.3 枚举实现接口

4. 反射

4.1 Class 对象

4.2 反射操作字段

4.3 反射操作方法

4.4 反射操作构造方法

4.5 反射工具类

5. 注解

5.1 内置注解

5.2 自定义注解

5.3 注解处理器

5.4 注解驱动的简单框架

6. 泛型

6.1 泛型基础

6.2 泛型方法

6.3 通配符

6.4 类型擦除和限制

7. 内部类

7.1 成员内部类

7.2 静态内部类

7.3 局部内部类

7.4 匿名内部类

7.5 内部类的实际应用

8. Lambda 表达式

8.1 Lambda 基础语法

8.2 常用函数式接口

8.3 方法引用

8.4 Lambda 表达式的实际应用

9. 函数式接口

9.1 自定义函数式接口

9.2 函数式接口组合

10. Stream API

10.1 Stream 基础操作

10.2 Stream 高级操作

10.3 并行流

11. Optional 类

11.1 Optional 基础用法

11.2 Optional 高级用法

12. 总结与最佳实践

12.1 设计原则

12.2 编码最佳实践

12.3 性能优化建议

12.4 安全注意事项