00_java基础笔记

_01_命令提示符

//cmd的操作（Ms-DOS）
/*
* 进文件夹：cd 文件夹名
* 进多级文件：cd 文件夹1\文件夹2
* 返回上一级：cd ..
* 回根路径：cd \
* 查看当前内容：dir
* 清屏：cls
* 退出：exit
* */

_02_Java和JDK

/*
* JVM：Java虚拟机，Java程序的运行环境
* 跨平台性：java程序可以运行在任何操作系统的虚拟机上  （win：win虚拟机 mac：mac虚拟机  ）
* JDK(Java程序开发工具包) > JRE(Java程序的运行环境) > JVM(Java虚拟机，Java程序的运行环境)
* JDK：Java程序开发工具包，包括JRE和开发人员使用的工具
* JRE：Java程序的运行环境，包含JVM和多需要的核心类库
*
* javac.exe ：Java程序编译器，生成二进制文件
* java.exe：Java程序解释器，解释生成的二进制文件
* */

_03_关键字标识符

package _01_知识点总结._03_关键字标识符;

public class _03_关键字标识符 {
}

/*
 * 关键字：
 *   1.完全小写 2.在编辑器中有颜色的
 *
 * 标识符：
 *   1.程序中自己定义的名字（类名称，方法名，变量名等）
 * 标识符命名规则：
 *   1.仅数字，英文字符，_。2.不用数字开头(类名称，方法名，变量名等)
 * 命名规范：
 *   1.小驼峰式：变量名  2.大驼峰式：类名称
 *
 * */

_04_基本数据类型

/*
*常量：
*   1 字符串常量
*   2 整数常量
*   3 浮点数常量
*   4 字符常量
*   5 布尔常量：true false
*   6 空常量：NULL
*
* 数据类型
*   1 基本数据类型：
*       整数型：byte short int long
*       浮点数：float double
*       字符型：char
*       布尔型：boolean
*   2 引用数据类型：字符串，数组，类，接口，Lambda
*
*   3 注意事项
*       浮点型可能只是近似值，并非精确值
*       数据范围：float比long广，f为4字节，l为8字节
*       浮点数：默认double类型，使用float类型，后加 F
*       整数型：默认int类型，使用long类型，后加 L
*
* 变量使用注意事项：
*   多变量不重名
*   float和long类型，后F和L不可省略
*   变量先声明后使用
*
* */

_05_数据类型转换

/*
*
* 自动类型转换（隐式）
*   自动完成
*   数据范围从小到大，隐含强制类型转换
*   数据范围从大到小，发生强制类型转换
*
* 强制类型转换
*   特殊格式处理
*   例：int num = (int) 100L;
*   不推荐使用，可能会发生精度损失
*   byte/short/char类型都能发生数学运算（提升为 int型，再进行运算）
*   boolean类型不能发生数学运算
*
*
*
* */

_06_运算符

/*
* 四则运算：+ - * /
* 取余 %
* +号的用法
*   算术：加减运算
*   字符中：加减运算
*   字符串中：字符串连接
*
* 自增自减：++ --
* 赋值运算：=  +=  -+  /=  *=  %=
* 比较运算：==  >  <  >=  <=   !=
* 逻辑运算：&&  ||  ！
* 三元运算：   ？ ：
*
*
* */

_07_方法入门

/*
* 1.方法定义：
*   public static void 方法名（）{
*       方法体；
*   }
* 2.注意事项：
*   方法顺序不限制
*   方法不能嵌套定义
*   方法有返回值时，必须写上（return 返回值；）
*
* 3.方法调用
*   单独调用    sum(a:10,b:20);
*   打印调用    System.out.println(sum(a:10,b:20));
*   赋值调用    int num = sum(a:10,b:20);
*
* 4.
*
* */

/*
* 方法重载(Overload)：多个方法的名称相同，参数列表不同
* 方法重载的正确使用：
*       参数个数不同
*       参数类型不同
*       参数多类型顺序不同
*
*  非正常使用重载：
*       与参数的名称无关
*       与方法的返回值类型不同
* */

_08_JDK9中的JShell

/*
* JShell脚本运行
* 启动：cmd中JShell
* 退出： /exit
* 语句执行：一句一句执行
* */

_09_流程及循环

