我大学整理的最全的Java面向对象编程，学不会看不懂你来打我

Java面向对象编程

类和对象

面向对象编程

面向对象编程的概念

• 万物皆对象
• 面向对象指以属性和行为的观点去分析现实生活中的事物
• 面向对象编程指先以面向对象的思想进行分析，然后使用面向对象的编程语言进行表达的过程
• 面向对象编程是软件产业化发展的需求
• 理解面向对象的思想精髓（封装、继承、多态、[抽象]），至少掌握一种编程语言

类和对象以及引用

类和对象的概念

• 对象主要是指现实生活中客观存在的实体，在Java语言中对象体现为内存空间中的一块存储区域
• 类，简单来说就是“分类”，是对具有相同特征和行为的多个对象共性的抽象描述，在Java语言中体现为一种引用数据类型，里面包含了描述特征/属性的成员变量以及描述行为的成员方法
• 类是用于构建对象的模板，对象的数据结构由定义它的类来决定

// 类的创建
class 类名 {
    
    
    类体;
}

对象的创建

new 类名();
// 当一个类定义完毕后，可以使用new关键字来创建该类的对象，这个过程叫做类的实例化
// 创建对象的本质就是在内存空间的堆区申请一块存储区域，用于存放该对象独有特征信息

引用的定义

• 使用引用数据类型定义的变量叫作引用型变量，简称为“引用”
• 引用变量主要用于记录对象在堆区中的内存地址信息，便于下次访问

类名 引用变量名;
引用变量名.成员变量名;

成员变量的初始值

对象创建后，其成员变量可以按照默认的方式初始化

成员变量的类型	默认初始值
byte、short、int、long、float、double、char	0
boolean	false
引用类型	null

不能将所有变量声明为局部变量

• 要保证全局变量安全
• 局部变量在方法执行结束以后就会被回收
• 代码可读性差

成员方法

成员方法的定义

class 类名 {
    
    
    权限修饰符 返回值类型 成员方法名(形参列表) {
    
    
        成员方法体;
    }
} 

返回值类型的详解

• 返回值主要指从方法体内返回到方法体外的数据内容
• 返回值类型主要指返回值的数据类型，可以是基本数据类型，也可以是引用数据类型
• 当返回的数据内容是整数时，则返回值类型写int即可
• 在方法体重使用return关键字可以返回具体的数据内容并结束当前方法
• 当该方法不需要返回任何数据内容时，则返回值类型写void即可

形参列表的详解

• 形式参数主要用于将方法体外的数据内容带入到方法体内部
• 若该方法不需要带入任何数据内容时，则形参列表位置不写即可

方法体的详解

• 成员方法体主要用于编写描述该方法功能的语句块
• 成员方法可以实现代码的复用，简化代码

方法的调用

// 实际参数列表主要用于对形式参数列表进行初始化操作
// 因此，参数的个数、类型以及顺序都要完全一致
// 实际参数可以传递直接量、变量、表达式、方法的调用等
引用变量名.成员方法名(实参列表);

• 在类中定义的特征可以在成员方法中直接使用不需要引用
• 在类中定义的成员方法可以在成员方法中直接使用而不需要引用
• 在main方法中访问类中定义的特征和成员方法时需要使用引用

可变长参数

// 方法参数部分指定类型的参数个数是可以改变的，也就是0~n个
// 一个方法的形参列表中最多只能声明一个可变长形参，并且需要放到参数列表的末尾
返回值类型 方法名(参数的类型... 参数名);
// 将可变长形参当作数组来看待

方法传参的过程

static int max(int ia, int ib) {
    
    
    方法体;
}

int a = 5;
int b = 6;
int res = max(a, b);

/**
* 为main方法中的变量a、b、res分配空间并初始化
* 调用max方法，为max方法的形参变量ia、ib分配空间
* 将实参变量的数值赋值到形参变量的内存空间中
* max方法运行完毕后返回，形参变量空间释放
* main方法中的res变量得到max方法的返回值
* main方法结束后释放相关变量的内存空间
**/

