【Java基础——18 接口新特性 代码块 内部类 Lambda表达式】

接口新特性

Java 8 引入了一些接口的新特性，使接口更强大和灵活：

• 默认方法（Default Methods）：可以在接口中定义带有实现的方法。
• 静态方法（Static Methods）：可以在接口中定义静态方法。

interface MyInterface {
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }

    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

代码块（Code Block）

代码块是括在大括号 {} 中的一段代码，用于组织代码。分为4种：

• 局部代码块：限定变量作用范围，释放内存。
• 构造代码块：对象创建时初始化实例变量。
• 静态代码块：类加载时初始化静态变量。
• 同步代码块：确保线程安全，避免竞态条件。

// 局部代码块是用大括号 {} 括起来的一段代码，可以放在方法中，以限定变量的作用范围，释放内存。
public void myMethod() {
    { // 局部代码块
        int x = 10;
        System.out.println(x);
    }
    // x 在这里不可用
}


// 构造代码块是直接在类中定义的代码块，每次创建对象时在构造方法之前执行，用于初始化实例变量。
public class MyClass {
    { // 构造代码块
        System.out.println("Constructor block executed.");
    }

    public MyClass() {
        System.out.println("Constructor executed.");
    }
}


// 静态代码块用 static 修饰，用于静态变量的初始化，在类加载时执行一次。
public class MyClass {
    static { // 静态代码块
        System.out.println("Static block executed.");
    }

    public MyClass() {
        System.out.println("Constructor executed.");
    }
}


// 同步代码块用于多线程编程，确保同一时间只有一个线程执行代码块中的代码，以避免线程安全问题。
public class MyClass {
    public void synchronizedMethod() {
        synchronized(this) { // 同步代码块
            System.out.println("Synchronized block executed.");
        }
    }
}

内部类（Inner Class）

内部类是在另一个类内部定义的类。它们可以分为四种类型：

• 成员内部类：作为外部类的成员，访问外部类的所有成员。
• 静态内部类：使用 static 修饰，不依赖外部类实例，访问外部类的静态成员。
• 局部内部类：定义在方法或构造块中，局部范围内使用。
• 匿名内部类：没有类名，用于实现接口或继承类的瞬时实例。

// 成员内部类是作为外部类的成员定义的类。它可以访问外部类的所有成员，包括私有成员。
public class OuterClass {
    class InnerClass { // 成员内部类
        void display() {
            System.out.println("Inner class method.");
        }
    }
}


// 静态内部类使用 static 修饰，不依赖于外部类的实例。它只能访问外部类的静态成员。
public class OuterClass {
    static class StaticInnerClass { // 静态内部类
        void display() {
            System.out.println("Static inner class method.");
        }
    }
}


// 局部内部类定义在方法或构造块中，只在其定义的范围内可见和使用。
public class OuterClass {
    void myMethod() {
        class LocalInnerClass { // 局部内部类
            void display() {
                System.out.println("Local inner class method.");
            }
        }
        LocalInnerClass local = new LocalInnerClass();
        local.display();
    }
}

// 匿名内部类没有类名，通常用于实现接口或继承类的瞬时实例。
public class OuterClass {
    void myMethod() {
        Runnable r = new Runnable() { // 匿名内部类
            public void run() {
                System.out.println("Anonymous inner class method.");
            }
        };
        r.run();
    }
}

Lambda表达式

Lambda表达式是 Java 8 引入的简洁的匿名函数，用于实现函数式接口（只有一个抽象方法的接口）。它使得代码更简洁和易读。

(parameters) -> expression
或者
(parameters) -> { statements; }

// 使用Lambda表达式实现Runnable接口
Runnable r = () -> System.out.println("Hello Lambda!");

public class TestLambda {
    public static void main(String[] args) {
        r.run();
    }
}