/*
* 1 顺序结构
* 2 选择结构
*       if-else
*       三元运算符： ？ ：
*       switch
*           swtich（表达式）{
*               case 常量值：语句体  ； break；
*               ……
*               default 语句体；break；}
*        注意事项：
*           case后的数值不能重复
*           case后支持的数据类型：基本：byte/short/char/int 引用：String/enum枚举
* 3 循环结构
*       for循环
*       while循环
*       do-while循环
*
* 4 循环控制
*       break：跳出循环，提前结束循环
*       continue：跳过本次循环，继续后边的循环
*
*
* */

_10_IDEA

/*
 * 项目名称：Java 二次学习
 * 模块名称：01_基础
 * 包名称：_01_基本操作    注：推荐cn.itcast.www   (约定俗成)
 * 类名称：
 *
 * 注：
 *   包及包下代码在src包中
 *   包中可以新建包
 *
 * 项目导入：项目结构-->模块-->模块导入
 *
 *
 *
 *
 * 方法重载：方法名相同  参数不同/参数类型不同/多类型顺序不同
 * shift+F6  ：方法中相同的参数统一修改
  * */

_11_数组及使用

/*
* 1 数组的特点：
*       数组时引用类型
*       数组定义后，元素类型相同，长度在运行期间不可改变
* 2 数组的定义：
*       动态初始化：数据类型[] 数组名称 = new 数据类型[数组长度];
*       静态初始化：数据类型[] 数组名称 = new 数据类型[]{a，b，c，……};
*                  省略格式：数据类型[] 数组名称 = {a,b,c,……};
*       注：省略格式不可拆分为先定义再使用
* 3 注：
*       动态初始化数组后的数组系统默认值
*           int 默认值0
*           float 默认值0.0
*           char 默认值‘/u0000’
*           boolean 默认值false
*           引用类型 null
* 4 数组长度：数组名称.length
* 5 数组遍历：数组名称.fori  （for(i=0;i<数组名称.length;i++)）
* */

_12_Java内存划分

/*
* 1 栈：存放方法中的局部变量，方法运行一定再栈中
* 2 堆：new出来的东西都在堆当中
*       堆内存中的东西都有一个地址值：16进制
*       堆内存中的数据，都有默认值
* 3 方法区：存放.class信息，包含方法的信息
* 4 本地方法栈：与操作系统有关
* 5 寄存器：与CPU有关
*
*
* 索引越界异常：ArrayIndexOutOfBoundsException
* 空指针异常：NullPointerException
*
* */

_13_面向对象

/*
* 面向过程：实现一个功能时，每个步骤都亲历亲为，详细处理每个细节
* 面向对象：实现一个功能时，找个具有该功能的对象，替我完成
*
*面向对象的三大特征：分装，继承，多态
*   类： 一组相关属性和行为的集合 （对一类事务的描述，抽象的）
*   对象：一类事务的具体实现，对象时类的一个实例（一类事务的实例，具体的）
* */

/*
* 类：属性  行为
*
* 成员变量（属性）
*       String name；
*       int age;
* 成员方法（行为）
*        public void eat () {};
*        public void sleep() {};
*        注：普通方法没有关键字static
* */

/*
* 成员变量：
*       在方法的外部，直接写在类中
*       整个 类 都通用
*       没有赋值，会有默认值
*       位于堆内存
*       随对象创建而产生，随对象被垃圾回收而消失
*
* 局部变量
*       在方法的内部
*       只有在方法中使用，出了方法不能使用
*       没有赋值，不会有默认值
*       位于栈内存中
*       随着方法进栈而产生，随方法出栈而消失
* */

/*
* 1 方法就是一种封装
* 2 关键字private也是一种封装
*
*
* */

/*
* 1 使用private修饰后，在本类当中随意使用，超出本类不能直接访问
* 2 需要间接访问private成员变量，定义一对Getter/Setter方法。实现数据倒手中判断数据合法性
* 3 格式：setXxx  getXxx
*       setXxx ： 不能有返回值，参数列表类型和成员变量类型对应
*       getXxx ： 不能有参数，返回值类型与成员变量对应
*
* 4 对于boolean类型，使用setXxx 和  isXxx 形式
* */

/*
* 当方法局部变量和类的成员变量发生重名关系时使用，就近原则，有限使用局部变量
* 访问类的成员变量，使用this.成员变量名
* */

_14_构造方法

/*
* 注意事项：
*       构造方法的名称必须和类名称完全相同
*       构造方法没有返回值，也没有void
*       new对象时，就是调用构造方法
*       构造方法不能return一个具体的值
*       没有编写构造方法，编译器自动赠送一个构造方法（无参数，方法体什么都不做）
*       一旦编写构造方法，编译器不在赠送构造方法
*       构造方法可以进行重载（方法名称相同，参数列表不同）
*
* 格式：
*       public 类名称（参数类型  参数名称） {
*           方法体；
*       }
*
* */

