[Java]归纳整理

基础知识介绍

1.环境

JDK (JAVA 开发工具包)
JRE（java运行时环境）
JVM (java虚拟机): 源代码文件： XXX.java ---> 经编译器compiler编译 ---> 字节码文件：XXX.class --->
经解释器interpreter解释翻译（jvm就有解释器） ---> 就能执行My Program

JDK安好后，就有JRE，JRE里也包含有JVM

2.使用记事本编辑XXX.java ---> 使用javac命令编译器编译成XXX.class（javac xxx.java） ---> 使用java命令解释器解释(java xxx)（java 命令后不能跟文件后缀） ---> 执行

使用eclipse开发

eclipse是ide工具 ide：集成开发环境（IDE）是一类软件，将程序开发环境和程序调试环境集合在一起，提高开发效率。还有MyEclipse，NetBeans

1.创建java项目 （会生成包）
2.创建程序包 （源代码文件在包下）
3.编写java源程序
4.运行java程序

3、public static void main(String [] args)是程序的入口。

4、java可有多个main()文件，但只有与文件名相同的用public修饰的类的main()才能作为程序的入口。注：有且仅有一个类被public修饰并与文件同名。

5、静态快在main函数之前执行。初始化执行顺序：父静态变量 父静态代码块 子静态代码变量 子静态代码块 父非静态变量 父非静态代码块 父类构造函数 子非静态变量 子非静态代码块 子类构造函数

6、构造函数：

1)与类同名，无返回值

2)可以有多个，根据参数不同

3)总是伴随new操作一起调用

4)主要用来初始化对象

5)不能被继承

6)可用super来显示调用父类构造函数

7、浅复制仅仅复制考虑的对象，不复制它引用的对象。深复制两者都复制

8、面向对象和面向过程有什么不同：

1)面向对象是用符合常规思维的方式去处理客观世界的问题，面向过程是则重以事件为中心，模块化。

2)面向对象是使计算机世界向客观世界靠拢，使问题的处理更清晰。面向过程是清晰准确表达过程的模块，把客观世界的问题抽象成计算机可以处理的过程。

9、面向对象的特征和优点：抽象 继承 封装 多态有较高的开发效率，代码可重用。较高的可维护性，代码更清晰明了。

10、java只支持单根继承，extends继承是 is a 关系，组合是 has a关系。

在java语言中能用到组合的尽量不要用继承。

11、多态：

重载（同个类中有多个同名方法） 水平关系

重写（子类重写父类，方法名和参数列表相同） 垂直关系

12、抽象类和接口的异同：

1)只要包含一个抽象方法都是抽象类，接口的方法全部是抽象方法，称为纯抽象类。

2)抽象类的子类需实现父类的抽象方法。

3)接口中的变量都默认为：static final 必须赋初值。

4)接口实现用implements。一个类可以实现多个接口实现类似多继承的关系。

5)接口被运用于常用的功能，如：添加删除。抽象类用于生活公共类的角色，不适用经常对代码修改的情况

13、this和super的区别：

This用来指向当前实例对象

Super用来访问父类的方法和成员变量

子类继承父类时，子类构造函数中super（）必须放第一句。

14、break continue return 的区别：

Break 用于直接强行跳出当前循环，不执行剩余代码

Continue 用于停止当次循环，回到起始处进行下次循环。

Return 跳转 用来表示从一个方法中返回。

Break out跳出多重循环

15、static的作用：

a 为对象分配单一的存储空间，与创建对象个数无关

b 实现某个方法或属性和类而不是与对象关联在一起

C 变量可达到全局的效果，在内存中只有一个复制

16、不可变类的实现：

类中的所有成员变量被private修饰

没有写set方法

类定义final

17、值传递和引用传递的区别:

值传递：实参会把它的值传递给形参

引用传递：传递的是对象，形参和实参指向同个存储单元。

18、有八种基本数据类型，类型转换的优先级：byte不能与booleam互换。

19、round 表示四舍五入 ceil表示向上取整 floor表示向下取整，i++表示先执行后加

一，++i表示先加一后执行。

20、String s1=”abc”是存放在常量区

String s2=”abc”s2应用常量区的对象，不会创建新的对象。

String s3=new String（“abc”）是在堆中创建对象，

String s4=new String（“abc”）又必须在堆中创建新对象。

21、“==”与“equals”

