1. 内部类

一个类中内部中定义了一个类B

如:

public class A{
    public class b{
    }
}

内部类的访问特点

内部类可以直接访问外部类的成员,包括私有
外部了你要访问内部类成员,必须创建对象

2. 成员内部类

如是公共则可以创建对象

a类名.b类名 i=new a类名().new b类名();

3. 局部内部类

局部类外界是无法直接访问的

需要在内部创建对象并使用

4. 匿名内部类

匿名内部类是一贯继承了该类或者实现了该接口的子类匿名对象

new 类名或接口名(){
    重写方法;
};

匿名内部类可以直接调用方法只需要在匿名内部类后调用

new Inter(){
    @Override
    public void show() {
        System.out.println("匿名内部类");
    }
}.show();  //匿名内部类需要在匿名内部类后直接调用内部类的方法

匿名内部类本质上也是一个类但是是匿名无法直接调用

但我们可以通过多态实现创建对象来调用

Inter i =  new Inter(){  //匿名内部类也可以使用多态创建对象
     @Override
     public void show() {
         System.out.println("匿名内部类");
     }
 };  //匿名内部类需要在匿名内部类后直接调用内部类的方法
 i.show();  //调用方法

如果一个方法需要提供一个接口并使用它,我们可以在方法中直接new一个匿名内部类并重写接口的方法

public void in(Inter inter){
        inter.show();
    }
Outer op =new Outer();
op.in(new Inter() {
            @Override
            public void show() {
                System.out.println("在方法中直接new一个匿名内部类");
            }
        });

5. lambda表达式

lambda表达式,我们上面使用直接new一个匿名内部类给这个方法,我们也可以通过lambda表达式直接传一个

使用lambda表达式的前提

有一个接口
接口中有且仅有一个抽象方法

语法: (参数) -> {重写方法};

public class lambda {
    public static void main(String[] args) {
        goswimming(() -> {
            System.out.println("lambda");
        });
    }
    public static void goswimming(Swimming swimming){
        swimming.swim();
    }
}
interface Swimming {  // 要求必须为接口实现
    void swim();  // 只能有一个抽象方法
}

带参无返回值

public class lambda2 {
    public static void main(String[] args) {
        useStringHandler(new StringHandler() {
            @Override
            public void pringMessage(String msg) {
                System.out.println("new匿名内部类 " + msg);
            }
        });
        useStringHandler((String msg) -> {
            System.out.println("lambda传参 " + msg);
        });
    }
    public static void useStringHandler(StringHandler stringHandler) {
        stringHandler.pringMessage("默认值");
    }
}
interface StringHandler {
    void pringMessage(String msg);
}

带返回值的lambda表达式

必须return

import java.util.Random;
public class lambda3 {
    public static void main(String[] args) {
        useRandomNumHandler(() -> {
            Random r =new Random();
            int num = r.nextInt(10)+1;
            return num;
        });
    }
    public static void useRandomNumHandler(RandomNumHandler randomNumHandler){
        int result = randomNumHandler.getNumber();
        System.out.println(result);
    }
}
interface RandomNumHandler{
    int getNumber();
}

带参与带返回值

public class lambda4 {
    public static void main(String[] args) {
        useCalculator(( a , b) -> a+b);
    }
    public static void useCalculator(Calculator calculator){
        int result = calculator.calc(10,20);
        System.out.println(result);
    }
}
interface Calculator{
    int calc(int a,int b);
}

5.1. lambda表达式的省略

参数类型可以省略,但有多个不同的参数类型时不能省略
如果参数只有一个,则小括号可以省略,没有参数则不能省略必须书写()
如果代码块的语句只有一条,可以省略大括号和分号甚至是return语句
m m,kkhj ;bnhjuo9p[‘inmji0op];[
khJU <KINM]’编译之后会生成一个单独的.class文件
lambda表达式:编译之后，不会生成.class文件，对应的字节码会在运行时动态生成

计算机从入门到入土