_15_标准的类

/*
*标准类的四个组成部分
* 1 所有的成员变量都要private
* 2 为每一个成员变量编写getter/setter方法
* 3 一个无参构造方法
* 4 一个全参构造方法
*
*
* 快捷键 ： Alt + insert
* */

_16_API概述和使用

/*
* Java API：程序员字典，类的说明文档
* */

/*
* Scannerl类：实现键盘输入数据
*
* 引用类型的使用步骤：
* 1 导包
*       improt 包路径.类名称；
*       使用的目标类在同一包中，不需要使用导包语句
*       只有在java.lang包下的内容不需要导包，其他的都需要import语句
* 2 创建
*       类名称 对象名 = new 类名称（）；
* 3 使用
*       对象名.成员方法名（）；
*
* 获取int类型：int num = 对象名.nextInt（）；
* 获取String： String str = 对姓名.next（）；
*
*
* */

/*
* 创建对象的标准格式：
*   类名称 对象名 = new 类名称（）；
*
* 匿名对象：
*   new 类名称（）
*   使用：  new 类名称（）.name = "gaoyuanyuan";
*          new 类名称（）.eat（）；
*
* */

/*
* 1 导包： import java.util.Random
* 2 创建： Random random = new Random();
* 3 使用： 获取随机数字： int num = random.nextInt();
*          指定范围数字： int num = random.nextInt(3);   [0，2)   即：0，1，2
*
* */

/*
* 缺点：数组一但创建，长度就固定
*       所以引入ArrayList集合
*
* */

/*
* ArrayList:数组长度可以发生改变
* <E>:表示范型
* 范型：集合当中的元素类型相同  属于：引用类型
*
* 注意事项：
*   ArrayList集合没有添加数据，直接打印得到[]，而不是像数组打印得到地址值
*
* 添加数据：数组名.add（）；
*
*
*
* */

/*
* 数组名.add（元素）；  //返回值为是否添加成功ture/false   可添加 可不添加
* 数组名.get（索引值）；//返回值为索引值位置元素
* 数组名.remove（索引值）； //返回值为删除的多因值位置元素
* 数组名.size();  //返回值为数组长度
*
* */

/*
*ArrayList集合创建 基本类型 数组时 使用 对应的包装类
*基本类型   包装类
* byte      Byte
* short     Short
* int       Integer
* long      Long
* float     Float
* double    Double
* char      character
* boolean   Boolean
* */

_17_字符串

/*
* 字符串的特点:
*   字符串的内容永不可变
*   字符串内容不可变，所以可以共享
*   字符串效果上相当于char[]类型数组，底层原理：byte[ ]字节数组
*
* 字符串的创建方法3+1种
*       public String();   空字符串
*       public String（char[] array）；
*       public String(byte[] array);
*       String str = "hello";
* */

/*
* 字符串常量池：直接写在“ ”中的，就在字符串常量池中
*
* 对于基本类型：==是进行数值的比较
*    引用类型：==是进行 地址值 的比较
*
*进行字符串比较：
*       public boolean equals(Object abj) //参数可以是任何对象，
* 注意事项：
*       任何对象都能用Object进行接收
*       equals具有对称性，a.equals(b)  等同于 b.equals(a)
*       常量和变量进行比较时，推荐常量在前，变量在后
*       a.equalsIgnoreCase(b)   //忽略字符串大小写进行比较
* */

/*
 * public int length（）；  //获取字符串长度
 * public String concat（String str）； //拼接字符串
 * public char charAt（int index）； //获取字符串指定位置的字符
 * public int indexOf（String str）； //获取参数字符串在原字符串中首次出现的索引位置
 *
 * 字符串截取：
 *       public String substring(int index);  //截取 从索引位置开始到结束
 *       public String substring（int begin，int end）；  指定位置的字符串截取[begin,end)  取前不取后
 *
 * 字符串转换方法：
 *       public char[] toCharArray();  //字符串转换成字符数组  进行输出
 *       public byte[] getBytes(); //获取字符底层的字节数组
 *       public String replace(CharSequence oldString, CharSequence newString);  //旧字符串替换为新字符串
 *
 * 分割字符串的方法：
 *       public String[] split(String regex);   //按分割规则。将字符串分割为字符串数组
 * 注意事项：
 *       split方法的参数实际是“正则表达式”
 *       按照英文.进行分割时，split参数为“\\.”  //两个反斜杠
 * */

