一些java学习的知识点

（前言）该笔记是我观看学习了B站UP主韩顺平老师的部分java基础教程后总结出的，在这里向大家强烈推荐韩顺平老师。为老韩打call。 第零章- java的引入 1.java se 是就业的基础

再牛的程序员都是从小白开始的，既然开始了，就全心投入学好技术

2.java适用于安卓软件，企业级应用，移动领域（车载系统，pos机…） 第一章-对java的一点儿介绍 1.什么是程序

程序就是一段文件，里面包含了一系列的计算机指令。由计算机执行这些命令。

2.java的诞生

1990 sun公司启动的绿色计划。
1994年，java功能震惊了世界。
1995年，java1.0发布。
2009，甲骨文收购了sun。
2011，java7发布了。
2014，java8发布了。
后面几年，java又产出了许多版本，但除了java8和java11是持续支持的外，其他的都不可获取了。

3.java技术体系平台

java se标准版
java ee企业版
java me小型版

4.java的重要特点

1. Java是面向对象的（oop语言）
2. 健壮性。强类型机制，异常处理，垃圾回收机制。
3. java跨平台性。（一次编译，各处执行。）
4. java是解释型语言。需要解释器执行。编译性语言则编译后的代码可以直接由机器执行。

5.java的开发工具

notepad++ 文本编辑器（前期适用）
sublime text 文本编辑器（前期适用）
idea 集成编辑器（后期）
eclipse 集成编辑器（后期）

6.java运行机制

jdk = jre + Java的开发工具（java，javac，javadoc，javap）
jre = jvm + java的核心类库
不同操作系统的jvm（简称 java virtual machine，安装在jdk中）运行程序编译好的 .class字节码文件。

7.一些编程的注意

1. 在java的一个 .java 文件中，只能有一个public类。
2. 而在一个 .java 文件中写了多个类，编译后每个类都都会产生一个. class 文件。
3. public类的类名必须匹配 .java 文件名

8.如何快速学习java技术？

1. 由浅入深。先有一个基本认识。
2. 开始考虑研究注意事项，使用细节，使用规范，如何优化。
3. 不同程序员的眼界能力不一样，对于新手，只能从简单的地方开始。
4. 总而言之。先提出需求，看能不能用传统技术解决，若不能。然后引出需求，学习新技术的用法，由浅入深。快速入门。然后研究细节。

9.程序员的等级划分

10.java注释

1. 单行注释 //
2. 多行注释
3. 文档注释

11.java代码规范

1. 对于类，方法的注释
   
2. 运算符 = 和 + - * / 左右空一格，可使代码整洁
3. 对于中文，采用utf-8
4. 行宽不要超过80字符
5. 行尾风格 {
   }
6. 次行风格
   {
   }
   （暂且只需掌握这么多）

12.DOS（Disk Operating System 磁盘操作系统）命令

1. md + 文件路径 + 文件夹名 创建文件夹
2. rd + 文件路径 + 文件夹名 删除…
3. dir 常看当前目录有哪些文件
4. dir + 路径 查看指定位置目录下有哪些文件
5. cd + 盘符（change directory）切换到其他盘
6. tree + 路径 用数图展示对应位置上的文件
7. cls 清屏
8. exit 退出DOS

13.相对路径和绝对路径

相对路径：相对当前文件 （…上一级目录）
绝对路径：从磁盘根开始

14.逻辑运算与进制

1. 逻辑运算符
   1. A & B 逻辑与
   2. A && B 短路与
      区别：
      逻辑与，两个条件都得判断。
      短路与，如果第一个条件为假，则不判断第二个条件。值为假。
      在编程中，逻辑与的效率高。即” && “ 。
      A | B 逻辑或
      A || B 短路或
      ! A 取反
      A ^ B 异或
2. 三元运算符（ ？ ： ： ）
   （条件）？（真执行）：（假执行）
   三元运算符可以嵌套（但不利于程序的理解，不推荐使用）
