接口（interface）

接口（interface）

接口代表了某种能力，类似于生活中的合同，而在接口定义的各个方法，表示了这个能力的具体的要求，类似于合同中的条款

接口中可以定义：

属性：公开静态属性

方法：公开抽象方法

特点：

一般接口中不写成员变量，只写方法，所以又将接口称为方法列表

接口的作用：

让java从单继承间接实现了多继承，扩充了原来的功能，我们可以认为接口是类的补充

接口和抽象类的异同：

相同：

1.都可以编译成字节码文件

2.都不能创建对象

3.都可以声明引用

4.都具备Object类中定义的方法

5.都可以写抽象方法

不同点：

1.接口中所有的属性，都是公开静态常量，缺省使用public static final修饰

2.接口中所有的方法，都是公开抽象方法，缺省使用public abstract修饰

3.接口中没有构造方法，构造代码段，静态代码段

接口的实现：

1.接口，需要让类实现，表示这个类具有了这个接口定义的能力。因为接口中有很多抽象方法，因此类在实现接口时，如果不是抽象类，必须要重写实现接口中所有的抽象方法。

2.我们使用接口进行行为的约束，规则的制定，接口表示了一组能力，那么一个类可以接受多种能力的约束，因此，一个类可以实现多个接口，实现多个接口的时候，必须把每一个接口中的方法都实现了（如果一个类实现的多个接口中，有相同的方法，实现类只需要实现一次即可）（如果两个接口中定义了两个同名，同参的方法，但是返回值不相同，那么类是没有办法同时实现这两个接口的。因为在同时实现的时候，无法最终确定这个方法的返回值类型）。

接口的继承：

1.接口之间也存在着继承关系，与类的继承相似，子接口可以继承父接口中的所有方法

2.与类的继承不同，接口之间的继承是多继承，也就是说，一个接口是可以有多个父接口的，子接口可以继承到所有父接口中的成员

3.一个类实现多个接口的时候，多个接口中不能存在有冲突的方法（方法名，参数列表相同，返回值不同），接口在继承父接口的时候，也不允许同时继承两个有方法冲突的接口

父类与接口：

一般父类中放的是主要功能，接口中放的是额外的功能，接口作为父类的补充

接口的多态：

接口的引用指向实现类的对象，称之为接口的多态

与类的多态相似，同样存在着向上转型和向下转型：

1.向上转型：

是一个隐式转换，不需要任何的修饰

向上转型后的接口引用，只能访问接口中的成员

向下转型

是一个显示转换，需要强制类型转换

向下转型后的实现类引用，可以访问实现类中的成员

多态体现：

与类相同，向上转型后的接口的引用，调用接口中的方法的时候，实际调用的是实现类中的重写实现

接口的新特性：

1.static方法：可以在接口中定义静态方法，静态方法不是抽象方法，是有实现部分的，同时，这个静态方法，只能由当前的接口名字调用，接口的引用和实现类都是不能使用的

2.default方法：修饰接口中的方法，default修饰的方法可以添加默认的实现部分。此时，实现类在实现接口的时候，对于这些方法可以重写，也可以不重写

内部类

1.成员内部类：

概念：

定义在一个类内部的类，内部类的地位和外部类的成员变量，成员方法平等，内部类也可以看作是外部类的成员，成员之间可以相互调用

使用：

外部类的一个成员部分，创建内部类对象时，必须依赖外部类对象

Outer outer = new Outer();

Inner inner = outer.new Inner();

Outer.Inner inner = new Outer().new Inner();

特点：

书写位置：与属性，方法平级别，且没有使用static修饰的类

访问权限：内部类可以是任意的访问权限

成员内部类中，不可以写静态属性，静态方法

编译生成的字节码文件格式：外部类$内部类.class

实例化对象：需要借助外部类的对象完成

2.静态内部类：

概念：

在类的内部定义，与实例变量，实例方法同级别，使用static修饰的类

使用：

不依赖外部类对象，可以直接创建或通过类名访问

Outer.Inner inner = new Outer.Inner();

特点：

书写位置：和类中的属性，方法评级，且使用static修饰

静态内部类中，可以写属性，方法，构造方法

静态内部类中，可以写静态属性，方法

编译之后生成的字节码文件，格式：外部类$内部类.class

对象的实例化，不需要借助外部类对象

3.局部内部类：

