Java笔记（韩顺平Java基础9-11章）

第9章 项目-房屋出租系统

房屋出租系统-需求

• 项目需求说明
  实现基于文本界面的《房屋出租软件》
  能够实现对房屋信息的添加、修改和删除（用数组实现），并能够打印房屋明细表

房屋出租系统-界面

• 项目界面 - 主菜单
  
• 项目界面- 新增房源

• 项目界面- 查找房源
  
• 项目界面- 删除房源
  
• 项目界面- 修改房源
  如果不希望修改某个信息，则直接回车
• 项目界面-房屋列表

• 项目界面-退出系统
  

房屋出租系统-设计

• 项目设计-程序框架图(分层模式=>当软件比较复杂,需求模式管理)
  

房屋出租系统-实现

• 准备工具类Utility,提高开发效率
  在实际开发中，公司都会提供相应的工具类和开发库，可以提高开发效率，程序员也需要能够看懂别人写的代码，并能够正确的调用。

• 项目功能实现-完成House类
  编号 房主 电话 月租 状态(未出租/已出租)

• 项目功能实现-显示主菜单和完成退出软件功能
  实现功能的三部曲[明确完成功能->思路分析->代码实现]
  √功能说明：
  用户打开软件，可以看到主菜单，可以退出软件
  √思路分析：
  在HouseView.java中,编写一个方法mainMenu,显示菜单

• 项目功能实现-完成显示房屋列表的功能

• 项目功能实现-添加房屋信息的功能
  
  • 项目功能实现- 完成删除房屋信息的功能
    
  • 项目功能实现 - 完善退出确认功能
    
• 项目功能实现 - 完成根据id查找房屋信息的功能
• 项目功能实现 - 完成修改房屋信息的功能

第10章 面向对象编程(高级部分)

类变量和类方法

案例：有一群小孩在玩堆雪人,不时有新的小孩加入,请问如何知道现在共有多少人在玩?，编写程序解决

√思路
1.在main方法中定义一个变量count
2.当一个小孩加入游戏后count++,最后count就记录有多少小孩玩游戏

√问题分析
1.count是一个独立于对象
2.以后我们访问count很麻烦，没有使用到OOP
3.因此，我们引出类变量/静态变量

• 类变量内存布局
  1.静态对象被对象共享
  2.因此不影响对静态变量的使用
  静态变量放在哪里？
  两种说法：①堆中②方法区（图示中两种说法皆有体现）
  这与jdk版本有关系

√不管static变量在哪里,共识（1）static变量是同一个类所有对象共享(2)static类变量,在类加载的时候就生成了

• 什么是类变量
  类变量也叫静态变量/静态变量,是该类的所有对象共享的变量,任何一个该类的对象去访问它时，取到的都是相同的值，同时任何一个该类的对象去修改它时，修改的也是同一个变量。

• 如何定义类变量
  定义语法：
  访问修饰符 static 数据类型 变量名；
  static 访问修饰符 数据类型 变量名；

• 如何访问类变量
  类名.类变量名
  或者 对象名.类变量名【静态变量的访问修饰符的访问权限和范围 和 普通属性是一样的。】

• 类变量使用注意事项和细节讨论
  1.什么时候需要用类变量
  当我们需要让某个类的所有对象都共享一个变量时,就可以考虑使用类变量(静态变量)
  2.类变量与实例变量(普通属性)区别
  类变量是该类的所有对象共享的,而实例变量是每个对象独享的
  3.加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
  4.类变量可以通过类名.类变量名或者对象名.类变量名来访问，但java设计者推荐我们使用类名.类变量名方式访问.【前提是满足访问修饰符的访问权限和范围】
  5.实例变量不能通过类名.类变量名方式访问
  6.类变量是在类加载时就初始化了,也就是说,即使你没有创建对象,只要类加载了，就可以使用类变量了
  7.类变量的生命周期是随类的加载开始，随着类消亡而销毁。

• 类方法基本介绍
  类方法也叫静态方法
  形式如下：
  访问修饰符 static 数据返回类型 方法名(){ } 【推荐】
  static 访问修饰符 数据返回类型 方法名(){ }

• 类方法的调用：
  使用方式：类名.类方法名 或者 对象名.类方法名 [前提是 满足访问修饰符的访问权限和范围]