3. 标识符命名规范
   1. 包名：所有字母小写
   2. 类名,接口名：所有单词首字母大写
   3. 方法名，变量名：驼峰命名法
   4. 常量名：所有字母大写 TAX_RATE

15.进制

1. 二进制 以0b或0B开头
2. 八进制 以0开头
3. 十六进制 以0x或0X开头
   注：使用println输出，会默认转化成十进制。

16.进制转换

数电知识点，已掌握

17.位运算

1. >> 算数右移
2. << 算数左移
3. >>> 无符号右移
4. ~ 按位取反

18.原码反码补码

对于有符号的二进制数
二进制的最高位时符号位 0为正数，1为负数
正数的原码，反码，补码都相同
下面是负数的原码、反码、和补码：
3的原码：00000011 -3的原码：10000011 也就是最左边的那个数表示正负，0代表正，1代表负，它也叫符号位
-3的原码：10000011
-3的反码：11111100 负数的反码是对其原码按位取反，符号位不变
-3的补码：11111101 负数的补码是在其反码的末位加1
计算机用补码计算
*计算机运算的时候都是以补码的方式来运算的 *看结果要看原码

第二章 数据类型 1.基本数据类型 ①整数类型

	byte1字节 -128~127
	short2字节 -2^15 ~ 2^15-1
	int4字节 (31次 类比short)
	long8字节 (63次 同上)

②浮点数

浮点数的构成： 浮点数 = 符号位 + 指数位 + 尾数位。尾数位可能丢失

浮点数的两种表示形式 之一

float num = 1.1；（错误）
float num = 1.1f；（正确） 小数位只有7位有效
原因：double类型数据占的位数要大于float，加入要将一个double类型的数据放入比它小的float类型数据，就放不下了，会产生数据损失。反之就不存在这种情况。

其次

	5e2 = 5*10^2
	5e-2 = 5*10^(-2)

一个重要的使用点

对运算结果是小数的数进行相等判断时，由于计算机计算的问题，通常这种比较是行不通的。

应该是以两个数的差值的绝对值，在某个精度范围内判断。这样写更安全。

③字符型 char

在java中，char类型的本质是一个整数，在输出时，对应unicode字符输出。

④布尔型 true false 2.引用数据类型 ①类 class ②接口 interface ③数组 array 3.什么是字节？

（计算机的一种数据单位）1字节 = 8位 1byte = 8bit

4.一个重要的编程工具（JDK_API）

查找jdk基本类库的使用方法使用

5.介绍一下字符编码表

将各个国家的字符进行编码
ascll 一个字节 ，128个字符。实际上一个字节可以表示256，只用了128个
Unicode 统一两个字节。（浪费空间） unicode兼容ascll
utf-8 大小可变 字母一个字节 汉字三个字节 对unicode码的改进
gbk 大小可变 字母一个字节 汉字两个字节
gb2312 表示汉字较少
bing5码 繁体中文（台湾，香港）
不同的编码对文件的大小有影响。

6.自动类型转换

1. 多种类型数据计算时，系统自动先将所有数据转换成精度最高的数据类型
2. char 与byte和 short不发生自动转换。
3. byte -128 ~ （+127）之间
4. byte，short运算，不论结果怎样，数值都会转换到 int ，这是编译器规定好的，必须遵守。（不管是单独还是混合）
5. boolean不参与数据类型的转换

7.基本数据类型转String类型

​ int n1 =100;
​ float f1 = 1.1F;
​ String s1 = n1 + f1 + " " ;

8.String转基本数据类型

​ String s5 = “123”;
​ int num1 = Intger.parseInt( s5 );
类比
​ double d1 = Double.parseDouble( s5 );
​ byte num5 = Boolean.parseBoolean(" true ");
使用基本数据类型对应的包装类的相应方法，得到基本数据类型。

9.习题（非常重要） 判断题：

1. int num1 = (int)“18”;
   错误，字符串类型需要使用包装类来转换 Integer.parsrInt（”18“）；
2. byte b = 9; short s = b + 2;
   错误，byte和short类型计算后的结果是int。而int不能直接转换成short，需要强制类型转换。

