01_接口、内部类、Lambda表达式

1、接口

1.1 接口的概述

1.1.1 接口的概述

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用

接口存在的意义：用来定义规范 用来做功能的拓展

1.1.2 接口的特点
接口用关键字 interface 修饰：public interface 接口名{ }
类实现接口用 implements 表示 ：public class类型 implements 接口名{ }
接口不能实例化：通过创建接口的实现类对象使用
接口的子类：要么是抽象类，要么重写接口中的所有抽象方法

1.1.3 接口的成员特点

成员变量：静态常量	
构造方法：无构造方法
成员方法：只能是抽象方法，默认修饰符->	public abstract 方法名();

1.1.4 类和接口的关系
类与类：可以是单继承，也可以是多层继承
类与接口：可以是单实现，也可以是多实现，还可以继承一个类的同时实现接口
接口与接口：可以单继承，也可以多继承

1.2 接口组成更新

1.2.1 接口组成更新概述

常量：public static final 变量名；
抽象方法：public abstract 方法();

默认方法：

public default 返回值类型 方法名(参数列表) { }
作用：解决接口升级

注意事项：
默认方法不是抽象方法，不强制重写， 但是可以被重写，重写的时候去掉abstract
public 可以省略，abstract不能省略
如果实现了多个接口，多个接口存在相同的方法声明，子类必须对该方法进行重写

静态方法：

格式：public static 返回值类型 方法名( 参数列表 ){ 方法体 }

注意事项：
静态方法只能通过接口名调用，不能通过类名或者对象名调用
public可以省略，static不能省略	

私有方法：

注意事项：
默认方法可以调用私有的静态方法和非静态方法
静态方法只能调用私有的静态方法

public class InnerClass {
    public static void main(String[] args) {
        Student.method();
        Student.method1();
    }

}
//接口
interface Student{
    private static void method3(){
        System.out.println("hello");
    }
    static void method1(){
        method3();
        System.out.println("this is Tim");
    }

    static void method(){
        method3();
        System.out.println("this is Bob");
    }
}

2、内部类

2.1 概述

在一个类中，定义一个类

2.2 内部类的访问特点

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

代码示例：
public class InnerClass {
    public static void main(String[] args) {
        //创建内部类对象
        Animal.Dog dog  =new Animal().new Dog();
        System.out.println(dog.age);
    }
}

class Animal{
    //内部类
    public class Dog{
         int age = 23;
    }
    public void eat(){
        System.out.println("eat fish");
    }
}

2.3 内部类的分类

2.3.1 私有成员内部类

public class InnerClass {
    public static void main(String[] args) {
        //创建内部类对象
        Outer outer =new Outer();
        outer.method();
    }
}

class Outer{
   
    private int age = 24;
    //创建私有内部类
    private class Inner{

         public void method(){
             System.out.println(age);
         }
    }
    //通过创建对象访问私有内部类
    public void method(){
       Inner inner = new Inner();
       inner.method();
    }
}

2.3.2 静态内部类

public class InnerClass {
    public static void main(String[] args) {
        //创建内部类对象
        Outer.Inner inner =new Outer.Inner();
        inner.show();
        Outer.Inner1.show();
    }
}

class Outer{
    //创建静态内部类
    static class Inner{
         public void show(){
             System.out.println("Inner...show...");
         }
    }
    static class Inner1{
        static void show(){
            System.out.println("Inner1...show...");
        }
    }
    //通过创建对象访问私有内部类
    public void method(){
        System.out.println("Outer...method...");
    }
}

2.3.3 局部内部类

public class InnerClass {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }
}

class Outer {
    private int num = 10;

    public void method() {
        int num2 = 20;

        class Inner {
            public void show() {
                System.out.println(num);
                System.out.println(num2);
            }
        }

        Inner inner = new Inner();
        inner.show();
    }
}

2.3.4 匿名内部类

匿名内部列的前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

匿名内部类的格式：

new Inner(){
	@Override
	public void method(){
	
	}
}

匿名内部类的本质：一个继承了该类或者实现了该接口的子类匿名对象
匿名内部类的细节：匿名内部类可以通过多态的方式接收

public class InnerClass {
    public static void main(String[] args) {
        //匿名内部类作为参数
        useSwim(new Swim() {
            @Override
            public void swimming() {
                System.out.println("铁汁，我们去游泳吧");
            }
        });
    }

    public static void useSwim(Swim swim){
        swim.swimming();
    }
}

//接口
interface Swim{
    void swimming();
}

3、Lambda表达式

函数式编程思想概述
忽略面向对象的复杂语法：“强调做什么，而不是怎么去做”

3.1 Lambda表达式的标准格式

(参数列表) -> {代码块}

3.2 Lambda表达式 的使用前提

有一个接口，有且只有一个抽象方法

3.3 Lambda表达式的缺省模式

参数类型可以省略，但是有多个参数的情况下，不能只剩一个
如果参数有且仅有一个，那么小括号可以省略
如果代码块的语句只有一条，可以省略大括号和“；”号，和return关键字

3.4 Lambda表达式和匿名内部类的区别

a.所需类型不同：

匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
Lambda表达式：只能是接口

b.使用限制不同：

如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
如果接口中多余一个抽象法，只能使用内部类，而不能使用Lambda表达式

c.实现原理不同：

匿名内部类：编译之后产生一个单独的.class字节码文件；
Lambda表达式：编译之后，没有一个单独的.class字节码文件，对应的字节码会在运行的
时候动态生成	

3.5 代码示例

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

        //无参无返回值构造方法
        useEatable(() -> System.out.println("eat rice!"));

        //有参无返回值构造方法
        useDrinkable(a -> System.out.println("Drink "+a));

        //有参有返回值
        useCalculate((a,b) -> a*b);
    }

    public static void useEatable(Eatable eatable){
        eatable.eat();
    }

    public static void useDrinkable(Drinkable drinkable){
        drinkable.drink("water");
    }

    public static void useCalculate(Calculate calculate){
        int result = calculate.cal(10,20);
        System.out.println(result);
    }
}

//无参无返回值
@FunctionalInterface
interface Eatable{
    void eat();
}

//有参无返回值
interface Drinkable{
    void drink(String s );
}

//有参有返回值
interface Calculate{
    int cal(int a ,int b);
}