参数传递的注意事项

• 基本数据类型的变量作为方法的参数传递时，形参变量数值的改变通常不会影响到实参变量的数值，因为两个变量有各自独立的内存空间
• 引用数据类型的变量作为方法的参数传递时，形参变量指向内容的改变会影响到实参变量指向内容的数值，因为两个变量指向同一块内存空间
• 当引用数据类型的变量作为方法的参数传递时，若形参变量改变指向后再改变指定的内容，则通常不会影响到实参变量指向内容的改变，因为两个变量指向不同的内存空间

引用数据类型存放的是地址，地址中才是数据

内存结构之栈区

• 栈用于存放程序运行过程中所有的局部变量。一个运行的Java程序从开始到结束会有多次方法的调用
• JVM会为没一个方法的调用在栈中分配一个对应的空间，这个空间称为该方法的栈帧。一个栈帧对应一个正在调用中的方法，栈帧中存储了该方法的参数、局部变量等数据
• 当某一个方法调用完成后，其对应的栈帧将被清除

传参的相关概念

• 参数分为实参和形参，定义方法时的参数叫形参，调用方法时传递的参数叫实参
• 调用方法时采用值传递把实参传递给形参，方法内部其实是在使用形参
• 所谓值传递就是当参数是基本类型时，传递参数的值。当参数是对象时，传递的是对象的值，也就是将对象的地址赋值给形参。

方法和封装

构造方法

class 类名 {
    
    
    // 构造方法名与类名完全相同且没有返回值类型，连void都不许有
    类名(形参列表) {
    
    
        构造方法体;
    }
}

默认构造方法

• 当一个类中没有定义任何构造方法时，编译器会自动添加一个无参空构造方法，叫做默认/缺省构造方法
• 若类中出现了构造方法，则编译器不再提供任何形式的构造方法

构造方法的作用

• 使用new关键字创建对象时会自动调用构造方法实现成员变量初始化工作。

方法重载

若方法名称相同，参数列表不同，这样的方法之间构成重载关系(Overload)。

重载的体现形式

• 方法重载的主要形式体现在：参数的个数不同、参数的类型不同、参数的顺序不同，与返回值类型和形参变量名无关，但建议返回值类型最好相同
• 判断方法是否能构成重载的核心：调用方法时能否加以区分

重载的实际意义

• 方法重载的实际意义在于调用者只需要记住一个方法名就可以调用各种不同的版本，来实现不同的功能

this关键字

• 若在构造方法中出现了this关键字，则代表当前正在构造的对象
• 若在成员方法中出现了this关键字，则代表当前正在调用的对象
• this关键字本质上就是当前类类型的引用变量

工作原理

• 在构造方法中和成员方法中访问成员变量时，编译器会加上this.的前缀，而this.相当于“我的”，当不同的对象调用同一个方法时，由于调用方法的对象不同导致this关键字不同，从而this.方式访问的结果也就随之不同。

使用方式

• 当局部变量名与成员变量名相同时，在方法体重会优先使用局部变量（就近原则）。若希望使用成员变量，则需要在成员变量的前面加上this.的前缀，明确要求该变量的成员变量。
• this关键字除了可以通过this.的方式调用成员变量和成员方法外，还可以作为方法的返回值。
• 在构造方法的第一行可以使用this()的方式来调用本类中的其它构造方法

注意事项

• 引用类型变量用于存放对象的地址，可以给引用类型赋值为null，表示不指向任何对象。
• 当某个引用类型变量为null时无法对对象实施访问（因为它没有指向任何对象）。此时，如果通过引用访问成员变量或调用方法，会产生NullPointerException异常

方法递归调用

递归的基本概念

• 递归本质就是指在方法体的内部直接或间接调用当前方法自身的形式。

注意事项