第四章-数组 1.静态初始化

double [ ] a = {1,2.3,4,5}

2.动态初始化

int a [ ]; //声明一个数组，还没有分配空间
a = new int [5]; //分配内存空间，可以存放数据
还可以写成int a[]=new int[];

3.数组赋值机制

数组赋值是地址赋值

第七章-类与对象的引出

java的设计者引入 oop语言 的根本原因在于，现有的技术不能完美地解决一些新的需求。

1.（ 对象【属性，行为】）

​ public class cat{ //抽象的猫类
​ private String name;
​ private int age;
​ private String color;
​ public void eat( ){
​ System.out.println(“我会吃老鼠。”);
​ }
​ }
​ cat Tom = new Tom(); //具体的一只猫 Tom

2.属性/成员变量/字段

它们指代的东西是一样的

3.访问修饰符

protected
public
friendly
private

4.（对象的）方法的调用机制

执行了 new ，在堆区产生一个对象并从栈区指向堆区。
调用方法时，再开一个独立的栈空间用于运行方法，然后通过 return 返回给原来的栈位置
然后该运行方法的空间被释放

5.成员方法的必要性

将一些方法封装起来，然后就可以供多人使用，可以提高代码编辑的效率。

6.方法的一些注意事项

1. 一个方法最多只能有一个返回值
2. 方法还可以返回一个对象
3. 方法取名采用驼峰
4. 方法的定义不能嵌套,方法里可以调用方法，但不能再定义一个新的方法

7.如何返回多个值？

返回一个数组

8.成员方法的传参的机制

调用到成员方法时，会创建一个新的栈区，在里边运行代码，但执行完所有方法的代码时，该空间就被销毁了。操作影响不到主方法中的基本数据类型的变量值。
要是传递的参数是引用数据类型的话，传递的是地址，方法里边一切对引用数据类型的操作都会影响到实际的位于堆空间的引用数据类型的值

9.对象克隆

对象克隆完成后，会创建一个独立的堆空间存放信息，但是，对于引用数据类型来说，它仍然指向的是相同的方法区。简言之，基本数据类型可以独立，引用数据类型仍不独立。

10.方法递归（recursion）

类比汉诺塔问题

11.可变参数的使用

public int sum( int … nums) {
​ int res = 0;
​ for (int i = 0 ; i
​ res = res + nums[i];
​ }
​ return res;
}
参数表可以当作一个数组
所以 ，可变参数的参数表可以是一个数组
可变参数表可以有其他非可变参数，但只能有一个可变参数。而且必须放参数表后边。

12.作用域 13.构造器/构造方法

构造器没有返回类型，也不能写void

14.javap（将字节码文件反编译成一个类）

##javap -c + 类名 （反汇编）
对象创建的空间上的流程分析

15.什么是this

即----“我的”
指代当前对象
哪个对象调用，this就指代哪个对象。

16.this的使用细节

this可以访问成员方法
​ this . 方法名（参数列表）；
this不能乱用，只能用在类里
##在构造器里访问本类其他构造器语法
​ this . 构造器名 （实参）；
​ 必须放在第一行语句！
​ 只能在构造器方法里使用
​ 只能用一次

17.hashcode

将该对象的内部地址转换成一个地址
使用： this.hashcode = 当前对象 . hashcode;

18.new test()

匿名对象 只能用一次

第八章 封装 1.封装概述

将一些属性和操作（方法）封装成一个盒子（类），在使用时只需要传入参数，然后获得一些功能，使用者对盒子内部的细节并不关心。

2.封装的好处

​ 可以用封存来保护数据。
​ 简化操作
​ 一个遥控器就可以看成是一个封装的例子。

3.封装的步骤

设置set方法
设置get方法（快捷键：alt + insert）

4.继承（extends） ①为什么需要继承？

减少代码冗余
当多个类存在相同的属性和方法时，可以从中抽象出父类。只需要通过关键字（extends）就可以将代码复制过来。
在子类写本身一些特有的属性和方法即可。
继承可以多重继承 即 A ->B ->C ->D ->…