• 类方法经典的使用场景
  当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率

  比如：工具类中的方法utils
  Math类、Arrays类、Collections集合类看下源码

  在程序员实际开发，往往会将一些通用的方法，设计成静态方法，这样我们不需要创建对象就可以使用了，比如打印一维数 组，冒泡排序，完成某个计算任务等

• 类方法使用注意事项和细节讨论
  1)类方法和普通方法都是随着类的加载而加载,将结构信息存储在方法区：
  类方法中无this的参数
  普通方法中隐含着this的参数
  2)类方法可以通过类名调用，也可以通过对象名调用
  3)普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，比如对象名.方法名(参数)，不能通过类名调用
  4)类方法中不允许使用和对象有关的关键字，比如this和super。普通成员(成员方法)可以。
  5)类方法(静态方法)中只能访问静态变量或静态方法。
  6)普通成员方法,即可以访问非静态成员，也可以访问静态成员。

==小结:==静态方法，只能访问静态的成员，非静态的方法，可以访问静态成员和非静态成员(必须遵守访问权限)

理解main方法语法

• 深入理解main方法
  解释main方法的形式：public static void main(String[] args){}
  1.main方法是虚拟机调用的
  2.java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public
  3.java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static
  4.该方法接收String类型的数组参数,该数组中保存执行java命令时传递给所执行的类的参数
  5.java 执行的程序参数1 参数2 参数3(命令行)
  - 特别提示：
  1）在main()方法中,我们可以直接调用main方法所在类的静态方法或静态属性。
  2)但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员

• 在idea如何传递参数(main)
  

代码块

• 基本介绍
  代码化块又称为初始化块，属于类中的成员【即是类的一部分】,类似于方法,将逻辑语句封装在方法体中，通过{}包围起来

  但是和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而且加载类时，或创建对象时隐式调用

• 基本语法
  【修饰符】{
  代码
  };
  注意：
  1)修饰符可选，要写的话，也只能写static
  2)代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块
  3)逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）
  4);号可以写上，也可以省略

• 代码块的好处
  1)相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作
  2)场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性

• 代码块使用注意事项和细节谈论
  1)static代码块也叫静态代码块,作用就是对类进行初始化,而且它随着类的加载而执行，而且只会执行一次。如果是普通代码块，每创建一个对象，就执行。
  2)类什么时候被加载[重要！]
  ①创建对象实例时(new)
  ②创建子类对象实例,父类也会加载
  ③使用类的静态成员时(静态属性，静态方法)
  3)普通的代码块,在创建对象实例时,会被隐式的调用。被创建一次，就会调用一次。如果只是使用类的静态成员时，普通代码块并不会执行。
  小结：
  1.static代码块是类加载时，执行，只会执行一次。
  2.普通代码块是在创建对象时调用的，创建一次，调用一次
  3.类加载的3种情况记住

4)创建一个对象时，在一个类调用顺序是:(重点，难点)：
①调用静态代码块和静态属性初始化(注意：静态代码块和静态属性初始化调用的优先级一样,如果有多个静态代码块和多个静态变量初始化，则按它们定义的顺序调用)
②调用普通代码块和普通属性的初始化(注意：普通代码和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)
③调用构造方法

5)构造器的最前面其实隐含了super()和调用普通代码块。静态相关的代码块,属性初始化,在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行的

6）创建一个子类对象时(继承关系)，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：
①父类的静态代码块和静态属性（优先级一样,按定义顺序执行）
②子类的静态代码块和静态属性（优先级一样，按定义顺序执行）
③父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
④父类的构造方法
⑤子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
⑥子类的构造方法
7)静态代码只能直接调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员

单例设计模式

• 什么是设计模式
  1.静态方法和属性的经典使用
  2.设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索

• 什么是单例模式
  1.所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
  2.单例模式有两种方式：1）饿汉式 2）懒汉式

• 单例模式应用实例
  演示饿汉式和懒汉式单例模式的实现
  步骤如下：
  1）构造器私有化=> 防止直接new
  2）类的内部创建对象
  3）向外暴露一个静态的公共方法
  4）代码实现