“==”用来比较两个变量的值是否相等，如果一个变量指向饿数据是对象（引用类型），就有两块内存。对象本身占用一块内存（堆内存），变量也占用一块内存。String s4 = new String（“abc”）。变量s所对应的内存中存储的数值就是对象占用那块内存的首地址。如果想看两个变量是否指向同一个对象，即要看他们对应内存中的数值（首地址）是否相同。

equals比较的不是引用，而是数值内容，即比较的是abc。

22、数组也是对象。数组提供length属性来获取数组的长度，而String是通过length()计算。

23、异常处理

1）try catch finally模式

2）Finally块中的代码一定会被执行，除非这两种情况：当程序在try之前就遇到异常或者在try中通过exit（）强制退出。

3）jvm将错误表示为一个异常并抛出，通过catch来捕获，然后进行处理。安全性和鲁棒性。

4）异常分为两大类：错误（error）和异常（Excetion）

异常分为：检查异常和运行异常。

检查异常又称为编译异常。

比如：IO异常、SQL异常

运行异常为：空指针异常、类型转换异常、算术异常、数组越界异常、数组存储异常、缓存区溢出异常。

先捕获子类后捕获父类，尽早抛出异常，能处理就处理，不处理就抛出，运行时异常实际不必处理，直接抛出。

24、Java IO：字节流（8位）不会用到缓存 字符流（16位）用到缓存

25、Socket称为套接字。用来实现不同虚拟机或不同计算机之间的通信。

分为两种类型：面向连接的TCP,可靠。无面向连接的UDP，不可靠。

任何一个Socket都是由一个IP地址和端口号唯一确定。

26、java平台独立性是指一个平台上编写和编译程序，而在其他平台上运行。有JVM和java API。

Java语言是一种动态解释型语言，类class只有被加载到JVM上才能运行。不会一次加载全部类后执行，而是先加载基类，其他类是需要时再加载。

27、垃圾回收GC：回收不会再使用的内存。三个任务：分配内存；确保被引用的内存不被错误地回收；回收不再被引用的对象的内存。

28、java中内存泄露问题：

两种情况：

1）在堆中申请的空间没有得到释放

2）对象不再被使用，但是仍在内存中保留着

原因：静态集合类、各种连接、监听器、变量不合理的作用域

29、java中堆和栈的区别：

分配在栈：基本数据类型的变量、对象的引用变量

变量出了作用域就会被自动释放

分配在堆：引用类型变量、需要通过new创建的变量。主要为运行时创建的对象

JVM是基于堆栈的虚拟机，每个java程序都运行在一个单独的JVM实例上，所以一个java程序中的对个线程运行在，每个实例又唯一对应一个堆，所以这些线程之间会共享堆内存。

只需要申请堆空间，不需要考虑释放问题。

使用栈中的引用变量来访问堆中的数组和对象。

堆只要是用来存放对象的，栈主要是用来放执行程序的。

栈的速度快，但大小和生存期确定，缺乏灵活性。堆是动态分配内存，灵活性强但速度慢。

30、容器：java Collections框架：list 、Queue 、set 、stack 、map
list 、Queue 、set 、stack都继承Collection接口。

1）List是有序的Collection。按对象的进入顺序保存对象，可保存重复对象。

2）Set是集合的概念，集合中不能有重复的元素。

3）map是键映射到值得数据结构。值可以重复，但是键是唯一的，不能重复。

31、迭代器：是一个对象，一种访问一个容器对象的各个元素，而又不必暴露该对象内部的细节方法。

1）使用容器的iterator()方法返回一个Iterator，然后通过Iterator的next（）方法返回一个元素。

2）使用Iterator的hasNext（）方法判断容器中是否还有元素，如果有可以使用next()获取下一个元素。

3）通过remove()来删除迭代器返回的元素。

32、collection和collections的区别：

Collection：是一个集合接口，为各个具体集合提供最大化的统一操作。

Collections：是针对集合类的一个包装类。不能实例化，相当于一个工具类，服务于Collection框架。

33、多线程：

线程：执行代码的一个执行单元。

进程：一个正在执行的程序

各线程共享程序的内存空间（代码段、数据、堆空间）有独立的栈空间。

线程优点：

1）减少程序的响应时间

2）相比进程，创建个切换开销小

3）多CPU和多核本身就具有多线程能力

4）简化程序结构，便于理解和维护。

34、如何实现java多线程：

1）继承Thread类，重写run()方法

2）实现Runnable接口，并实现接口的run（）方法。