父类也叫超类，基类
子类也叫派生类

②继承注意

私有的属性和方法只能通过父类提供的能够进入的方法访问

5.super（）

默认调用父类的无参构造器，系统自动加。写不写一样。
初始化时需要注意的问题

1. 在使用子类创建对象时，需要先完成对其父类的初始化操作。如果子类不指定用父类的哪个构造器，则默认调用父类的无参构造器。如果指定构造器，则编译器就通过那个构造器完成对其父类的初始化。 super（实参参数表）,例如：
   ​ super（“smith”，15）；
2. super（…）必须放在子类构造器第一行
3. super（…）只能写一条
4. this（…）也要求放到构造器的第一条，所以：super（…）与this（…）只能存在一个

6.object类

object是顶级类。默认存在于每个类
初始化时，先初始化顶级类（依次往下）

7.不能滥用继承

必须满足：子类 is a 父类
牵一发，动全身
子类被创建，父类也得被创建。

8.查找关系

子类是否有该属性，如果有，并且可以访问：返回信息。
子类没有该属性，就看父类有没有这个属性，如果有，并且可以访问，：返回信息。
依次往上…

第九章 idea快捷键 1.out与src

每个类都会产生一个 . class文件。与它位于的 .class文件无关

2.常用快捷键

ctrl + Y 删除整行
ctrl + D 复制整行
ctrl + alt + L 快速格式化
shift + F10 运行
alt + insert 快速生成构造器/set方法/get方法
ctrl + H 生成继承关系表
ctrl + B 定位追踪

3.模板快捷键

new + 类名 + .var 自动生成对象名
main
sout
fori

第十章 面向对象中级 1.package 包

控制访问范围
管理类
不同包的类可以同名

2.包的命名规范

一般是小写字母 + 小圆点
com . 公司名. 项目名 . 业务模块名
如：
​ com . sina . crm . user 用户模块
​ com . sina . crm . order 订单模块

3.java中常用的包

java. lang . * ; 它是默认引入的
java , util . * ; 扫描
java . net . * ; 网络编程
java . awt . * ; 图形界面

4.访问修饰符

控制方法和属性的访问权限

1. public 对外公开
2. protected 对子类和同包类公开
3. 默认级别 对同包公开
4. private 只有类本身可以访问，不对外公开

5.hashCode（object的一个方法）

哈希值不完全等价于对象的地址 , java运行在jvm上，C语言的hashCode可以等价于地址
如果需要，hashCode也会被重写

6.toString（object的一个方法）

返回该对象的字符串表示，默认返回全类名 + hashCode的十六进制值
当直接输出一个对象时，会默认调用对象的toString（）方法。
##finalize（垃圾回收器调用的方法—object的一个方法）
当一个对象没有任何引用时，jvm会采用垃圾回收。垃圾回收默认调用finalize（）方法。
可以通过重写来达到你想要的目的。（比如释放数据库资源，关闭文件）
如果程序员不重写这个方法，那么就会调用object的ainalize方法。

7.System.gc ( ) 主动回收垃圾

实际开发不会运用finalize（）方法。更多的是为了应付面试。

8.断点调试（DeBug）

程序的某一行设置一个断点，程序运行到这一步就会停止。然后一步步进行。这是程序员的基本技能。
这里视频教程很全面，但考虑时间原因，暂时跳过。进入实际项目开发。

9.重写 ①重写条件

参数表必须相同
返回类型可以是父类返回类型的子类
如：父类返回object，子类返回String/数组/类

②对于重写的一些心得体会

我们在编写一个方法时要用到父类的方法，那直接用关键字super（）调入，然后再写一些自己的功能不就可以了吗？那为什么还要有重写这一说呢？我认为，重写之所以存在，是因为说到底这个方法和父类的方法还是很相近的，只是细微之处有不同。所以需要重写。没错，光使用super（）就可以满足需求，但是，毕竟这两个方法是非常相近的，不需要大费周章地再去想一个新名字。用相同的名字显然更好。而且，在涉及到多态时，也方便编译器从子类到父类的找寻。