• 饿汉式vs懒汉式
  1.二者最主要的区别在于创建对象的时机不同：饿汉式是在类加载就创建了对象实例，而懒汉式是在使用时才创建。
  2.饿汉式不存在线程安全问题。
  3.饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。
  4.在我们javaSE标准类中,java.lang.Runtime就是经典的单例模式。

final关键字

• 基本介绍
  final可以修饰类、属性、方法和局部变量
  在某些情况下，程序员可能有以下需求，就会使用到final:
  1)当不希望类被继承时，可以用final修饰
  2)当不希望父类的某个方法被子类覆盖/重写(override)时,可以用final关键字修饰
  3)当不希望类的某个属性被修改,可以用final修饰
  4)当不希望某个局部变量被修改，可以使用final修饰

• final使用注意事项和细节讨论
  1)final修饰的属性又叫常量,一般用xx_xx_xx来命名
  2)final修饰的属性在定义时，必须赋初值,并且以后不能再修改，赋值可以在如下位置之一【选择一个位置赋初值即可】：
  ①定义时：如public final double TAX_RATE = 0.08;
  ②在构造器中
  ③在代码块中
  3)如果final修饰的属性是静态的,则初始化的位置只能是①定义时②在静态代码块不能在构造器赋值
  4)final类不能继承，但是可以实例化对象
  5)如果类不是final类,但是含有final方法,则该方法虽然不能重写,但是可以被继承。
  6)一般来说，如果一个类已经是final类了,就没有必要再将方法修饰成final方法
  7)final不能修饰构造方法(即构造器)
  8)final和static往往搭配使用,效率更高，不会导致类加载底层编译器做了优化处理
  9)包装类(Integer,Double,Float.Boolean等都是final),String也是final类

抽象类

• 抽象类快速入门
  当父类的一些方法不能确定时,可以用abstract关键字来修饰该方法,这个方法就是抽象方法,用abstract来修饰就是抽象类

• 抽象类的介绍
  1)用abstract关键字来修饰一个类时,这个类就叫抽象类
  访问修饰符 abstract 类名{
  }
  2)用abstract 关键字来修饰一个方法时,这个方法就是抽象方法
  访问修饰符 abstract 返回类型 方法名(参数列表); //没有方法体
  3)抽象类的价值更多作用是在于设计,是设计者设计好后,让子类继承并实现抽象类()
  4)抽象类,是考官比较爱问的知识点，在框架和设计模式使用较多

• 抽象类使用的注意事项和细节讨论
  1)抽象类不能被实例化
  2)抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
  3)一旦类包含了abstract方法,则这个类必须声明为abstract
  4)abstract只能修饰类和方法,不能修饰属性和其他的
  5)抽象类可以有任意成员【因为抽象类还是类】，比如非抽象方法、构造器、静态属性等等
  6)抽象方法不能有主体，即不能实现
  7)如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
  8)抽象方法不能使用private、final和static来修饰,因为这些关键字都是和重写相违背的

抽象类最佳实践-模板设计模式

• 实践

需求
1)有多个类,完成不同的任务job
2)要求统计得到各自完成任务的时间

√解决
1.先用最容易想到的方法-> 代码实现
2.分析问题,提出使用模板设计模式

• 最佳实践
• 设计一个抽象类(Template),能完成如下功能：
  1)编写方法calculateTime(),可以计算某段代码的耗时时间
  2)编写抽象方法job()
  3)编写一个子类Sub,继承抽象类Template,并实现job方法

接口

• 基本介绍

• 借口就是给出一些没有实现的方法,封装到一起，到某些类要使用的时候，再根据具体情况把这些方法写出来。
  语法：
  interface 接口名{
  //属性
  //方法(1.抽象方法2.默认实现方法(default)3.静态方法)
  }
  class 类名 implements 接口{
  自己属性；
  自己方法；
  必须实现的接口的抽象方法
  }
  小结：
  1.在JDK7.0前接口里的所有方法都没有方法体，即都是抽象方法。
  2.JDK8.0后接口可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

• 注意事项和细节
  1)接口不能被实例化
  2)接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰
  3)一个普通类实现接口，就必须将该接口的所有方法都实现
  4)抽象类实现接口，可以不用实现接口的方法
  5)一个类同时可以实现多个接口
  6)接口中的属性，只能是final的,而且是public static final修饰符
  7)接口中属性的访问形式:接口名.属性名
  8)接口不能继承其他的类,但是可以继承多个别的接口
  9)接口的修饰符只能是public和默认,这点和类的修饰符是一样的。