_18_Static关键字

/*
* static关键字：使用static关键字，这样的内容不属于对象，属于类，凡是本类的对象，都共享同一份
* */

/*
* Static修饰成员方法后的成员方法调用：（无需创建对象，即可直接通过类名称进行调用）
*       类名称.成员方法（）；  //推荐使用
*       对象名称.成员方法（）； //可以使用，但不推荐
*
* 普通成员方法的调用：
*       必须先创建对象，在进行调用，格式：对象名称.成员方法（）；
*
* Static修饰的成员变量/普通的成员变量：
*       普通方法中，可以调用Static修饰的成员变量，也可以使用普通成员变量
*       Static修饰的方法中，只能调用Static修饰的成员变量
*           原因：内存当中，现有静态内容，后有非静态内容
*           this：代表当前对象
*           静态方法中不能使用this关键字
*
 *  */

/*
* 静态代码块：
*       public class 类名称 {
*           static {
*               静态代码块内容；
*           }
*       }
*
* 注意事项：
*       第一次用到本类时，执行静态代码块，且仅执行一次
*       静态内容总是优先于非静态内容。故先执行静态代码块，后执行构造方法（无参构造方法，全参构造方法）
*
*       用来给一次性成员变量进新赋值
* */

/*
* java.util.Arrays;  //与数组相关的工具类，提供大量静态方法，实现常见的操作
*
* public static String toString（数组）； //将参数数组变成字符串
* public static void sort（数组）；  //数组元素进行排序
*           数字：升序
*           字母：升序
*           其他：自定义的类需要有Comparable或Comparatore接口的支持
* */

/*
* 数组名.forr  倒序遍历 for (int i = array.length - 1; i >= 0; i--)
* 数组名.fori  正序遍历
 * */

/*
* java.util.Math; //数学工具类，提供大量静态方法，完成数学运算
*
* public static double abs（double num）；//绝对值
* public static double ceil(double num); //向上取整
* public static double floor(double num);//向下取整
* public static long round(double num ); // 四舍五入
* */

_19_封装性

/*
* 继承是多态的前提，没有继承就没有多态
* 继承主要解决问题：共性抽取
*
* 父类：基类，超类
* 子类：派生类
*       子类可以拥有父类的内容，也可以拥有自己独有的内容
*       子类也可以当作父类使用
*
* 父类格式：
*       public class 父类名称（）{
*           //……
*       }
* 子类格式：
*       public class 子类名称 extends 父类名称 {
*              //……
*       }
*
* 继承的 特点：
*       父类可以有多个子类
*       一个子类只能有一个父类
*       继承可以多级继承
* */

/*
* 无论是成员方法还是成员变量，如果没有都是向上找父类，不可能向下找子类
*
*
* 重写：Override 方法名称一样， 参数列表相同
* 重载：Overload 方法名称一样，参数列表不同
* */

/*
* 方法覆盖重写的注意事项：
*   1  保证父子类的方法名称相同，参数列表也相同
*           @Override  //写在方法的前面，检验方法知否正确覆盖重写
*   2 子类方法的返回值的范围必须小于或等于父类方法中的返回值范围
*           java.util.Object是所有类的公共最高父类（祖宗类），java.util.String就Object的子类
*   3 子类方法的权限必须大于或等于父类方法的修饰权限
*       public > protected >(default) >private
*       default不是关键字，是什么都不写
*
*
* */

/*
* 继承关系中，父子类构造方法的访问特点：
*  1 子类构造方法中隐含super（）；调用，先执行父类构造方法，再执行子类构造方法
*  2 子类构造方法中可以使用super调用父类构造方法进行重载构造
*  3 子类构造中调用必须在子类构造第一句，且只能调用一次
*
* */

/*
* 构造方法：
*      public 方法名称（类名称）（可有可无）{}
*   方法名称与 类名完全相同，参数可以不同
*   无static，也无void，没有返回值
*   new该对象时，就是调用构造方法
*   无构造方法时，编译器赠送。
*   构造方法可以进行重载（方法名相同。参数不同）
* */