③注意

子类不能缩小父类的访问权限

10.重载与重写的区别 ①发生范围：

重载出现在本类的构造器中，重写在继承关系中。

②方法名：

重载要求方法名和类名完全相同
重写要求方法名和父类被重写的方法名完全相同

③形参列表：

重载的形参列表和本类名必须不同（数据类型，参数个数，顺序）
重写的参数表必须和父类完全相同。

④返回类型：

重载无返回类型（注意是“无”，不能写，不是void）
重写的返回类型必须和父类相同或者是父类返回类型的子类。

⑤访问修饰符（权限修饰符）：

重载（overload） 无要求
重写（override） 子类方法不能缩小父类的访问范围

11.main方法

main方法由java虚拟机调用
虚拟机和main方法不在一个类，就需要给 public 访问权限
虚拟机执行 main 方法时，不需要实例化该类，就需要给 static
在执行 main 方法时，可以通过main方法传入参数。String [ ] args

12.多态（poly） ①必要性

当通过一个类去管理协调两个以上的类时，通常会编写很多的“桥梁代码”，通常这样的重写是冗杂的。
多态可以提高代码的复用性，利于维护

②多态的体现

1. 方法的多态 —重写—重载
2. 对象的多态（核心）
   一个对象的编译类型和运行类型可以不一致
   Animal animal = new Dog（）；编译类型是Animal，运行类型成了Dog；
   animal = new Cat（）； 编译类型仍然是Animal，运行类型变成了Cat；
   表面是…但实际上是…
   即：等号= 左边是编译类型，右边的是运行类型

③向上转型

父类的引用指向子类的对象
先看运行类型有没有满足的成员，如果有，则访问。如果没有，则向上找寻，父类，父类的父类…类似于this（）；

④向下转型

改变对象的编译类型成运行类型
要求 编译类型原先就指向 运行类型
即：下转的前提是上转
通俗来说：你只能将指向猫的动物变成一只猫，不能将指向狗的动物变成一只猫。
Cat cat = （Cat）animal；

⑤注意

向上转型不适用于属性。对子类做的改动无效。

13.instanceof

用法：bb instanceof BB
判断当前对象的运行类型bb是否是BB的类型或子类型

14.动态绑定机制（非常重要）

方法有动态绑定机制，该方法会绑定对象的运行类型。
属性没有动态绑定机制,哪里调用，哪里使用。
注：这个地方不懂会影响到后续的源码学习

15.多态数组

上转型对象有动态绑定机制，通常，上转型对象应该会有很多。所以，就需要一个容器，将这些对象存放在一起，然后通过数组的下标即可遍历每个上转型对象------多态数组

如何调用上转型对象特有的（私有的）方法？

​ 利用 instanceof判断子类，然后向下转型

16.多态参数

方法的参数表写的是父类类型，但实参可以是子类。

17.equals方法

源码：判断两个对象的引用类型是否是同一个对象
但通常他已经被引用数据类型重写
字符串的equals判断的是内容，其他的类型判断的是地址
功能较多，软件复杂，要用到模式管理

18.类变量

所有对象共享。可以通过类名访问。

①用法：

在属性前加 static

②注意

1. 静态变量是随着类加载就创建了，所以可以通过类名直接访问
2. 类的生命周期跟随类的生命周期

19.类方法（工具）

不实例化对象，也想使用类里边的方法时，就可以将这个方法设置为类方法。但类方法里边不能包含对象属性。

①用法：

在普通方法前加上 static 即可

②调用：

与类变量相同，但要注意权限

20.代码块

减少冗余
构造器自动执行代码块的内容

使用细节

1. static 代码块 它跟随的是类 只要类被加载，静态代码块就会被执行
2. 普通代码块 跟随的是对象的构造器 只有对象被实例化时，代码块才会跟着构造器执行
3. 静态代码块的优先级和静态属性的初始化优先级一样，谁写在前，谁先执行
4. 普通代码块的优先级和普通属性初始化的优先级相同，同样，谁写在前，谁先执行