• 实现接口vs继承类
  √接口和继承解决的问题不同
  继承的价值主要在于：解决代码的复用性和可维护性。
  接口的价值主要在于：设计好各种规范(方法),让其它类去实现这些方法

√接口比继承更加灵活
接口比继承更加的灵活,继承是满足is - a的关系,而接口只需要满足like - a的关系

√接口在一定程度上实现代码解耦【即 接口规范性 + 动态绑定机制】

• 接口的多态特性
  1)多态参数
  在UsbInterface接口案例，既可以接收手机对象，又可以接收相机对象，就体现了接口多态(接口引用可以指向实现了接口的类的对象)
  2)多态数组
  3)接口存在多态传递现象
  如果IG继承了IH接口,而Teacher类实现了IG接口
  那么,实际上就相当于Teacher类也实现了IH接口
  这就是所谓的接口多态传递现象.

内部类

• 基本介绍
  一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其它类的类称为外部类(outer class)。是类的第五大成员,内部类最大的特点就是可以直接访问私有属性,并且可以体现类与类之间的包含关系

• 基本语法

class Outer{		//外部类
	class Inner{	//内部类
	}
}
class Other{		//外部其他类
}

• 内部类的分类
  √定义在外部类局部位置上(比如方法内):
  1)局部内部类(有类名)
  2)匿名内部类(没有类名,重点！！！！)

  √定义在外部类的成员位置上：
  1)成员内部类(没用static修饰)
  2)静态内部类(使用static修饰)

• 局部内部类的使用

• 说明：局部内部类是定义在外部类的局部位置,比如方法中，而且有类名。
  1.可以直接访问外部类的所有成员，包含私有的
  2.不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量时不能使用修饰符的。但是可以使用final修饰,因为局部变量也可以使用final
  3.作用域：仅仅在定义他的方法或代码块中。
  4.局部内部类—访问—>外部类的成员【访问方式：直接访问】
  5.外部类—>访问—>局部内部类的成员
  访问方式：创建对象，再访问(注意：必须在作用域内)
  6.外部其他类—不能访问---->局部内部类(因为局部内部类地位是一个局部变量)
  7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

  记住：(1)局部内部类定义在方法中/代码块
  (2)作用域在方法体或者代码块中
  (3)本质仍然是一个类
  说明：(1)本质是类(2)内部类(3)该类没有名字(4)同时还是一个对象

• 匿名内部类的使用(重要！！！)

• 说明：匿名内部类是定义在外部类的局部位置，比如方法中，而且没有类名
  1.匿名内部类的基本语法

  new 类或接口(参数列表){
  类体
  }；
  2.匿名内部类的语法比较奇特，因为匿名内部类即是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，因此可以调用匿名内部类方法
  3.可以直接访问外部类的所有成员，包含私有的
  4.不能添加访问修饰符，因为它的地位就是一个局部变量。
  5.作用域：仅仅在定义它的方法或代码块中
  6.匿名内部类—访问—>外部类成员
  7.外部其他类—不能访问—>匿名内部类(因为匿名内部类地位是一个局部变量)
  8.如果外部类和匿名内部类的成员重名时,匿名内部类访问的话,默认遵循就近原则,如果想访问外部类的成员,则可以使用(外部类名.this.成员)去访问

• 匿名内部类的最佳实践
  当做实参直接传递，简洁高效

• 成员内部类的使用
  说明：成员内部类是定义在外部类的成员位置，并且没有static修饰
  1.可以直接访问外部类的所有成员,包含私有的
  2.可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员
  3.作用域：和外部类的其他成员一样，为整个类体
  4.成员内部类—>访问—>外部类成员(比如：属性)【访问方式：直接访问】
  5.外部类—访问—>内部类(说明)访问方式：创建对象，再访问
  6.外部其他类–访问—>成员内部类
  7.如果外部类和内部类的成员重名时,内部类访问的话,默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