• 使用递归必须有递归的规律以及终止条件
• 使用递归必须使得问题简单化而不是复杂化
• 若递归影响到程序的执行性能，则使用递推取代之

封装

封装的概念

• 通常情况下可以在测试类给成员变量赋值一些核发单不合理的数值，无论是编译阶段还是运行阶段都不会报错或者给出提示，此时与现实生活不符
• 为了避免上述错误的发生，就需要对成员变量进行密封包装处理，来隐藏成员变量的细节以及保证成员变量数值的合理性，该机制就叫做封装

封装的实现流程

• 私有化成员变量，使用private关键字修饰
• 提供公有的get和set方法，并在方法体重进行合理值的判断
• 在构造方法中调用set方法进行合理值的判断

JavaBean的概念

• JavaBean是一种Java语言写成的可重用组件，其他Java类可以通过反射机制发现和操作这些JavaBean的属性
• JavaBean本质上就是符合以下标准的Java类：
  1. 类是公共的
  2. 有一个无参的公共的构造器
  3. 有属性，且有对应的get、set方法

static关键字和继承

static关键字

• 使用static关键字修饰成员变量表示静态的含义，此时成员变量由对象层级提升为类层级，也就是整个类只有一份并被所有对象共享，该成员变量随着类的加载准备就绪，与是否创建对象无关
• static关键字修饰的成员可以使用引用.的方式访问，但推荐类名.的方式

使用方式

• 在非静态成员方法中既能访问非静态的成员又能访问静态的成员

  （成员：成员变量 + 成员方法，静态成员被所有对象共享）

• 在静态成员方法中只能访问静态成员不能访问非静态成员

  （成员：成员变量 + 成员方法，因为此时可能还没有创建对象）

• 在以后的开发中只有隶属于类层级并被所有对象共享的内容才可以使用static关键字修饰（不能滥用static关键字）

构造块和静态代码块

• 构造块：在类体中直接使用{}括起来的代码块

  每创建一个对象都会执行一次构造块

• 静态代码块：使用static关键字修饰的构造块

  静态代码块随着类加载时执行一次

main方法

public static void main() {
    
    }

main的名称不能变是为了JVM能够识别程序运行的起点，main方法可以被重载，重载的main方法不会被执行。main方法作为程序初始线程的起点，任何其他线程均由该线程启动。对于Java中的main方法，JVM有限制，不能有返回值，所以返回值类型为void。main方法中字符串数组参数的作用是接收命令行输入的参数，命令行输入的参数之间用空格隔开。JVM内部有两种线程，非守护线程和守护线程，main方法属于非守护线程，守护线程通常由JVM自己使用，Java程序也可以表明自己的线程是守护线程。当程序中所有的非守护线程终止时，JVM退出。也可以用Runtime类或者System.exit()来退出。

单例设计模式的概念

• 在某些特殊场合中，一个类对外提供且只提供一个对象时，这样的类叫作单例类，而设计单例类的流程和思想叫作单例设计模式。

单例设计模式的优点

• 单例设计模式在内存中只有一个实例，减少了内存开支
• 单例设计模式只生成一个实例，减少了系统的性能开销
• 单例设计模式可以避免对资源的多重占用
• 单例模式可以在系统设置全局的访问点，优化和共享资源访问

单例设计模式的实现流程

• 私有化构造方法，使用private关键字修饰
• 声明本类类型的引用指向本类类型的对象，并使用private static关键字共同修饰
• 提供公有的get方法负责将对象返回出去，并使用public static关键字共同修饰

单例设计模式的实现方式

• 单例设计模式的实现方式有两种：饿汉式和懒汉式，在以后的开发中推荐饿汉式