/*
* super的三种用法：
*       1 在子类成员方法中，调用父类的成员变量
*       2 在子类成员方法中，调用父类的成员方法
*       3 在子类构造方法中，调用父类的构造方法
*
* this的三种用法：
*       1 在本类成员方法中，访问本类的成员变量
*       2 在本类成员方法中，访问本类中另一个成员方法
*       3 在本类构造方法中，访问本类的另一个构造方法
*           注：
*           this.构造方法(); //只能在构造方法的首句，且唯一一次
*           this.构造方法();  和 super.构造方法();   //在调用时，只能选其一，不能同时调用
* */

_20_抽象方法

/*
* 抽象方法：父类当中的方法只是笼统的实现，具体实现通过子类方法实现。这种方法叫做抽象方法
* 抽象方法格式： public abstract void 方法名称();
* 抽象类和抽象方法：
*       1 抽象方法必须在抽象类当中
*       2 抽象类： public abstract class 类名称() {  }
*       3 抽象类中可以有别的普通方法
*       4 抽象方法必须由子类继承 进行覆盖重写
*       5 抽象方法的调用，通过创建子类对象，进行调用，不能直接创建父类对象进行调用
*注意事项：
*       1 抽象类不能直接创建对象，只能通过创建子类对象进行调用实现
*       2 抽象类中可以有构造方法，在子类中super（）；调用父类构造方法
*       3 抽象类中不一定有抽象方法，抽象方法必须在抽象类中
*       4 抽象类的子类，必须覆盖重写所有父类中抽象方法
*
* */

_22_接口与多态

/*
* 1 接口：就是公共的规范标准
* 2 所有版本的Java都可以定义抽象方法
*       接口中抽象方法：必须用public static 修饰，可以选择性的省略
*
*       Java7版本可包含：1 常量  2 抽象方法
*       Java8版本可包含：1 常量  2 抽象方法  3 默认方法  4 静态方法
*       Java9版本可包含：1 常量  2 抽象方法  3 默认方法  4 静态方法  5 私有方法
*
* 3 注意事项
*       接口不能直接使用，必须要实现类来实现
*           格式：  public class 实现类名称 implements 接口名称 { }
*       接口的实现类必须覆盖重写所有接口中的抽象方法
*       如果没有覆盖重写所有抽象方法，那么实现类必须是抽象类
*
* 4 注：
*       类与类之间是单继承的，直接父类只有一个
*       类与接口是多实现的，一个类可以实现多个接口
*       接口与接口是多继承的
*               多父接口中的抽象方法重复，没关系
*               多父接口中的默认方法重复，子接口必须对默认方法进行覆盖重写
*
* */

/*
* 接口中的默认方法为了解决 接口升级 问题
*   举例：接口中抽象方法写定后，子类实现覆盖重写后。 在接口中再次添加抽象方法时，其子类出现错误。所以引入默认方法，以实现添加方法的目的
*
* */

/*
* 接口静态方法：
*   格式：public static 返回值类型 方法名称（） {}；
*   注意事项：
*       接口静态方法不能通过实现类调用，只能通过接口名称直接调用
*       而普通静态方法，推荐类名称调用，不推荐实现类调用，但可以用
*
*
* */

/*
* 接口私有方法：解决方法之间重复代码的问题
*
* 私有方法分类：
*   普通私有方法：解决默认方法之间的重复代码
*       格式：private 返回值类型 方法名称（）{}；
*   静态私有方法：解决静态方法之间的重复代码
*       格式：private static 返回值类型 方法名称（）{}；
* */

/*
* 接口常量修饰：public static final 数据类型 常量名成 = 数据值；
* 注意事项：
*   一但使用final修饰，表示不可修改
*   接口中的常量，可以省略public static final，不写也是常量
*   接口中的常量，必须进行赋值
*   常量的名称，推荐全大写字母，用_分割
* */

/*
* 使用接口，需要注意的事项
*   1 接口是没有代码块或构造方法的
*   2 一个类的直接父类唯一，但一个类可以实现多个接口
*     格式： public class 实现类名称 implents 接口A，接口B { 覆盖重写所有抽象方法}
*   3 实现类实现的多个接口中有重复的抽象方法，只需要覆盖重写一次
*   4 若实现类中没有覆盖重写所有抽象方法，那么实现类必须是抽象类
*   5 若实现类中实现的多个 接口中，有重复的默认方法，实现类必须覆盖重写该方法
*   6 一个类的父类中有方法与实现的接口中方法重复，优先使用父类当中的方法
*
* */

_23_多态

/*
*extends和implements是多态性的前提
* 多态：指对象的多种形态
*       父类引用指向子类兑现
* 格式：父类名称 对象名 = new 子类名称（）；
*       接口名称 对象名 = new 实现类名称（）；
* */