• 静态内部类的使用
  说明：静态内部类是定义在外部类的成员位置,并且有static修饰
  1.可以直接访问外部类的所有静态成员,包含私有的,但不能直接访问非静态成员
  2.可以添加任意访问修饰符,因为它的地位就是一个成员
  3.作用域：同其他成员，为整个类体
  4.静态内部类—访问—>外部类(比如：静态属性)【访问方式：直接访问所有静态成员】
  5.外部类—>访问—>静态内部类 访问方式：创建对象，再访问
  6.外部其他类—访问—>静态内部类
  7.如果外部类和静态内部类的成员重名时，静态内部类访问时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.成员）去访问

第11章 枚举和注解

枚举

• 需求：要求创建季节(Season) 对象，请设计并完成。

• 创建Season对象有如下特点：
  1)季节的值是有限的几个值(spring,summer,autumn,winter)
  2)只读,不需要修改

• 解决方案-枚举
  1)枚举对应英文(enumeration,简写enum)
  2)枚举是一组常量的集合
  3)可以这里理解：枚举属于一种特殊的类，里面只包含一组有限的特定的对象。

枚举的两种实现方式

1)自定义类实现枚举
2)使用enum关键字实现枚举

自定义类实现枚举

1.不需要提供setXxx方法，因为枚举对象值通常为只读
2.对枚举对象/属性使用final + static 共同修饰，实现底层优化
3.枚举对象名通常使用全部大写,常量的命名规范
4.枚举对象根据需要,也可以有多个属性

小结：进行自定义类实现枚举，有如下特点：
1)构造器私有化
2）本类内部创建一组对象【春夏秋冬】
3)对外暴露对象(通过为对象添加public final static修饰符)
4)可以提供get方法，但是不要提供set

enum关键字实现枚举

使用enum来实现前面的枚举案例
代码:

package com.hspedu.enum_;

public class Enumeration03 {
    public static void main(String[] args) {
        System.out.println(Season2.AUTUMN);
        System.out.println(Season2.SUMMER);

    }
}


//演示使用enum关键字来实现枚举类
enum Season2{   //类


    //定义了四个对象,固定...
//    public static final Season SPRING = new Season("春天", "温暖");
//    public static final Season WINTER = new Season("冬天", "寒冷");
//    public static final Season SUMMER = new Season("夏天", "炎热");
//    public static final Season AUTUMN = new Season("秋天", "凉爽");
    //如果使用了enum来实现枚举类
    //1.使用关键字enum替代class
    //2.public static final Season SPRING = new Season("春天", "温暖") 直接使用
    //  SPRING("春天", "温暖") 解读 常量名(实参列表)
    //3.如果有多个常量(对象),使用“,”号间隔即可
    //4.如果使用enum来实现枚举,要求将定义常量对象,写在前面
    SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"), SUMMER("夏天", "炎热");

    private String name;
    private String desc;    //描述

    private Season2(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

结果：

• enum关键字实现枚举注意事项
  1.当我们使用enum关键字开发一个枚举类时，默认会继承Enum类
  2.传统的public static final Season2 SPRING = new Season2(“春天”, “温暖”);简化成SPRING(“春天”, “温暖”),这里必须知道，它调用的是哪个构造器
  3.如果使用无参构造器创建枚举对象,则实参列表和小括号都可以省略
  4.当有多个枚举对象时,使用,间隔,最后有一个分号结尾
  5.枚举对象必须放在枚举类的行首

  javap反编译
  反编译后的返回信息
  

enum常见方法

1.toString:Enum类已经重写过了,返回的是当前对象名,子类可以重写该方法,用于返回对象的属性信息
2.name:返回当前对象名(常量名),子类中不能重写
3.ordinal:返回当前对象的位置号,默认从0开始
4.values:返回当前枚举类中所有的常量
5.valueOf:将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常！
6.compare To:比较两个枚举常量，比较的就是位置号！

enum实现接口

1)使用enum关键字后,就不能再继承其他类了，因为enum会隐式继承Enum,而Java是单继承机制。
2)枚举类和普通类一样,可以实现接口
enum 类名 implements 接口1, 接口2{}

注解的理解