3）实现Callable接口，重写call()方法。

35、同步

要想实现同步操作，必须获得每个线程对象的锁，获得它可以保证同一时刻只有一个线程能够进入临界区，并且在这个锁被释放之前，其他线程就能再进入临界区，如果还有其他线程想要获得该对象的锁，只能进入等待队列等待。

36、多进程同步的实现方法：

1）synchronized关键字

2）Wait（）方法与notify（）方法

3）Lock

37、终止线程的方法：stop()方法与suspeng()方法。

Java提供两种线程：守护线程（服务进程）、用户进程。

38、如何通过JDBC来访问数据库：

1）加载JDBC驱动器，将JDBC驱动 jar包复制到lib下

2）加载JDBC驱动

3）创建数据库连接

4）建立Statement对象或是PrepareStatement对象。用于对数据库操作

5）执行SQL语句

6）访问结果集ReaultSet对象

7）依次关闭ReaultSet Statement Connection。

39、Class.forName（）方法的作用是把类加载到JVM中。

在使用JDBC连接数据库之前，一般会调用Class.forName（“com.mysql.jdbc.Driver”）方法来加载驱动。
Statement用于执行不带参数的简单SQL语句，并返回它所生成结果的对象。每次执行SQL，数据库都会编译该SQL语句。
PrepareStatement可执行带参数的。效率更高，可读性，可维护性更高，安全性更好

40、JDBC提供了getString()、getInt()、getIData()等方法从ResultSet中获取数据。

41、在JDBC连接时连接池数目有限，所以一定要保证释放不再使用的连接。

createStatement和prepareStatement最好放在循环外面，而且使用statement后需要及时关闭。最好是执行一次executeQuery后马上关闭statement。

42、Hibernate是JDBC的封装。采用配置文件的形式将数据库的连接参数写到XML中，但
是最后对数据库的访问还是要通过JDBC来完成。

43、Hibernate是个持久层框架，它将表中的信息映射到XML中，再从XML文件映射到相应的持久化类中。

 

详细解释

 

如何定义 Java 中的方法
所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。

一般情况下，定义一个方法的语法是：

访问修饰符 返回值类型 方法名（参数列表）{
方法体
}

其中：

1、 访问修饰符：方法允许被访问的权限范围， 可以是 public、protected、private 甚至可以省略 ，其中 public 表示该方法可以被其他任何代码调用，其他几种修饰符的使用在后面章节中会详细讲解滴

2、 返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void ；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值

3、 方法名：定义的方法的名字，必须使用合法的标识符

4、 参数列表：传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开

Java 中方法的重载

问： 什么是方法的重载呢？
答： 如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法，则称为方法的重载，也可称该方法被重载了。如下所示 4 个方法名称都为 show ，但方法的参数有所不同，因此都属于方法的重载

问： 如何区分调用的是哪个重载方法呢？
答： 当调用被重载的方法时， Java 会根据参数的个数和类型来判断应该调用哪个重载方法，参数完全匹配的方法将被执行。

面向对象

类：类是模子，确定对象将会拥有的特征（属性）和行为（方法）。类的组成：属性和方法。
类的特点：类是对象的类型，具有相同属性的方法的一组对象的集合。

对象是具体实体

属性：对象具有的特征，有什么，每个对象的每个属性都拥有特定值。
方法：对象执行的操作，能干什么
所有java程序都以类class为组织单元

定义一个类的步骤

1.定义类名
2.编写类的属性
3.编写类的方法

public class 类名（首字母要大写）{

//定义属性部分
属性1的类型 属性1；
属性2的类型 属性2；

//定义方法的部分
方法1；
方法1；
}

使用对象步骤：

1.创建对象：

类名 对象名 =new 类名（）；
Telphone phone = new Telphone();

2.使用对象

引用对象的属性：对象名.n属性
phone.scree=5;给scree属性赋值5

引用对象的方法：对象名.方法名（）
phone.sendMessage(); 调用sendMessage（）方法

成员变量和局部变量

1.成员变量 在类中定义，用来描述对象将要有什么。 可被本类的方法使用，也可被其他类的方法使用。
2.局部变量 在类的方法中定义，在方法中临时保存数据。 只能在当前的方法中使用。

区别

作用域不同： 成员变量在整个类内都是可见的。
局部变量仅限于定义它的方法，限于方法的开始和方法的结束。