/*
* 成员变量访问两种方式：
*   1 直接通过对象名称访问成员变量：等号左边是谁，优先用谁
*   2 间接通过成员方法访问成员变量：优先使用成员方法所在类的成员变量
*
* 成员方法访问特点：
*   看new的是谁就优先用谁
*   即：编译看左边，运行看右边
*
* 对象的向上和向下转型
*       1 向上转型一定是安全的 （小范围-->大范围）
*               弊端：使用子类特有方法时，编译器报错（在父类方法中没有对象的方法名称）
*       2 向下转型，将子类范围转换为父类范围后，进行小范围的还原
*               格式:子类名称 对象名 = （子类名称） 父类对象；
*
* instanceOf 关键字进行类型判断
*       格式:  子类对象 instanceOf 父类对象
*       判断创建对象时，时候时由该子类对象向上转型为该父类对象的，
*       返回值为Boolean
*
* */

_25_final关键字

/*
* final：最终，不可改变
* 常见四种用法：
*       修饰类
*               格式：public final class 类名称 { }
*               含义：当前这个类不能有任何子类
*               注：一个类如果时final类，其中所有的成员方法都无法进行覆盖重写（因为没有儿子）
*       修饰方法
*               final修饰方法时，这个方法就是最终方法，不能被覆盖重写
*               格式：public final 返回值类型 方法名）（参数列表） { 方法体 }
*               注：对于类、方法，abstract和final关键字不可共存，会产生矛盾
*       修饰局部变量
*               final修饰变量，表示不可变，一次赋值，终生不变
*               修饰基本类型：表示值不可变
*               修饰引用类型：表示地址值不可变
*       修饰成员变量
*               用final修饰成员变量后，也表示变量不可变
*               1 由于成员变量有默认值，所以final修饰后必须手动赋值，不会再有默认值
*               2 final修饰的成员变量，直接赋值，或通过构造方法赋值，二者选一，一次赋值不可再变
*               3 保证类中重载的构造方法，都最终会对final的成员变量进行赋值
* */

/*
*               public      protect       (default)     private
*同一个类           Y           Y               Y           Y
*同一个包           Y           Y               Y           N
*不同包子类          Y           Y               N           N
*不同包非子类         Y           N               N           N
*
* 注：default并不是关键字，而是什么都不写
* */

/*
* 1 内部类分类：
*      1 成员内部类：
*           1 格式：public class 外部内名称 {
*                       public class 内部类名称 {
*                              内部类成员变量；
*                              内部类成员方法；
*                       }
*                   外部类成员变量；
*                   外部内方法；
*               }
*                注意：内用外，随意使用，外用内，需要内部类对象
*            2 使用成员内部类：
*               1 间接方式：在外部方法创建内部对象，通过调用外部方法，间接调用内部方法
*               2 直接方式： 创建内部类对象  ：   外部类名称.内部类名称  对象名 = new 外部类名称().new 内部类名称();
*      2 局部内部类：
*           局部：只有本类能够使用，超出本类不能使用
*           格式： public class 外部类名称{
*                       public void 成员方法(){
*                           class 局部内部类名 {
*
*                           }
*                       }
*                   }
*
*       3 类的权限修饰符： public > protected > (default) > private
*       4 外部类：public / （default）
*       5 成员内部类： public / protected / （default） / private
*       6 局部内部类： 什么都不写
*           1 局部内部类的final问题
*                   局部内部类访问所在方法中的变量，这个局部变量必须时 有效final 的
*                   关键字final 可省略（ 保证该变量仅为唯一一次赋值）
*
*
* */

/*
* 使用场景：
*       接口的实现类（父类的子类）只需要使用唯一一次
*       可省略该类的定义，直接使用匿名内部类
* 格式：
*       接口名称 对象名 = new 接口名称（）{
*           //覆盖重写所有抽象方法
*       }；    //;不能丢
*
* 解释：
*       new：代表创建对象的动作
*       接口名称就是匿名内部类需要实现哪个接口
*       {}的内容才是匿名对象实现的内容
*
* 注意事项：
*   匿名对象在创建对象时，只能使用一次
*           多次使用，就必须创建接口的实现类（父类的子类继承）
*   匿名对象调用方法，只能调用一次
*           多次使用，需给匿名对象起个名字
*
* */

/*
* java.util.List是ArrayList实行的接口
*
* 接口：作为方法的参数/返回值都可以
* */

END