Java之内部类、匿名内部类、Lambda表达式和方法引用_lomok表达式语法内部匿名类

本章讲解内部类 匿名内部类 Lambda表达式 方法引用

目录

1.内部类：

2.匿名内部类

3.Lambda表达式

4.方法引用

---

1.内部类

内部类顾名思义就是一个类里面再次定义一个类，这样做有好处也有坏处，好处是如果使用了内部类，那么这两个类之间的通信将会十分轻松。比如私有属性传递，但是缺点也很明显，就是内部类会导致类的结构复杂化。

内部类访问外部类私有化属性，方法的格式 与其实例化过程：

实例化过程

外部类.内部类  对象名称= new 外部类().内部类()

public class OuterClass {
    public class InnerClass {
        public void display() {
            System.out.println("This is the inner class.");
        }
    }
}
 
public class Example {
    public static void main(String[] args) {
        OuterClass.InnerClass obj = new OuterClass().new InnerClass();
        obj.display();
    }
}

访问外部私有属性和方法等

str = 外部类.this.str

当实现static定义内部类时候，其访问外部类的属性方法的格式和实例化过程：

1.实例化过程

外部类.内部类 实例化对象名称 = new 外部类.内部类();

2.访问外部私有属性和方法

str = 外部类.str

public class OuterClass {
    private static int outerStaticField = 100;
    private int outerField = 200;
    
    public static class InnerClass {
        public void display() {
            System.out.println("Outer static field: " + outerStaticField);
        }
    }
    
    public static void outerStaticMethod() {
        System.out.println("Calling outer static method");
    }
}
 
public class Example {
    public static void main(String[] args) {
        OuterClass.InnerClass obj = new OuterClass.InnerClass();
        obj.display();
        
        OuterClass.outerStaticMethod();
    }
}

注意：可以直接访问外部类的静态成员（包括静态属性和静态方法），但不能直接访问外部类的非静态成员（非静态属性和非静态方法）。

两者的区别：

1.当用static定义内部类时候，那么内部类其实就是一个独立的个体了所以可以不需要实例化其外部类就嗯呢更直接实例化内部类

除了内部类还可以有内部接口，接口内部实现抽象类，接口子类定义内部类

1.内部接口：

public class Example {
    interface InnerInterface {
        void display();
    }
    
    public static void main(String[] args) {
        InnerInterface innerObj = new InnerInterface() {
            public void display() {
                System.out.println("Inner interface implementation");
            }
        };
        
        innerObj.display();
    }
}

2.接口内部实现抽象类

public interface OuterInterface {
    abstract class InnerAbstractClass {
        abstract void display();
    }
}
 
public class Example implements OuterInterface.InnerAbstractClass {
    public void display() {
        System.out.println("Implementation of inner abstract class");
    }
 
    public static void main(String[] args) {
        Example obj = new Example();
        obj.display();
    }
}

3.接口子类定义内部类

interface OuterInterface {
    void outerMethod();
 
    class InnerClass {
        void innerMethod() {
            System.out.println("Inner class method");
        }
    }
}
 
class Example implements OuterInterface {
    public void outerMethod() {
        InnerClass innerObj = new InnerClass();
        innerObj.innerMethod();
    }
 
    public static void main(String[] args) {
        Example obj = new Example();
        obj.outerMethod();
    }
}

4.方法种定义内部类

虽然一般内部类在类的哪里都可以进行定义，到那时，一般情况下，内部类都是定义在外部类的方法里面

public class OuterClass {
    public void outerMethod() {
        class InnerClass {
            void innerMethod() {
                System.out.println("Inner method");
            }
        }
        
        InnerClass innerObj = new InnerClass();
        innerObj.innerMethod();
    }
    
    public static void main(String[] args) {
        OuterClass obj = new OuterClass();
        obj.outerMethod();
    }
}

---

2.匿名内部类

问题引出：由于一般情况下一个public类对应一个.java文件，那么如果类功能简单情况下，很多的类下就会产生大量的java类文件。所以通过匿名内部类可以不产生子类，就能完成子类带来的功能。

public class Main {
    public static void main(String[] args) {
        // 创建接口对象并调用方法
        MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("匿名内部类实现的方法");
            }
        };
 
        myInterface.doSomething(); // 输出：匿名内部类实现的方法
    }
}
 
// 定义接口
interface MyInterface {
    void doSomething();
}

---

（重点掌握）3.Lambda表达式

匿名内部类由于其实现是比较复杂的，所以就诞生了Lambda表达式，这种表达式极大的简化的匿名内部类的操作

实现Lambda的语法有两种：

1.()->{方法体}

Runnable runnable = () -> {
    System.out.println("Hello, world!");
};

2.()->语句

Calculator calculator = (a, b) -> a + b;

@FunctionInterface注解

表示函数式接口，接口内只能出现一种抽象类方法

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}
 
public class LambdaExample {
    public static void main(String[] args) {
        Calculator add = (a, b) -> a + b;
        int result = add.calculate(10, 5);
        System.out.println("Addition result: " + result);
        
        Calculator subtract = (a, b) -> a - b;
        result = subtract.calculate(10, 5);
        System.out.println("Subtraction result: " + result);
    }
}

---

4.方法引用

引用并不陌生，在以前的java的实例中就有着大量的引用，但是引用的大部分都是实例化对象，或者引用值，这里是对方法的引用。方法的引用分为三类：引用静态方法 引用某个对象的方法 引用特定类型的方法 引用构造方法

方法引用有以下四种：

引用静态方法 ：                 类名称：：static方法名称

@FunctionalInterface
interface Calculator {
public void caculate();
}
// 静态方法
class MathUtils {
    public static int multiply(int a, int b) {
        return a * b;
    }
}
 
// 方法引用
Calculator calculator = MathUtils::multiply;
int result = calculator.calculate(5, 3);
System.out.println("Multiplication result: " + result);

引用某个对象的方法 ：     实例化对象：：普通方法

// 对象方法
class StringUtils {
    public int getLength(String str) {
        return str.length();
    }
}
 
// 方法引用
StringUtils stringUtils = new StringUtils();
Calculator calculator = stringUtils::getLength;
int result = calculator.calculate("Hello");
System.out.println("String length: " + result);

引用特定类型的方法  ：    特定类：：普通方法

// 指定类型的方法
class StringUtils {
    public static boolean startsWith(String str, String prefix) {
        return str.startsWith(prefix);
    }
}
 
// 方法引用
BiPredicate<String, String> startsWith = StringUtils::startsWith;
boolean result = startsWith.test("Hello", "He");
System.out.println("Starts with 'He': " + result);

引用构造方法：                   类名称：：new

// 构造方法
class Person {
    private String name;
 
    public Person(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
}
 
// 方法引用
Function<String, Person> personFactory = Person::new;
Person person = personFactory.apply("John");
System.out.println("Person name: " + person.getName());

---