初始值不同： java会给成员变量一个初始值
java不会给局部变量赋予初始值

在同一方法中，不允许有同名局部变量；
在不同方法中，可以有同名局部变量

两类变量同名时，局部变量具有更高的优先级

构造方法
1.使用new+构造方法 创建一个新的对象
2.构造方法是定义在java类中的一个用来 初始化对象的方法
构造方法与类同名且没有返回值

就是可以创建对象，并可初始化对象的值
创建对象的时候就是执行的（无参的）构造方法

格式： public 构造方法名（）{
//初始化代码
}

当没有指定的构造方法时，系统会自动添加无参的构造方法
当有指定的构造方法时，无论无参还是有参，都不会自动添加无参的构造方法

构造方法也有重载

构造方法不但可以给对象的属性赋值，还可以保证给对象的属性一个合理的值

static使用之静态变量

大家都知道，我们可以基于一个类创建多个该类的对象，每个对象都拥有自己的成员，互相独立。
然而在某些时候，我们更希望该类所有的对象共享同一个成员。此时就是 static 大显身手的时候了！！

Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，
即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。
当然，鉴于他作用的特殊性更推荐用类名访问~~

使用 static 可以修饰变量、方法和代码块。

static使用之静态方法

与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。
其实之前我们一直写的 main 方法就是静态方法。
public static void print(){
}

1、 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。
如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。

2、 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量.

3、 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

 

Java 中的 static 使用之静态初始化块

 

Java 中可以通过初始化块进行数据赋值。如：

 

在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。
如果使用 static 修饰初始化块，就称为静态初始化块。

需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，
不能初始化普通的成员变量。

我们来看一段代码：

 

运行结果：

 

通过输出结果，我们可以看到，程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。
由于静态初始化块只在类加载时执行一次，所以当再次创建对象 hello2 时并未执行静态初始化块。

封装

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

好处：
只能通过规定的方法访问数据
隐藏类的实例细节，方便修改和实现

封装步骤：修改属性的可见性（设为private）--> 创建getter/setter方法（用于属性的读写）
--> 在getter/setter方法中加入属性控制语句（对属性值的合法性进行判断）

source 下的 Generate Getters and Setters可自动生成

就是隐藏属性，通过方法得到属性


java中的包

包名为全小写字母拼写
作用：管理java文件，解决同名文件冲突。用不同名的包来区分相同文件名的类

定义包：package 包名 必须放在java源程序的第一行，包名间用 . 隔开 eg：com.imooc.Myclass

系统中的包

java.(功能).(类)

java.lang.(类) 包含java语言基础的类
java.util.(类) 包含java语言中各种工具的类
java.io.(类) 包含java输入输出相关功能的类

通过import关键字，在某个文件使用其它文件中的类

import 包.子包.类
import 包.*（包下的全部文件）

java中的访问修饰符

访问修饰符：可以修饰属性和方法的访问范围

private 本类
默认 本类 同包
protected 本类 同包 子类
public 本类 同包 子类 其他

this关键字

this关键字代表当前对象
this.属性 操作当前对象的属性
this.方法 调用当前对象的方法

封装对象的属性的时候，经常会使用this关键字

什么是 Java 中的内部类

问：什么是内部类呢？
答：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！
答：内部类的主要作用如下：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

问：内部类有几种呢？

答：内部类可分为以下几种：

成员内部类
静态内部类
方法内部类
匿名内部类


Java 中的成员内部类

内部类中最常见的就是成员内部类，也称为普通内部类。

成员内部类的使用方法：

1、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，
如 public 、 protected 、 private 等

2、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

3、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，
即：内部类 对象名 = 外部类对象.new 内部类( );

4、 编译上面的程序后，会发现产生了两个 .class 文件

Java 中的静态内部类

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；
如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();
其中，第二个是外部类的 .class 文件，第一个是内部类的 .class 文件，
即成员内部类的 .class 文件总是这样：外部类名$内部类名.class

另外，友情提示哦：

1、 外部类是不能直接使用内部类的成员和方法滴
可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。

2、 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，
如果要访问外部类的成员变量，可以使用 this 关键字。

Java 中的方法内部类

方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

一定要注意哦：由于方法内部类不能在外部类的方法以外的地方使用，
因此方法内部类不能使用访问控制符和 static 修饰符。

 

java的继承

是类与类的一种关系 子类，父类
java中继承是间继承，只能有一个父类

好处： 子类有父类所有的属性和方法 private修饰的无效