21.额外注意：

构造器的优先级是最低的。意思就是在实例化一个对象时，先加载类的静态操作，再加载普通属性的操作，最后执行构造器。
外在表现形式就是：
​ public BBB(){
​ 1. super( );
​ 2. 调用普通代码块…;
​ 3. (构造器本体…)
​ }

第十一章 1.final

1. final修饰属性时，必须赋初值。不然要报错。
2. 赋初值可以写到1.定义时，2.构造器中。3.在代码块中（实质上就是构造器）
3. final类只能实例化，不能继承
4. static与final同时写，不会导致类加载。

2.abstract 抽象类 ①简述

没有方法体，只有方法声明，没有方法体 {…}。同时类也要声明为 abstract

②注意

1. 抽象类不能被实例化，只能被继承
2. 抽象类可以写普通方法
3. 抽象方法的类必须是抽象类
4. 如果一个类继承了抽象类，那么就必须实现抽象父类的所有抽象方法
5. 抽象类的抽象方法不能用static修饰。子类无法继承抽象类的该静态方法，该方法是父类的静态方法。

3.接口

1. 接口在jdk8之后可以有自己的非抽象方法（静态方法，默认方法）。也就是说可以有具体的方法实现。
2. 接口的多态传递现象
   接口类型的变量可以指向实现了该接口的类的对象实例
   接口可以继承，接口类型的继承的父类接口还可以指向实现了该接口的类的对象实例
   类似于向上转型：利用子类去实例化父类

4.内部类

类嵌套类 被嵌套的类叫做内部类

5.类的五大成员（面试题）

属性 方法 构造器 代码块 内部类

6.四种内部类 ①局部内部类

定义在类的方法体中的类。可以直接访问外部所以成员
不能添加访问修饰符，但可以用final修饰。这样别人就无法继承
它的作用域只在方法体内，或代码块内
可以直接访问访问外部类的成员
同样 外部类在方法中可以创建内部类的对象实例，然后调用方法
内部类内，通过 外部类名 . this . 成员 访问 (原因：外部类名 . this实质是外部类的对象。类似于动态绑定)

②匿名内部类！！！！！！

类型：基于接口，基于类，
注意：定义在外部类的局部位置，比如方法中，并且没有类名。同时，它还是一个对象。
目的：简化开发（匿名内部类只能使用一次）
​ new 类/接口（参数列表）{
​ …
​ …
​ }；

③成员内部类

定义在成员位置，可以直接访问访问外部类的成员，包含私有的。

④静态内部类（static class）

放在外部类的成员位置，用static修饰。
外部类访问，要先创建外部类的对象，然后直接调用。
外部其他类访问，

7.枚举(enumeration)

包含一组有限的，特定的对象。
枚举对象命名要全部大写。常量池
代码演示：

package enumeration;
import java.sql.SQLOutput;

public class enumeration01 {
    //枚举演示代码
    public static void main(String[] args) {
        System.out.println(Season.SPRING);
        System.out.println(Season.SUMMER);
    }
}
class Season{
    private String name;
    private String desc;
    static{
        System.out.println("hello");
    }
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }//构造器私有化，防止对象直接被new

    //去掉set方法，保留get方法。防止属性被修改。
    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }
    //在类中创建固定的对象,定义了两个对象。
    public static final Season SPRING = new Season("春天","温暖");
    public static final Season SUMMER = new Season("夏天","炎热");
    //加final不会导致类加载。但要new对象，所以不管写不写，类都会被加载。
    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + ''' +
                ", desc='" + desc + ''' +
                '}';
    }
}

//使用enum关键字实现枚举类
package enumeration;
import java.sql.SQLOutput;

