java-新手笔记-(Lambda表达式, 匿名内部类,作用域,闭包)

Lambda表达式

定义:可以看作是一种没有名称（即匿名）的函数。Lambda表达式主要用于表示那些只有一个抽象方法的接口（即函数式接口）的实例.

这边可以用接口定义抽象的方法,再用lambda继续完善方法,注意的是 接口是只支持单一函数lambda调用. 用@FunctionalInterface

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

参数列表描述了函数的输入，箭头符号将参数列表与函数体连接起来，函数体则描述了函数的具体行为。

模版 

// 定义一个函数式接口  
@FunctionalInterface  
interface Greeting {  
    void sayHello(String name);  
}  
  
public class Main {  
    public static void main(String[] args) {  
        // 使用Lambda表达式创建Greeting接口的实例  
        Greeting greeting = name -> System.out.println("Hello, " + name);  
          
        // 调用Lambda表达式表示的方法  
        greeting.sayHello("World");  
    }  
}

匿名内部类

匿名内部类在Java中用于创建一个没有名称的类实例，它通常用于实现接口或扩展一个类

注意的是:interface没有用@FunctionalInterface函数接口

模版

interface Greeting {  
    void sayHello();  
}  
  
public class AnonymousInnerClassExample {  
    public static void main(String[] args) {  
        // 使用匿名内部类实现 Greeting 接口  
        Greeting greeting = new Greeting() {
//新建一个类,然后重写了sayHello方法  
            @Override  
            public void sayHello() {  
                System.out.println("Hello, World from Anonymous Inner Class!");  
            }  
        };  
          
        // 调用匿名内部类实现的方法  
        greeting.sayHello();  
    }  
}

 匿名内部类和lambda区别

接口中只有一个抽象方法且需要更简洁的语法时，建议使用Lambda表达式；而当接口中有多个抽象方法或需要更多灵活性时，可以使用匿名内部类。

在了解闭包之前 先了解一下作用域

局部变量作用域：是在类的主体中声明的变量 如 int b =10;

实例变量作用域：在类的主体中声明的变量 

public class Person {  
    // 实例变量  
    String name;  
    int age;

 public void setName(String name) {  
        this.name = name; // 在方法内部访问和修改实例变量  
    }    }

 类变量（静态变量）作用域：在Java中的作用域是整个类,这意味着它们可以在类的任何方法或代码块中被访问，而无需创建类的实例

public class StaticVariableExample {  
    // 静态变量（类变量）  
    public static int staticVar = 42;  
  
    public static void main(String[] args) {  
        // 通过类名直接访问静态变量  
        System.out.println("静态变量的值：" + StaticVariableExample.staticVar);  
  
        // 创建类的实例  
        StaticVariableExample instance = new StaticVariableExample();  
  
        // 通过对象实例访问静态变量（尽管不推荐这样做）  
        System.out.println("通过实例访问静态变量的值：" + instance.staticVar);  
  
        // 修改静态变量的值  
        StaticVariableExample.staticVar = 100;  
  
        // 再次打印静态变量的值，以验证其已被修改  
        System.out.println("修改后的静态变量的值：" + StaticVariableExample.staticVar);  
    }  
}

方法作用域:方法内部声明的局部变量和参数的作用域。它们只能在该方法内部被访问。

void print(){
    
    System.out.println("VariableHolder.print");
}

 

参数作用域：方法参数的作用域仅限于该方法内部。一旦方法执行完毕，参数变量就会被销毁。

 

void print(String name){
    System.out.println("name = " + name);
}

块作用域：块作用域指的是在代码块（如if语句、for循环等）内部声明的变量的作用域 

闭包

闭包可以被视为一个能够访问和操作在其外部作用域中定义的变量的Lambda表达式或匿名内部类。由于Lambda表达式可以捕获其所在上下文的变量，因此它们可以保留对外部变量的引用，并在稍后的时间点执行时访问这些变量，即使这些变量在Lambda表达式定义之后的外部作用域中已经不再可用。

模版

public class UsingLambda{


        public static void main(String[] args) {
            // 定义一个外部变量
            final int outerVariable = 10;

            // 使用Lambda表达式创建一个闭包
            Runnable closure = () -> {
                System.out.println("outerVariable inside closure: " + outerVariable);
            };

            // 执行闭包
            closure.run(); // 输出：outerVariable inside closure: 20
        }
    }

这边使用了Runnable 接口是为了实现代码的复用,可以不在定义一个@FunctionalInterface函数接口的接口

注意的是 outerVariable是最终变量,如果需要更改的话,可以封装一个对象类解决

public class UsingLambda {
    public static void main(String[] args) {
        // 创建一个包含外部变量的对象
        class VariableHolder {
            int value = 10;
        }
        VariableHolder holder = new VariableHolder();

        // 使用Lambda表达式创建一个闭包，闭包捕获的是holder对象的引用
        Runnable closure = () -> {
            System.out.println("outerVariable inside closure: " + holder.value);
        };

        // 改变外部变量的值，通过修改holder对象的状态
        holder.value = 20;

        // 执行闭包
        closure.run(); // 输出：outerVariable inside closure: 20
    }
}