Lambda和Stream流——Lambda表达式

内部类

内部类根据在类中的位置不同分为三种

1. 成员内部类： 在类的成员位置
2. 局部内部类： 在方法中
3. 匿名内部类： 在方法中，是一种简化的写法

成员内部类

public class Outer{
    //成员变量
    int num=10; 
    
    //成员内部类
   	public class Inner{
        //内部类的，成员变量
        int num=20;
        //内部类的，成员方法
        public void show(){
            int num=30;
            System.out.println(num); //30
            System.out.println(this.num); //20
            System.out.println(Outer.this.num); //10
        }
    } 
}

public class Demo1{
    public static void main(String[] args){
        Outer.Inner  inner = new Outer().new Inner();
        inner.show();
    }
}

局部内部类(了解)

局部内部类是定义在方法中的类，只能在方法中使用，局限性很强。所以一般不会使用。

public class Outer{
    //Outer类中的show方法
    public void show(){
        int num=10; //局部变量，只在方法中有效

        //局部内部类，只在方法中有效
        class Inner{
            public void inShow(){
                System.out.println("in...show");
            }
        }
        
        new Inner().inShow(); 
    }
}

匿名内部类(掌握)

匿名内部类实际开发的时候还是使用的特别多的

1.前提: 需要有一个接口或者抽象类
2.格式：
	new 接口/抽象类(){
		复写抽象方法
	}
3.本质：匿名内部类本质上是一个抽象类/接口的子类对象

public interface Usb {
    public void powerOn(); //通电
    public void loadDriver(); //加载驱动
    public void run(); //运行
} 

public class Computer {
    //使用接口的功能
    public void useUsb(Usb u){
        u.powerOn();
        u.loadDriver();
        u.run();
    }
}

public class Demo2 {
    public static void main(String[] args) {

        Computer com=new Computer();

        //调用方法，传递匿名内部类
        com.useUsb(new Usb() {
            @Override
            public void powerOn() {
                System.out.println("鼠标通电");
            }

            @Override
            public void loadDriver() {
                System.out.println("加载鼠标驱动");
            }

            @Override
            public void run() {
                System.out.println("鼠标运行");
            }
        }); 
    }
}

JDK8的新特性

Lambda表达式

Lambda表达式是函数式编程的一种体现，它可以简化匿名内部类的代码书写。

Lamdba表达式的使用步骤
	1.必须要有一个函数式接口
		当接口中只有一个抽象方法，这样的接口叫做函数式接口
	
	2.有一个方法，把函数式接口作为参数
	
	3.调用方法，传递Lambda表达式作为函数式接口的实现方式。

Lambda表达式案例

//1.定义一个函数式接口，只有一个抽象方法
@FunctionalInterface
public interface Animal {
    public void eat(String food);
}

public class Demo3 {
    public static void main(String[] args) {

        //匿名内部类写法
        method(new Animal() {
            @Override
            public void eat(String food) {
                System.out.println("狗在吃" + food);
            }
        });

       //Lambda标准规格
        method((String food) -> {
                System.out.println("狗在吃" + food);
            }
        );

        //Lambda省略数据类型
        method((food) -> {
                    System.out.println("狗在吃" + food);
                }
        );

        //Lambda省略小括号，参数只一个的情况下
        method(food -> {
                    System.out.println("狗在吃" + food);
                }
        );

        //Lambda省略小括号，参数只一个的情况下
        //Lambda省略大括号，方法体只有一条语句
        method(food -> System.out.println("狗在吃" + food)); 
    }

    //2.把接口作为方法的参数
    public static void method(Animal a) {
        a.eat("骨头");
    }

}

Lambda表达式的格式

1.标准格式：
	(数据类型1 参数1, 数据类型2 参数1)->{ 语句体 return 返回值; }

2.省略数据类型
	(参数1, 参数1) -> { 语句体 return 返回值; }

3.参数只有一个时，可以省略()
    参数 -> { 语句体 return 返回值; }

3.当语句体只有一条语句时，可以省略{}
    参数 -> 语句体

JDK8对接口更新

public interface Inter {
    //抽象方法
    public abstract void show1();

    //JDK8之后，允许在接口中写默认方法(default修饰的方法)
    public default void show2(){
        System.out.println("Inter...show2");
        show4();
    }

    //JDK8之后，允许在接口中写静态方法
    public static void show3(){
        System.out.println("Inter...show3");
    }

    //JDK9之后，允许在接口中写私有方法
    private void show4(){
        System.out.println("Inter...show4");
    } 
}