//演示使用enum来创建枚举类
public class enumeration02 {
    //枚举演示代码
    public static void main(String[] args) {
        System.out.println(Season.SPRING);
        System.out.println(Season.SUMMER);
    }
}
enum Season02{
    SPRING("春天","温暖"),SUMMER("夏天","炎热");
    private String name;
    private String desc;
    static{
        System.out.println("hello");
    }
    private Season02(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }//构造器私有化，防止对象直接被new
    //去掉set方法，保留get方法。防止属性被修改。
    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }
    //在类中创建固定的对象,定义了两个对象。
//    public static final Season SPRING = new Season("春天","温暖");
//    public static final Season SUMMER = new Season("夏天","炎热");
//    加final不会导致类加载。但要new对象，所以不管写不写，类都会被加载。
    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + ''' +
                ", desc='" + desc + ''' +
                '}';
    }
}

注意：

1. 使用enum会默认继承到Enum类，该类是final类型的。
   ​ 2. SPRING(“春天”,“温暖”)
   ​ 等价于
   ​ public static final Season SPRING = new Season(“春天”,“温暖”);
2. 如果实例化对象调用的是无参构造器的话，无需在参数表里加任何东西。甚至连（）都能省略。
3. 逗号间隔，最后加分号，必须位于行首。

8.for each循环演示：

for each循环演示：
int n[] = {1,2,3,4,5,6};
for (int i = 0; i < n.length; i++) {
    System.out.println(n[i]);
}
for (int i:n) {
    System.out.println(i);
}
package enumeration;

//enum实现接口
class test6{
    public static void main(String[] args) {
        enumration.PLAY.playing();
    }
        }
interface abc{
    abstract void playing();
}

enum enumration implements abc{
    PLAY;

    @Override
    public void playing() {
        System.out.println("ooooooooooooo");
    }
}

9注解（Annotation） ①@Override

标记重写，只能放在方法上。编译器就会去检查该方法是否真的重写了父类的方法。如果确实重写了，则编译通过。否则编译失败。
总之，它在校验方法是否真的被重写了。

//注解类
@Target(ElementType.METHOD)//修饰注解的注解，称之为元注解
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}

②@Deprecated

用于标识类，方法，包，参数等等已经过时，即不再推荐使用，但仍然可以使用。

package anno;

public class test {
    public static void main(String[] args) {
        abc.say();//此处可以调用，但不推荐使用。编译器里会显示删除线。
    }
}
class abc{
    @Deprecated
    public static void say(){
        System.out.println("hello");
    }
}

③@SuppressWarnings()

@SuppressWarnings({"all"})

作用范围：和放置的位置相关。如果放置在main方法，那么抑制警告的范围就是main方法。
可以放到类上，方法上

④@SuppressWarning 中的属性介绍以及属性说明

all，抑制所有警告
boxing，抑制与封装/拆装作业相关的警告
cast，抑制与强制转型作业相关的警告
dep-ann，抑制与淘汰注释相关的警告
deprecation，抑制与淘汰的相关警告
fallthrough，抑制与switch陈述式中遗漏break相关的警告
finally，抑制与未传回finally区块相关的警告
hiding，抑制与隐藏变数的区域变数相关的警告
incomplete-switch，抑制与switch陈述式(enum case)中遗漏项目相关的警告
javadoc，抑制与javadoc相关的警告
nls，抑制与非nls字串文字相关的警告
null，抑制与空值分析相关的警告
rawtypes，抑制与使用raw类型相关的警告
resource，抑制与使用Closeable类型的资源相关的警告
restriction，抑制与使用不建议或禁止参照相关的警告
serial，抑制与可序列化的类别遗漏serialVersionUID栏位相关的警告
static-access，抑制与静态存取不正确相关的警告
static-method，抑制与可能宣告为static的方法相关的警告
super，抑制与置换方法相关但不含super呼叫的警告
synthetic-access，抑制与内部类别的存取未最佳化相关的警告
sync-override，抑制因为置换同步方法而遗漏同步化的警告
unchecked，抑制与未检查的作业相关的警告
unqualified-field-access，抑制与栏位存取不合格相关的警告
unused，抑制与未用的程式码及停用的程式码相关的警告

未完待续