概念：

定义在外部类的方法中，作用范围和创建对象范围仅限于当前方法

特点：

局部内部类访问外部类当前方法中的局部变量时，因为无法保障变量的生命周期与自身相同，所以必须修饰为final

不能使用访问权限修饰符修饰

书写位置：写在一个类的方法的内部，作用域仅限于当前方法

局部内部类，编译之后生成的字节码文件格式：外部类$序号内部类名.class

作用：

通过局部内部类实现了功能的私有化，并对方法内部的代码进行了整理，增强了代码的可读性和可操作性

final：被final修饰的变量会被放在常量区，而常量区的值存在的时间要大于局部变量所在的方法，相当于从原来的基础上扩大了作用域
当方法中同时存在局部内部类和局部变量时，局部变量的使用范围就会从原来的基础上进行扩大

4.匿名内部类：

概念：

匿名内部类（对象）：定义在一个类的方法中的匿名子类对象，属于局部内部类

特点：

一切特征局部内部类相同

必须显式地继承或者实现一个接口

定义类，实现类，创建对象的语法合并，只能创建一个该类的对象

作用：

当只用到当前类的一个实例对象的时候，定义好马上使用，使用完立刻释放

与重载由相似之处，可以方便程序员的开发压力

可以更好的定义运行时的回调

创建：

第一种方式：使用已有的子类创建匿名子类对象

使用场景：已经创建好的子类可以多次使用，适合于相同的功能被多次调用

第二种方式：直接使用父类或者接口创建匿名子类对象

构成： new + 父类的名字/接口的名字 + ()+{写当前类的成员} + ;
使用场景：只能使用一次，使用完会被当作垃圾回收，适合于每次都使用不同的功能

内部类的作用：

1.间接实现了多继承

2.方便定义

3.只有外部类可以访问创建的内部类的属性和方法，包括私有方法

4.同一个包中其他的类不可见，有很好的封装性

接口回调：

package bk.java.p522;
/*
情景一：
老师让小明做作业

情景二：
老师让小明做作业，小明不可能立马就做完，于是老师让小明做完之后，告诉他一声

所谓回调：就是类A调用了B的方法，类B在方法执行的过程中会回过头去调A的方法，即
A --> B -->A

情景三：
小明作业很多，语文老师，数学老师，英语老师都想叫小明做作业，并且都需要小明做完作业后告诉他们
 */
public class demo18 {
    public static void main(String[] args){
        //首先要创建干活的对象--->小明
        Student student = new Student();
        //其实创建老师，叫小明去做作业
        new Teacher1(student);
        new Teacher2(student);
    }

}
//要交作业的是小明
class Student{
    public void doHomework(Teach teach){
        System.out.println("做作业");
        teach.call();
    }
}
interface Teach{
    public abstract void call();
}

//这是语文老师
class Teacher1 implements Teach{
    public Teacher1(Student student){
        student.doHomework(this);
    }
    public void call(){
        System.out.println("语文做完了");
    }
}
//这是数学老师
class Teacher2 implements Teach{
    public Teacher2(Student student){
        //但是由于学生类中的doHomework中的方法已经被定义好了，那我这里的参数根本传不进去，
        //第一种解决办法：创建许多类，每个类中都有各自的方法，方法中的参数并不一样，但是这将随着实现类的的增加，而需要写无数个干活的类（显然不可取）
        //第二种解决办法：写一个接口，所有的实现类都实现这个接口，因为接口的多态，我只需要写一个干活的类，我里面装的参数不再是类，而是接口
        student.doHomework(this);
    }
    @Override
    public void call() {
        System.out.println("数学作业做完了");
    }
}

//class Teacher{
//    public Teacher(Student student){
//        student.doHomework();
//        System.out.println("好的");
//    }
//}
做作业是学生的任务
//class Student{
//    public void doHomework(){
//        System.out.println("我做完了");
//    }
//}
//
//class Teacher1{
//    public Teacher1(Student student){
//        student.doHomework(this);
//    }
//
//    public void call(){
//        System.out.println("报告老师，我作业做完了");
//    }
//}
//
做作业是小明的事情
//class Student{
//    public void doHomework(Teacher1 teacher1){
//        System.out.println("做作业");
//
//        //那我做完之后，需要告诉老师，我做完了
//        teacher1.call();
//    }
//}