方法：class 子类 extends 父类{}

java中的方法重写

如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。

语法规则：返回值类型，方法名，参数类型及个数 都要与父类继承的方法相同，才叫方法的重写。

继承的初始化顺序：
先初始化父类再初始化子类；
先执行初始化对象中属性，再执行构造方法中的初始化。

final关键字

可修饰类、方法、属性和变量，使用final标识有“最终的”含义。
则类不可继承；
方法不可重写；
该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值（但只能选其一）；
变量的值只能赋一次值，成为常量。

super关键字：

在对象的内部使用，可以代表父类对象
1.访问父类的属性 super.age
2.访问父类的方法 super.eat()

子类的构造过程中必须调用父类的构造方法

如果子类的构造方法中没有显示调用父类的构造方法，则系统默认调用父类无参的构造方法。
如果显示的调用构造方法，必须在子类的构造方法的第一行。
如果子类构造方法中既没有显示调用父类构造方法，而父类又没有无参的构造方法，则编译出错。
如果自己定义了有参的构造方法，系统就不会帮生成无参的构造方法。

Object类

它是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，则默认继承object类，object中方法，适合所有子类。

1.toString()方法 返回对象的哈希码（对象地址字符串）
可以重写这个方法，返回对象的属性值 source --> Generate toString()

2.eqials()方法
比较的是对象的引用是否指向同一块内存地址，dog1.equals（dog2）返回值为bool型，比较的是两个对象的内存地址是否相同。
一般情况下比较两个 对象时比较他的值是否一致，所以要进行重写。
new 再次相当于开辟了两个内存区域，所以两个对象的引用肯定不相同。等价于dog==dog2
==可判断两个基本数据类型的数据是否相同，若判断两个引用，比较的也是内存地址

若想判断两个对象的数据的值是否相同：重写equals方法
Source下的Generate hashCode() and equals()

类对象和类的对象
类对象更关注代码，类的对象更关注对象的值的信息
通过类对象可以判断对象的类型

多态

就是对象的多种形态，继承是多态的实现基础
1.引用多态 父类的引用可以指向本类的对象，父类的引用可以指向子类的对象。
Animal obj1 = new Animal();
Animal obj2 = new Dog(); 父类的引用可以指向子类的对象。这就是引用多态！
2.方法多态 创建本类对象时，调用的方法为本类方法
创建子类对象时，调用的方法为子类重写的方法或者继承的方法。这就是方法多态！

 

引用类型转换

1.向上类型转换（隐式/自动类型转换），是小类型到大类型的转换
2.向下类型转换（强制类型转换），是大类型到小类型
3.instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题。
if(animal instanceof Dog){} Dog类型能否转为animal类型

Java中的抽象类
语法：抽象类前使用abstract关键字修饰，则该类为抽象类。

作用：限制规定子类必须实现某些方法，但是不关注细节。

抽象方法没有方法体以分号结束。
抽象类定义：abstract class Animal{abstract void grow();}抽象类的抽象方法都需要添加关键字abstract，且顺序为abstract class。
使用规则：
abstract定义抽象类
abstract定义抽象方法，只有声明，不需要实现。抽象方法没有方法体以分号结束。
包含抽象类方法的类是抽象类
抽象类中可以包含普通的方法，也可以没有抽象方法
抽象类不能直接创建，可以定义引用变量

接口

接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。

类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，
也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。

是用来约束类的

定义接口
和类定义不同，使用interface关键字

类是单继承的，接口是多继承的

方法

[修饰符]interface 接口名[extends 父接口1，父接口2...]
{
零个到多个常量定义。。。
零个到多个抽象方法的定义。。。
}

接口就是用来被继承、被实现的，修饰符一般建议用public，不能使用private和protected修饰接口

接口定义：
常量： 接口中的属性是常量，即使使定义时不添加，public static final 修饰符，系统也会自动加上
方法： 接口中的方法只能是抽象方法，总是使用，即使定义时不添加public abstract修饰符，系统也会自动加上

一个类可实现一个或多个接口，实现 接口使用implements关键字。

继承父类实现接口的语法：
[修饰符] class 类名 extends 父类 implements 接口1，接口2...
{
类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。
}

接口命名，名字前加个大写I

使用接口： 接口在使用过程当中，还经常与匿名内部类配合使用
匿名内部类就是没有名字的内部类，多用于关注实现而不关注实现类的名称。