• public class Singleton {
        
        
      private Singleton() {
        
        
          构造方法体;
      }
      
      // 饿汉式
      // 无论是否使用了该对象，在一开始的时候就创建了该对象
      private static Singleton sin = new Singleton();
      
      public static Singleton getInstance() {
        
        
          return sin;
      }
      
      
      // 懒汉式
      // 当程序获取该单例对象时，会判断该对象是否已经创建。
      // 当只有第一次使用该对象时会创建对象（如果不使用该对象就不创建）
      private static Singleton sin = null;
      
      public static Singleton getInstance() {
        
        
          if (sin == null) {
        
        
              sin = new Singleton();
          }
          return sin;
      }
      
  }
  
  

**懒汉式单例模式是线程不安全的。**当并发量增加时则可能在内存中出现多个实例，破坏了最初的预期。因为多个线程在执行的时候如果此时判断对象为空，就会创建对象，这样会在内存中出现多个对象。

继承

• 当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成一个公共类，让多个类吸收公共类已有特征的行为而在多个类型只需要编写自己独有特征和行为的机制

• Java语言中使用extends关键字来表示继承关系

• 使用继承提高了代码的复用性，可维护性及扩展性，是多态的前提条件

继承的特点

• 子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承只是不能直接访问
• 无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法，来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加代码super()的效果
• 使用继承必须满足逻辑关系，不能滥用继承
• Java语言中只支持单继承不支持多继承，一个父类可以有多个子类，但一个子类只能有一个父类

方法重写的概念

• 从父类中继承下来的方法不满足子类的需求时，就需要在子类中重新写一个和父类一样的方法来覆盖从父类中继承下来的版本，该方式叫做方法的重写（Override）

方法重写的原则

• 要求方法名相同、参数列表相同以及返回值类型相同，从Java5开始允许返回子类类型
• 要求方法的访问权限不能变小，可以相同或者变大
• 要求方法不能抛出更大的异常（异常机制）

类加载过程

• 先执行父类的静态代码块，再执行子类的静态代码块
• 之后执行父类的构造块，父类的构造方法
• 最后执行子类的构造块，子类的构造方法

访问控制

常用的访问控制符

修饰符	本类	同一个包中的类	子类	其他类
public	可以访问	可以访问	可以访问	可以访问
protected	可以访问	可以访问	可以访问	不能访问
default	可以访问	可以访问	不能访问	不能访问
private	可以访问	不能访问	不能访问	不能访问

注意事项

• public修饰的成员可以在任意位置使用
• private修饰的成员只能在本类内部使用
• 通常情况下，成员方法都使用public关键字修饰，成员变量都使用private关键字修饰

package语句的由来

• 定义类时需要指定类的名称，但如果仅仅将类名作为类的唯一标识，则不可避免的出现命名冲突的问题。这会给组件复用以及团队间的合作造成很大的麻烦
• 在Java语言中，用包的概念来解决命名冲突的问题

包的定义

• 在定义一个类时，除了定义类的名称一般还要指定一个包名
• 为了实现项目管理、解决命名冲突以及权限控制的效果

定义包的规范

• 包的命名需要按照一定的规范

包的导入

• 使用import关键字导入包
• 使用import关键字导入静态成员，从Java5开始支持

final关键字

final本意为“最终的、不可改变的”，可以修饰类、成员方法以及成员变量

使用方式

• final关键字修饰类体现在该类不能被继承
  • 主要用于防止滥用继承
• final关键字修饰成员方法体现在该方法不能被重写但可以被继承
  • 主要用于防止不经意间造成重写
• final关键字修饰成员变量体现在该变量必须初始化且不能改变
  • 主要用于防止不经意间造成改变

常量的概念

• 在以后的开发中很少单独使用final关键字来修饰成员变量，通常使用public static final关键字共同修饰成员变量来表达常量的含义，常量的命名规范要求是所有字母都要大写，不同的单词之间采用下划线连

多态和特殊类

多态

• 多态主要是指同一种事物表现出来的多种形态

多态的语法格式

父类类型 引用变量名 = new 子类类型();

多态的特点

• 当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法
• 当父类类型的引用指向子类类型的对象时，父类类型的引用不可以直接调用子类独有的方法
• 对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段调用子类重写的版本（动态绑定）
• 对于父子类都有的静态方法，编译和运行阶段都的调用父类版本

