内部类

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

如:

public class A{

	public class b{

	}

}

内部类的访问特点

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

成员内部类

如是公共则可以创建对象

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

局部内部类

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

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

匿名内部类

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

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一个匿名内部类");
            }
        });

lambda 表达式

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

使用 lambda 表达式的前提

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

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

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);
}

lambda 表达式的省略

• 参数类型可以省略，但有多个不同的参数类型时不能省略

• 如果参数只有一个，则小括号可以省略，没有参数则不能省略必须书写 ()

• 如果代码块的语句只有一条，可以省略大括号和分号甚至是 return 语句

• m m,kkhj ;bnhjuo9p['inmji0op];[

• khJU <KINM]' 编译之后会生成一个单独的.class 文件

• lambda 表达式：编译之后，不会生成.class 文件，对应的字节码会在运行时动态生成