《零基础学Java编程：手把手教你写出第一个可运行的程序

class Outer {
    private int x = 10;
    
    class Inner {
        void display() {
            System.out.println("x = " + x); // 可以直接访问外部类成员
        }
    }
}

(2) 静态内部类

class Outer {
    static class StaticInner {
        // 不能直接访问外部类的非静态成员
    }
}

(3) 方法局部内部类

class Outer {
    void method() {
        class LocalInner {
            // 只在方法内可见
        }
    }
}

(4) 匿名内部类

interface Greeting {
    void greet();
}

public class Main {
    public static void main(String[] args) {
        Greeting g = new Greeting() {
            @Override
            public void greet() {
                System.out.println("Hello, world!");
            }
        };
    }
}

3. 内部类的特点

可以实现多重继承（通过多个内部类继承不同父类）
可以更好地封装仅在一个地方使用的类
匿名内部类常用于事件处理和线程实现

二 . 函数式编程（Functional Programming）

1. 函数式编程核心概念

不可变性：避免状态改变和可变数据
纯函数：相同输入总是产生相同输出，没有副作用
高阶函数：函数可以作为参数或返回值
函数组合：将多个简单函数组合成复杂功能

2. Java中的函数式编程特性（Java 8+）

(1) Lambda表达式

（博哥有话说：博哥最喜欢这种编程形式，这个表达式简化了代码并且好用，在下面优势也有提到）

// 传统方式
Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
};

// Lambda方式
Runnable r2 = () -> System.out.println("Hello");

(2) 函数式接口（Functional Interface）

只有一个抽象方法的接口
常用注解：@FunctionalInterface

@FunctionalInterface
interface MyFunction {
    int apply(int a, int b);
}

MyFunction add = (a, b) -> a + b;
System.out.println(add.apply(2, 3)); // 输出5

(3) Java内置函数式接口

Predicate<T>：接受一个参数，返回boolean
Function<T,R>：接受T类型参数，返回R类型结果
Consumer<T>：接受一个参数，无返回值
Supplier<T>：无参数，返回一个结果
BiFunction<T,U,R>：接受T和U类型参数，返回R类型结果

(4) 方法引用

（博哥有话说：这种方式确实简单，但是初学者建议先写源码，不要省略）

List<String> list = Arrays.asList("a", "b", "c");
list.forEach(System.out::println); // 方法引用

3. Stream API

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");

// 过滤空字符串并计数
long count = strings.stream()
                   .filter(string -> !string.isEmpty())
                   .count();

// 并行处理
List<String> filtered = strings.parallelStream()
                              .filter(string -> !string.isEmpty())
                              .collect(Collectors.toList());

4. Optional类

用于避免NullPointerException

Optional<String> optional = Optional.ofNullable(getString());
String value = optional.orElse("default");

5. 函数式编程优势

代码更简洁易读
更容易并行化处理
减少副作用，提高代码可靠性
更好的支持惰性求值

三、内部类与函数式编程的结合

1. Lambda替代匿名内部类

// 传统匿名内部类
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Running");
    }
}).start();

// Lambda方式
new Thread(() -> System.out.println("Running")).start();

2. 函数式接口中的内部类

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
    
    // 默认方法
    default void print(int result) {
        System.out.println("Result: " + result);
    }
    
    // 静态内部类
    static class Helper {
        static int doubleNum(int n) {
            return n * 2;
        }
    }
}