1)注解(Annotation)也被称为元数据(Metadata),用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息。
2)和注释一样，注解不影响程序逻辑，但注解可以被编译或运行,相当于嵌入在代码中的补充信息。
3)在JavaSE中，注解的使用目的比较简单,例如标记过时的功能，忽略警告等。在JavaEE中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替javaEE旧版中所遗留的繁冗代码和XML配置等。

• 基本的Annotation介绍
  使用Annotation时要在其前面增加@符号，并把该Annotation当成一个修饰符使用。用于修饰它支持的程序元素
  √三个基本的Annotation
  1)@Override:限定某个方法，是重写父类方法，该注解只能用于方法
  2)@Deprecated:用于表示某个程序元素(类，方法等)已过时
  3)@SuppressWarnings:抑制编译器警告

• @Override使用说明
  1.@Override表示指定重写父类的方法(从编译层面验证)，如果父类没有fly方法，则会报错
  2.如果不写@Override注解,而父类仍有public void fly(){},仍然构成重写
  3.@Override只能修饰方法，不能修饰其它类,包,属性等等
  4.查看@Override注解源码为@Target(ElementType.METHOD),说明只能修饰方法
  5.@Target是修饰注解的注解，成为元注解

• @Deprecated的说明
  - @SuppressWarnings: 抑制编译器警告

package com.hspedu.anntation_;

import java.util.ArrayList;
import java.util.List;

public class SuppressWarnings_ {

    //1.当我们不希望看到这些警告的时候,可以使用SuppressWarnings注解来抑制警告信息
    //2.在{""}中,可以写入你希望抑制(不显示)警告信息
    //3.可以指定的警告类型有
    //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，抑制与未用的程式码及停用的程式码相关的警告
    //4.关于SuppressWarnings作用范围是和你放置的位置相关
    //  比如@SuppressWarnings放置在main方法,那么抑制警告的范围就是main
    //  通常我们可以放置具体的语句,方法,类
    //5.    看看@SuppressWarnings 源码
    //(1) 放置的位置就是TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE
    //(2) 该注解有数组 String[] values() 设置一个数组比如{"rawtypes", "unchecked", "unused"}
    /*
    @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
    @Retention(RetentionPolicy.SOURCE)
    public @interface SuppressWarnings {

    String[] value();
    }
     */
    @SuppressWarnings({"rawtypes", "unchecked", "unused"})
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        int i;
        System.out.println(list.get(1));

    }
}

## JDK的元Annotation(元注解，了解)

• 元注解的基本介绍
  JDK的元Annotation用于修饰其他Annotation
  元注解：看源码时,可以知道他是干什么

• 元注解的种类(使用不多，了解，不用深入研究)
  1)Retention //指定注解的作用范围，三种SOURCE,CLASS,RUNTIME
  2)Target //指定注解可以在哪些地方使用
  3)Documented //指定该注解是否在javadoc体现
  4)Inherited //子类会继承父类注解

• @Retention注解
  √说明
  只能用于修饰一个Annotation定义，用于指定该Annotation可以保留多长时间，@Rentention包含一个RetentionPolicy类型的成员变量，使用@Rentention时必须为该value成员变量指定值

  √@Retention的三种值
  1)RetentionPolicy.SOURCE:编译器使用后，直接丢弃这种策略的注解
  2)RetentionPolicy.CLASS:编译器将把注解记录在class文件中，当运行Java程序时，JVM不会保留注解。这是默认值
  3)RetentionPolicy.RUNTIME:编译器将把注解记录在class文件中。当运行Java程序时，JVM会保留注解。程序可以通过反射获取该注解

• @Target
  √基本说明
  用于修饰Annotation定义，用于指定被修饰的Annotation能用于修饰哪些程序元素。@Target也包含一个名为value的成员变量

• @Documented
  √基本说明
  @Documented:用于指定被该元Annotation修饰的Annotation类将被javadoc工具提取文档，即在生成文档时，可以看到该注解

说明：定义为Documented的注解必须设置Retention值为RUNTIME。

• @Inherited注解
  被它修饰的Annotation将具有继承性。如果某个类使用了被@Inherited修饰的Annotation,则其子类将自动具有该注解

说明：实际应用中，使用较少，了解即可。

日期

第9章 2022年5月13日
第10章 2022年5月14日-2022年5月18日
第11章 2022年5月18日-2022年5月22日