2021.01.11第一阶段06

一、接口

（一）接口的概述
1、广义：一切定义规则的都是接口
2、狭义：Java中用于定义方法声明的就是接口
在Java的接口中，定义的都是抽象方法，只有方法的声明，没有方法的实现
3、好处：解耦合
将方法的调用和方法的实现拆分开了
（二）接口的特点
1、定义格式：
interface 接口名 {
抽象方法
}
2、接口中，只能定义抽象方法，不能定义非抽象方法
3、接口在编译过后，也会生成一个【.class】文件
4、接口无法实例化，可以使用类来实现接口，类创建对象
5、类实现接口：使用关键字implements
class 类名 implements 接口名 {
实现接口中的抽象方法
}
6、实现类的前途：和抽象类的实现子类前途一样
（1）当类没有完全实现接口中的所有抽象方法时，就是一个抽象类，需要继续使用子类来实现
（2）当类完全实现了接口中的所有抽象方法，就是一个普通类，就可以创建对象调用方法
（三）接口的成员特点
1、接口中不能定义变量，只能定义常量，并且可以省略public static final ，建议手动加上
2、构造方法：接口中没有构造方法，因为构造方法是给成员变量赋值的，但是接口中不能有成员变量，
所有也就没有构造方法
3、成员方法：只能是抽象方法，可以省略public abstract ，但是建议手动加上
（四）类与类、类与接口、接口与接口之间的关系
1、类与类：继承的关系，使用extends关键字。Java类支持单继承，不支持多继承，支持多层继承
2、类与接口：实现关系，使用关键字implements
（1）一个类，可以实现一个或者多个接口
class 类名 implements 接口1, 接口2, …, 接口n {
重写所有接口中的所有抽象方法
}
这种写法不会有安全隐患，因为虽然多个接口中有同样的方法声明，但是在类中只有一个方法实
现，不会 有冲突
（2）一个类，在继承一个类的同时，还能实现多个接口
class 类名 extends 类名 implements 接口1, 接口2, …, 接口n {
重写所有接口中的所有抽象方法
}
3、接口与接口：继承的关系，使用extends关键字。Java接口支持单继承，支持多继承，支持多层继承
4、类和接口的使用场景：
（1）类：用于定义事物的固有属性和行为
（2）接口：用于定义通过学习、或者训练、或者扩展而来的行为

二、代码块

（一）概述
1、使用大括号将一段代码包围起来。根据书写的位置不同，具有不同的功能和不同的名称，也有不同的
执行时机。
2、分类：
（1）局部代码块
（2）构造代码块
（3）静态代码块
（二）局部代码块
1、格式：直接使用大括号包围起来一段代码
2、位置：方法内
3、作用：用于限定变量作用域和生命周期。变量定义在哪个大括号内，只能在哪个多括号内起效，出了
大括号就无法使用了，就会被当做垃圾回收，节约系统内存。
（三）构造代码块
1、格式：直接使用大括号包围起来一段代码
2、书写位置：类中方法外
3、执行时机：随着对象的创建而被调用
4、作用：可以为成员变量赋值，也可以书写所有构造方法中都要执行的内容
5、总结：
（1）在创建对象的过程中，由JVM自动调用
（2）在构造方法执行前执行
（3）构造代码块在每一个构造方法执行之前都会执行
（4）针对同一个对象，构造代码块只能被调用一次
（四）静态代码块
1、书写格式：
static {
静态代码块的内容
}
2、书写位置：类中方法外
3、作用：
（1）可以为静态变量赋值
（2）可以书写一些只执行一次的代码，例如加载驱动
4、执行特点：
（1）随着类的加载而加载
（2）类只加载一次，所以静态代码块也只执行一次
（3）执行时机最早：优先于所有对象存在
5、规律总结：静态代码块也是类的一个静态成员，所以，对于类而言，就和静态变量等具有相同的性质

三、内部类

（一）内部类的概述
1、定义在类的内部的类，就是内部类。可以定义在方法的内部，也可以定义在类的内部。
2、根据定义位置的不同，可以分为：
（1）成员内部类
（2）局部内部类
3、成员内部类：
（1）普通成员内部类
（2）私有成员内部类
（3）静态成员内部类
4、局部内部类
5、按照名称划分：
（1）有名字的内部类
（2）【匿名内部类】
（二）普通成员内部类
1、概念：定义在类成员位置的一个类，就是成员内部类
2、定义格式：
class 外部类名 {
外部类成员
class 内部类名 {
内部类成员
}
}
3、成员内部类的说明：
（1）在内部类中，可以访问外部类的所有成员，包括私有成员
（2）在外部类中，访问内部类的成员，需要创建内部类对象，通过对象来访问
static {
System.out.println(“静态代码块执行了”);
}
public static void test() {
System.out.println("=============");
}
}
（3）在外部类以外，访问内部类的成员，可以创建外部类对象，外部类对象调用外部类方法，方法中
使用内部类对象，调用内部类成员，从而达成间接访问
（4）在外部类以外创建内部类的对象：外部类名.内部类名 标识符 = new 外部类名().new 内部类名();
（三）私有成员内部类
1、也是一个成员内部类，只是在普通成员内部类的基础上加上了private关键字修饰
2、访问方式：
（1）私有成员内部类中可以访问所在外部类的所有成员
（2）外部类中可以访问私有成员内部类的所有内容，但是需要创建内部类对象
（3）在外部类以外无法直接创建内部类的对象，只能通过间接的方式访问。间接方式：创建外部类对
象，外部类对象调用外部类的方法，方法中内部类对象调用内部类成员
（四）静态成员内部类
1、也是一个成员内部类，只是在普通成员内部类的基础上加上了static关键字修饰
2、访问特点：
（1）成员内部类是外部类的静态成员，可以通过类名直接调用的方式来访问内容，不需要创建对象
（2）静态成员内部类中的非静态成员，需要使用对象来调用
（3）如果在外部类之外，访问内部类的非静态成员，要创建内部类对象：
外部类名.内部类名 标识符 = new 外部类名.内部类名();
（4）如果在外部类之外，访问内部类的静态成员，可以直接外部类名.内部类名.内部类的静态成员
3、注意：一个类，是否需要创建对象来访问成员，不取决于类是不是静态，取决于被访问的内容是不是静态
（五）局部内部类
1、定义在方法中的类
2、局部内部类说明：
（1）方法的局部变量可以被内部类访问
（2）内部类的成员想要在方法中访问，需要先创建内部类对象
（3）额外的，内部类的对象书写位置，必须写在类之后，因为方法执行的时候，内容按照顺序执行，
先有类，后有类的对象
（4）由于方法的内容，外界没有任何办法访问到，所以外界没有任何手段可以创建局部内部类的对
象，如果想要在方法之外访问内部类成员，只能执行方法，方法内创建内部类对象来访问，从而达成间
接访问
（六）【匿名内部类】
1、匿名内部类，没有名字的类
2、使用前提：
（1）实现接口
（2）实现抽象类
3、定义格式：
new 接口名或者抽象父类类名() {
重写接口或者是抽象父类中的抽象方法
};
4、本质：就是一个对象，是接口的实现类对象，或者是抽象类的实现子类对象；编译过后生成一个【.class】文件
5、内部类编译后【.class】文件名称规律：
（1）成员内部类：外部类名$内部类名（2）局部内部类：外部类名$序号内部类名，其中序号从1开始
（3）匿名内部类：外部类名$序号，序号从1开始