static修饰的方法隶属于类，该类的任何引用调用都不会有区别。而多态是希望通过不同的引用得到不同的结果。

引用数据类型之间的转换

• 引用数据类型之间的转换方式有两种：自动类型转换和强制类型转换

• 自动类型转换主要指小类型向大类型的转换，也就是子类转为父类，也叫作向上转型

• 强制类型转换主要指大类型向小类型的转换，也就是父类转为子类，也叫做向下转型或显式类型转换

• 引用数据类型之间的转换必须发生在父子类之间，否则编译报错

• 若强转的目标类型并不是该引用真正指向的数据类型时则编译通过，运行阶段发生类型转换异常

• 为了避免上述错误的发生，应该在强转之前进行判断，格式如下：

  // 判断引用变量指向的对象是否为后面的数据类型
  if (引用变量 instanceof 数据类型)
  
  

多态的实际意义

• 多态的实际意义在于屏蔽不同子类的差异性实现通用的编程带来不同的效果

父类对象调用子类拥有的从父类继承的方法，可以表现出不同的效果。

抽象类

抽象方法的概念

• 抽象方法主要指不能具体实现的方法并且使用abstract关键字修饰，也就是没有方法体

• 具体格式如下：

  // 访问权限 abstract 返回值类型 方法名(形参列表);
  public abstract void 方法名(形参列表);
  
  

抽象类的概念

• 抽象类主要指不能具体实例化的类并且使用abstract关键字修饰，也就是不能创建对象。不能创建对象的原因是可能存在抽象方法，而抽象方法是没有方法体的，调用抽象方法没有意义。

final和abstract不能共同修饰抽象方法；static和abstract不能共同修饰抽象方法。

抽象类和抽象方法的关系

• 抽象类中可以有成员变量、构造方法、成员方法
• 抽象类中可以没有抽象方法
• 拥有抽象方法的类必须是抽象类，因此真正意义上的抽象类应该是具有抽象方法并且使用abstract关键字修饰的类

抽象类的实际意义

• 抽象类的实际意义不在于创建对象而在于被继承
• 当一个类继承抽象类后必须重写抽象方法，否则该类也变成抽象类，也就是抽象类对子类具有强制性和规范性，因此叫做模板设计模式

开发经验分享

• 在以后的开发中推荐使用多态的格式，此时父类类型引用直接调用的所有方法一定是父类中拥有的方法，若以后更换子类时，只需要将new关键字后面的子类类型修改而其他地方无需改变就可以立即生效，从而提高了代码的可维护性和可扩展性。
• 该方法的缺点就是：父类引用不能直接调用子类独有的方法，若调用则需要强制类型转换

接口

• 接口就是一种比抽象类还抽象的类，体现在所有方法都为抽象方法
• 定义类的关键字是class，而定义接口的关键字是interface

接口中不允许使用protected关键字修饰抽象方法，public关键字可以省略

类和接口之间的关系

名称	关键字	关系
类和类之间的关系	使用extends关键字表达继承关系	支持单继承
类和接口之间的关系	使用implements关键字表达实现关系	支持多实现
接口和接口之间的关系	使用extends关键字表达继承关系	支持多继承

抽象类和接口的主要区别

• 定义抽象类的关键字是abstract class，而定义接口的关键字是interface
• 继承抽象类的关键字是extends，而实现接口的关键字是implements
• 继承抽象类支持单继承，而实现接口支持多实现
• 抽象类中可以有构造方法，而接口中不可以有构造方法
• 抽象类中可以有成员变量，而接口中只可以有常量
• 抽象类中可以有成员方法，而接口中只可以有抽象方法
• 抽象类中增加方法时子类可以不用重写，而接口中增加方法时实现类需要重写（Java8以前的版本）
• 从Java8开始增加新特性，接口中允许出现非抽象方法和静态方法，但非抽象方法需要使用default关键字修饰
• 从Java9开始增加新特性，接口中允许出现私有方法

特殊类

内部类

• 当一个类的定义出现在另外一个类的类体中时，那么这个类叫做内部类(Inner)，而这个内部类所在的类叫作外部类(Outer)。
• 类中的内容：成员变量、成员方法、构造方法、静态成员、构造块和静态代码块、内部类。

实际作用

• 当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个类定义为所服务类中的内部类，这样可以隐藏该类的实现细节并且可以方便的访问外部类的私有成员而不再需要提供公有的get和set方法。

内部类的分类

• 普通内部类：直接将一个类的定义放在另外一个类的类体中
• 静态内部类：使用static关键字修饰的内部类，隶属于类层级
• 局部内部类：直接将一个类的定义放在方法体的内部时
• 匿名内部类：没有名字的内部类

普通（成员）内部类的格式

访问修饰符 class 外部类的类名 {
    
    
    访问修饰符 class 内部类的类名 {
    
    
        内部类的类体;
    }
}

普通内部类的使用方式

• 普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等
• 普通内部类和普通类一样可以使用final或者abstract关键字修饰
• 普通内部类还可以使用private或protected关键字进行修饰
• 普通内部类需要使用外部类对象来创建对象
• 如果内部类访问外部类中与本类内部同名的成员变量或方法时，需要使用this关键字

静态内部类的格式

访问修饰符 class 外部类的类名 {
    
    
    访问修饰符 static class 内部类的类名 {
    
    
        内部类的类体;
    }
}

静态内部类的使用方式

• 静态内部类不能直接访问外部类的非静态成员
• 静态内部类可以直接创建对象
• 如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问

局部（方法）内部类的格式

访问修饰符 class 外部类的类名 {
    
    
    访问修饰符 返回值类型 成员方法名(形参列表) {
    
    
        class 内部类的类名 {
    
    
            内部类的类体;
        }
    }
}

局部内部类的使用方式

• 局部内部类只能在该方法的内部可以使用
• 局部内部类可以在方法体内部直接创建对象
• 局部内部类不能使用访问控制符和static关键字符修饰
• 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致

匿名内部类的语法格式

接口/父类类型 引用变量名 = new 接口/父类类型() {
    
    
    方法的重写;
};

回调模式的概念

• 回调模式是指——如果一个方法的参数是接口类型，则在调用该方法时，需要创建并传递一个实现此接口的对象；而该方法在运行时会调用到参数对象中所实现的方法（接口中定义的）

开发经验分享

• 当接口/类类型的引用作为方法的形参时，实参的传递方式有两种：
  1. 自定义类实现接口/继承类并重写方法，然后创建该类对象作为实参传递
  2. 使用上述匿名内部类的语法格式得到接口/类类型的引用即可

枚举

• 在日常生活中有些事物的取值只有明确的几个固定值，此时描述这些事物的所有值都可以一一列举出来，而这个列举出来的类型就叫做枚举类型

枚举的定义

• 使用public static final表示的常量描述较为繁琐，使用enum关键字来定义枚举类型取代常量，枚举类型是从Java5开始增加的一种引用数据类型
• 枚举值就是当前类的类型，也就是指向本类的对象，默认使用public static final关键字共同修饰，因此采用枚举类型.的方式调用
• 枚举类可以自定义构造方法，但是构造方法的修饰符必须是private，默认也是私有的

Enum类的概念和方法

• 所有的枚举类都继承自java.lang.Enum类，常用方法如下：

  函数名	作用
  static T[] values()	返回当前枚举类中的所有对象
  String toString()	返回当前枚举类对象的名称
  int ordinal()	获取美剧对象在枚举类中的索引位置
  static T valueOf(String str)	将参数指定的字符串名转为当前枚举类的对象
  int compareTo(E o)	比较两个枚举对象在定义时的顺序

打印枚举类引用时，会自动调用toString方法。

枚举类实现接口的方式

• 枚举类实现接口后需要重写抽象方法，而重写方法的方式有两种：重写一个，或者每个对象都重写

注解

• 注解(Annotation)又叫标注，是从Java5开始增加的一种引用数据类型。
• 注解本质上就是代码中的特殊标记，通过这些标记可以在编译、类加载、以及运行时执行指定的处理
• 若一个注解中没有任何内容，则该注解仅仅是标记注解

注解的语法格式

访问修饰符 @interface 注解名称 {
    
    
    注解成员;
}

• 自定义注解自动继承java.lang.annotation.Annotation接口
• 通过@注解名称的方式可以修饰包、类、成员方法、成员变量、构造方法、参数、局部变量的声明等

注解的使用方式

• 注解体中只有成员变量没有成员方法，而注解的成员变量以“无形参的方法”形式来声明，其方法名定义了该成员变量的名字，其返回值定义了该变量的类型
• 如果注解只有一个参数成员，建议使用参数名为value，而类型只能是八种基本数据类型、String类型、Class类型、enum类型及Annotation类型

元注解的概念

• 元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其他的注解上面
• 元注解主要有@Retention、@Documented、@Target、@Inherited、@Repeatable

元注解@Retention

• @Retention应用到一个注解上用于说明该注解的生命周期，取值如下：

  RetentionPolicy.SOURCE注解只在源码阶段保留，在编译器进行编译时他将被丢弃忽视

  RetentionPolicy.CLASS注解只被保留到编译进行的时候，它并不会被加载到JVM中，默认方式

  RetentionPolicy.RUNTIME注解可以保留到程序运行的时候，它会被加载进入到JVM中，所以在程序运行时可以获取到它们

元注解@Documented

• 使用javadoc工具可以从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档，而该工具抽取时默认不包括注解内容
• @Documented用于指定被该注解将被javadoc工具提取成文档
• 定义为@Documented的注解必须设置Retention值为RUNTIME

元注解@Target

• @Target用于指定被修饰的注解能用于哪些元素的修饰，取值如下：

  元素名	含义
  ElementType.ANNOTATION_TYPE	可以给一个注解进行注解
  ElementType.CONSTRUCTOR	可以给构造方法进行注解
  ElementType.FIELD	可以给属性进行注解
  ElementType.LOCAL_VARIABLE	可以给局部变量进行注解
  ElementType.METHOD	可以给方法进行注解
  ElementType.PACKAGE	可以给一个包进行注解
  ElementType.PARAMETER	可以给一个方法内的参数进行注解
  ElementType.TYPE	可以给类型进行注解，比如类、接口、枚举

元注解@Inherited

• @Inherited并不是说注解本身可以继承，而是说如果一个超类被该注解标记过的注解进行注解时，如果子类没有被任何注解应用时，则子类就继承超类的注解

元注解@Repeatable

• @Repeatable表示自然可重复的含义，从Java8开始增加的新特性
• 从Java8开始对元注解@Target的参数类型ElementType枚举值增加了两个：
  1. 其中ElementType.TYPE_PARAMETER表示该注解能写在类型变量的声明语句中，如：泛型
  2. 其中ElementType.TYPE_USE表示该注解能写在适用类型的任何语句中

常见的预制注解

• 预制注解就是Java语言自身提供的注解，具体如下：

  注解类型	含义
  @author	标明开发该类模块的作者，多个作者之间用逗号分隔
  @version	标明该类模块的版本
  @see	参考转向，也就是相关主题
  @since	从哪个版本开始增加的
  @param	对方法中某参数的说明，如果没有参数就不能写
  @return	对方法返回值的说明，如果方法的返回值类型是void就不能写
  @exception	对方法可能抛出的异常进行说明
  @Override	限定重写父类方法，该注解只能用于方法
  @Deprecated	用于表示所修饰的元素（类、方法等）已过时
  @SuppressWarnings	抑制编译器警告