【笔记】Java 类与对象 快速复习（记录自 韩顺平 零基础30天学会Java 部分）

1、重载

1. 基本介绍
   java中允许同一类中，多个同名方法的存在，但要求形参列表不一致。
2. 注意事项和使用细节
   1. 方法名：必须相同
   2. 参数列表：必须不同（参数类型或个数或顺序，至少有一样不同，参数名无要求）
   3. 返回类型：无要求

2、可变参数

1. 基本概念
   Java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法
2. 基本语法
   访问修饰符 返回类型 方法名(数据类型... 形参名)
3. 注意事项和使用细节
   1. 可变参数的实参可以为0个或任意多个
   2. 可变参数的实参可以为数组
   3. 可变参数的本质是数组
   4. 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
   5. 一个形参列表中只能出现一个可变参数

3、作用域（scope）

1. 基本使用
   面向对象中，变量作用域是非常重要的知识点，相对来说不是特别好理解
   1. 在Java编程中，主要的变量就是属性（成员变量）和局部变量
   2. 局部变量一般指在成员方法中定义的变量
   3. Java中作用域的分类
      全局变量：也就是属性，作用域为整个类体
      局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中
   4. 全局变量可以不赋值，直接使用，因为有默认值；局部变量必须赋值后，才能使用，因为没有默认值
2. 注意事项和细节使用
   1. 属性和局部变量可以重名，访问时遵守就近原则
   2. 在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名
   3. 属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量生命周期比较短，伴随着它的代码块执行而创建，伴随着代码块的结束而销毁。即在一次方法调用过程中。
   4. 作用域范围不同
      全局变量/属性：可以被本类使用，或其他类使用（通过对象调用）
      局部变量：只能在本类中对应的方法中使用
   5. 修饰符不同
      全局变量/属性可以加修饰符
      局部变量不可以加修饰符

4、构造方法（构造器）（constructor）

1. 基本语法
   [修饰符] 方法名(形参列表){方法体;}
2. 说明（特点）
   1. 构造器的修饰符可以默认，也可以是public、private、protected
   2. 构造器没有返回值
   3. 方法名和类名必须一样
   4. 参数列表 和 成员方法一样的规则
   5. 构造方法的调用系统完成
3. 基本介绍
   构造方法是类的一种特殊的方法，它的主要作用是完成对新对象的初始化
4. 注意事项和使用细节
   1. 一个类可以定义多个不同的构造器，即构造器的重载
   2. 构造器名和类名必须相同
   3. 构造器没有返回值
   4. 构造器是完成对象的初始化，并不是创建对象
   5. 在创建对象时，系统自动的调用该类的构造方法
   6. 如果程序员没有定义构造方法，系统自动给类生成一个默认无参数构造方法（也叫默认构造方法）
   7. 一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下，即：Person()
5. 对象创建的流程分析
   1. 加载类信息，只会加载一次
   2. 在堆中分配空间（地址）
   3. 完成对象初始化（有默认初始化和显式初始化）
   4. 把对象在堆中的地址返回给p（p是对象名。对象的引用）

5、this

1. 理解this
   看一个案例来理解this：
   
   简单的说，哪个对象调用，this就代表哪个对象

2. this的注意事项和使用细节

   1. this关键字可以用来访问本类的属性、方法、构造器

   2. this用于区分当前类的属性和局部变量

   3. 访问成员方法的语法：this.方法名(参数列表)

   4. 访问构造器语法：this(参数列表)注意只能在构造器中使用，必须放置在第一条语句

   5. this不能在类定义的外部使用，只能在类定义的方法中使用

6、包

1. 包的三大作用
   1. 区分相同名字的类
   2. 当类很多时，可以很好的管理类
   3. 控制访问范围
2. 包的基本语法
   package xxx.xxxx
   说明：
   1. package关键字表示打包
   2. xxx,xxxx：表示包名
3. 包的本质：实际上就是创建不同的文件夹/目录来保存类文件
4. 包的命名
   1. 命名规则：只能包含数字、字母、下划线、小圆点，但是不能用数字开头，不能是关键字或是保留字
   2. 命名规范：一般是小写字母+小圆点
5. 常用的包
   一个包下，包含很多的类，Java中常用的包有：
   1. java.lang.*：lang包是基本包，默认引入，不需要再引入
   2. java.util.*：util包是系统提供的工具包，工具类，使用Scanner
   3. java.net.*：网络包，网络开发
   4. java.awt.*：是做Java界面开发，GUI
6. 如何引用包：import 包

7、访问修饰符

java提供四种访问修饰符号，用于控制方法和属性（成员变量）的访问权限（范围）：

1. public：公开
2. protected：保护，对子类和同一个包中的类公开
3. 默认：没有修饰符号，向同一个包的类公开
4. private：私有，只有类本身可以访问，不对外公开
   
   使用的注意事项：
   1. 修饰符可以用来修饰类中的属性，成员方法及类
   2. 只有默认和public才能修饰类，并且遵循上述访问权限的特点
   3. 成员方法的访问规则和属性完全一样

8、面向对象的三大特征之一----封装

1. 封装（encapsulation）就是把抽象出的数据（属性）和对数据的操作（方法）封装在一起，数据被保护在内部，程序的其余部分只有通过被授权的操作（方法），才能对数据进行操作。
2. 封装的好处
   1. 隐藏实现细节
   2. 可以对数据进行验证，保证安全合理
3. 封装的实现步骤
   1. 将属性进行私有化（即不能直接修改属性）
   2. 提供一个公共的set方法，用于对属性判断并赋值

public void setXxx(类型 参数名){
    
    
	//加入数据验证的业务逻辑
	属性 = 参数名;
}

3. 提供一个公共的get方法，用于获取属性的值

public 数据类型 getXxx(){
    
    //权限判断
	return xx;
}

9、面向对象的三大特征之一----继承

1. 继承的作用
   1. 实现代码的复用
   2. 代码的扩展性和维护性提高了
2. 继承的基本语法：

class 子类 extends父类{
    
    
	
}

（1）子类就会自动拥有父类定义的属性和方法
（2）父类又叫超类/基类
（3）子类又叫派生类

3. 继承的深入讨论细节问题
   1. 子类继承了所有的属性和方法，但是私有属性不能在子类中直接访问，要通过公共的方法去访问
   2. 子类必须调用父类的构造器，完成父类的初始化
   3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会调用父类的无参构造器，如果父亲没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则编译不会通过
   4. 如果希望指定去调用父类的某个构造器，则显式的调用一下：super(参数列表)
   5. super在使用的时候，需要放在构造器第一行（super只能在构造器中使用）
   6. super()和this()都只能放在构造器的第一行因此这两个方法不能共存在同一个构造器里（super和this调用构造器不能同时出现）
   7. Java所有的类都是Object类的子类
   8. 父类构造器的调用不限于直接父类，将一直往上追溯直到Object（顶级父类）
   9. 子类最多只能继承一个父类（指直接继承），即Java中是单继承机制
   10. 不能滥用继承，子类和父类之间必须满足is-a的逻辑关系（例如Person is a Music？就不满足is-a）
   11. 父类的构造器完成父类属性的初始化，子类构造器完成子类属性的初始化

public class PC extends Computer {
    
    
    private String brand;
    public PC(String cpu, int memory, int disk, String brand) {
    
    
        super(cpu, memory, disk);
        this.brand = brand;
    }
}

4. super关键字介绍
   1. 基本介绍：super代表父类的引用，用于访问父类的属性、方法、构造器
   2. 基本语法：
      1. 访问父类的属性，但不能访问父类的private属性：super.属性名
      2. 访问父类的方法，但不能访问父类的private方法：super.方法名(参数列表)
      3. 访问父类的构造器（前面讲过）：super(参数列表)（只能放在第一句）
   3. super的细节
      1. 调用父类的构造器的好处（分工明确，父类属性由父类初始化，子类的属性由子类初始化）
      2. 当子类中有和父类中的成员（属性和方法）重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问是一样的效果。
      3. super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类中都有同名的成员，使用super访问遵循就近原则。
5. super和this的比较

No.	区别点	this	super
1	访问属性	访问本类的属性，如果本类没有此属性则从父类中继续查找	直接访问父类中的属性
2	调用方法	访问本类的方法，如果本类没有此方法则从父类中继续查找	直接访问父类中的方法
3	调用构造器	调用本类构造器，必须放在构造器的首行	调用父类的构造器，必须放在子类构造器的首行
4	特殊	表示当前对象	子类中访问父类对象

6. 方法重写
   1. 基本介绍
      简单的说，方法重写就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法重写了父类的那个方法
   2. 注意事项和使用细节
      1. 子类的方法的参数、方法名称要和父类方法的参数、方法名称完全一致
      2. 子类方法的返回类型和父类方法返回类型一样或者是父类返回类型的子类，比如父类的返回类型是Object，子类的返回类型是String
      3. 子类的方法不能缩小父类方法的访问权限
   3. 重写和重载的区别

名称	发生范围	方法名	形参列表	返回类型	修饰符
重载（overload）	本类	必须一样	类型、个数或者顺序至少有一个不相同	无要求	无要求
重写（override）	父子类	必须一样	相同	子类重写的方法，返回的类型和父类返回的类型一致，或者是其子类	子类方法不能缩小父类方法的范围

10、面向对象的三大特征之一----多态

1. 基本介绍
   方法或对象具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的。

2. 多态的具体体现

   1. 方法的多态。重写和重载就体现多态
   2. 对象的多态（重点）
      需记：
      1. 一个对象的编译类型和运行类型可以不一致
      2. 编译类型在定义对象时，就确定了，不能改变
      3. 运行类型是可以变化的
      4. 编译类型看定义时看“=”号左边，运行类型看“=”号的右边
         例如
         

3. 多态的注意事项和细节讨论

   1. 多态的前提是两个对象（类）存在继承关系
   2. 多态的向上转型
      1. 本质是父类的引用指向了子类的对象
      2. 语法：父类类型 对象名 = new 子类类型()
      3. 特点：
         1. 编译类型看左边，运行类型看右边
         2. 可以调用父类中所有成员（需遵守访问权限）
         3. 不能调用子类中特有成员，因为在编译阶段，能调用哪些成员，是由编译类型决定的。
         4. 属性没有重写之说，属性的值看编译类型
         5. 最终运行效果看子类的具体体现
   3. 多态的向下转型
      1. 语法：子类类型 对象名 = (子类类型) 父类引用;
      2. 只能强转父类的引用，不能强转父类的对象
      3. 要求父类的引用必须指向的是当前目标类型的对象
      4. 当向下转型后，可以调用子类类型中所有的成员
   4. instanceOf比较操作符
      xxx instanceOf xx用于判断对象xxx的运行类型是否为xx类型或xx类型的子类型

4. Java的动态绑定机制

   1. 当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
   2. 当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用。
      即方法看运行类型，属性看编译类型

5. 多态的应用

   1. 多态数组：数组的定义类型为父类类型，里面保存的实际元素为子类类型
   2. 多态参数：方法定义的形参类型为父类类型，实参类型允许为子类类型

11、Object类方法摘要

1. equals(Object obj)指示其他某个对象是否与此对象“相等”
   ==和equals的对比
   1. ==是一个比较运算符，既可以判断基本类型，又可以判断引用类型
   2. ==如果判断基本类型，判断的是值是否相等
   3. ==如果判断引用类型，判断的是地址是否相等，即判断的是地址是否相等，即判断是不是同一个对象
   4. equals是Object类中的方法，只能判断引用类型
   5. 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等
2. finalize()当垃圾回收器确定不存在对该对象的更多引用时，由此对象的垃圾回收器调用此方法
   1. 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作
   2. 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法
   3. 垃圾回收机制的调用，是由系统来决定（即有自己的GC算法），也可以通过System.gc()主动出发垃圾回收机制
   4. 实际开发中，几乎不会运用到finalize，更多的是为了面试。
3. getClass()返回此Object的运行时类
4. hashCode()返回该对象的哈希码值
   1. 提高具有哈希结构的容器的效率
   2. 两个引用，如果指向的是同一个对象，则哈希值一定一样
   3. 两个引用，如果指向的是不同对象，则哈希值是不一样的
   4. 哈希值主要根据地址号来的，但不能完全将哈希值等价于地址
   5. 后面再集合中，如果hashCode方法也会重写
5. toString()返回该对象的字符串表示
   1. 默认返回：全类名+@+哈希值的十六进制
   2. 子类往往重写toString方法，用于返回对象的属性信息
   3. 重写toString方法，打印对象或拼接对象时，都会自动调用该对象的toString形式
   4. 当直接输出一个对象时，toString方法会被默认的调用

12、断点调试

1. 基本介绍
   1. 在开发中，可以用断点调试，一步步的看源码执行过程，从而发现错误所在
   2. 在断点调试过程中，是运行状态，是以对象的运行类型来执行的。
   3. 断点调试快捷键：
      1. F7：跳入方法内
      2. F8：逐行执行代码
      3. shift+F8：跳出方法
      4. F9：执行到下一个断点

13、静态变量和静态方法（static）

1、静态变量

1. 什么是静态变量
   静态变量是该类所有对象共享的变量，任何一个该类的对象去访问它的时候，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。
2. 如何定义静态变量
   定义语法：访问修饰符 static 数据类型 变量名;或static 访问修饰符 数据类型 变量名;
3. 如何访问静态变量
   类名.静态变量名（推荐）或者对象名.静态变量名
   静态变量的访问也必须遵守相关的访问权限
4. 什么时候需要静态变量
   当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用静态变量
5. 静态变量与实例变量的区别：静态变量是该类的所有对象共享的，而实例变量是每个对象独享的。
6. 静态变量在类加载时就初始化了，也就是说，即使没有创建对象，只要类加载了，就可以使用静态变量了
7. 静态变量的生命周期时随类的加载开始，随着类消亡而消亡

2、静态方法

1. 基本语法：访问修饰符 static 数据返回类型 方法名(){};或static 访问修饰符 数据返回类型 方法名(){};
2. 静态方法的调用：类名.静态方法名 或 对象名.静态方法名（前提也要满足访问修饰符的访问权限和范围）
3. 静态方法的经典使用场景：
   当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法，提高开发效率
4. 静态方法使用注意事项和细节讨论
   1. 静态方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区；
   2. 静态方法中无this参数，普通方法中有thi参数
   3. 静态方法可以通过类名调用，也可以通过对象名调用
   4. 普通方法和对象有关，需要通过对象名调用，不能通过类名调用
   5. 静态方法不允许使用和对象有关的关键字，比如this和super，普通方法可以
   6. 静态方法中只能访问静态变量 或静态方法
   7. 普通成员方法既可以发个文普通变量和方法，也可以访问ing他变量和方法

14、理解main方法语法

1. main方法时虚拟机调用
2. Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须时public
3. Java虚拟机在执行main()方法时不必创建对象，所以该方法必须时static
4. 该方法接受String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数（java 执行的程序 参数1 参数2 参数3…)

15、代码块

1. 基本介绍
   代码块又称为初始化块，属于类中的成员（即是类的一部分），类似于方法，将逻辑语句封装在方法体中，通过{}包起来
   但和方法不同，没有方法名、没有返回类型、没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用
2. 基本语法

[修饰符]{
    
    
	代码
}

注意：
（1）修饰符可选，要写的话，也只能写static
（2）代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块
（3）逻辑语句可以为任何逻辑语句
（4）;可以写也可以省略

3. 不管调用哪个构造器创建对象，都会先调用代码块的内容，代码块调用顺序优先于构造器
4. 代码块注意事项和使用细节
   1. static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次，如果普通代码块，创建一个对象，就执行。
   2. 类什么时候被加载：
      1. 创建对象实例时（new）
      2. 创建子类对象实例，父类也会被加载
      3. 使用类的静态成员时（静态方法和静态属性）
   3. 普通代码块，在创建对象实例时，会被隐式调用；被创建一次就调用一次；如果只是使用类的静态成员时，普通代码块并不会执行（就是说静态代码块在类加载的时候执行且只执行一次；普通代码块创建一次对象实例就调用一次）
   4. 创建一个对象时，在一个类调用顺序是：
      1. 调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）
      2. 调用普通代码块和普通属性初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通变量初始化，则按他们定义的顺序调用）
      3. 调用构造方法
   5. 构造方法的最前面其实隐藏了super()和调用普通代码块，而静态相关的代码块、属性初始化，在类加载时，就执行完毕，因此时优先于构造器和普通代码块执行的

例如


主方法中new BBB()就会输出

6. 继承关系的静态代码块、静态属性初始化、普通代码块、普通属性初始化、构造方法的调用顺序如下：
   1. 父类的静态代码块和静态属性（优先级一样，按定义顺序执行）
   2. 子类的静态代码块和静态属性（优先级一样，按定义顺序执行）
   3. 父类的普通代码块和普通属性的初始化（优先级一样，按定义顺序执行）
   4. 父类的构造方法
   5. 子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
   6. 子类的构造方法
7. 静态代码块只能直接调用静态成员，普通代码块可以调用任意成员

16、final关键字

1. 基本介绍
   1. final可以修饰类、属性、方法和局部变量
   2. 在某些情况下，程序员可能有以下需求，就会用到final：
      1. 当不希望类被继承时，可以用final修饰
      2. 当不希望父类的某个方法被子类重写时，可以用final关键字修饰
      3. 当不希望类的某个属性的值被修改，可以用final修饰
      4. 当不希望某个局部变量
2. final使用注意事项和细节
   1. final修饰的属性又叫常量，一般用XX_XX_XX来命名
   2. final修饰的属性在定义时，必须赋初值，并且不能再修改，赋值可以在如下位置之一（选择一个位置赋初值即可）：
      1. 定义时，如public final double TAX_RATE=0.08
      2. 在构造器里
      3. 在代码块中
   3. 如果final修饰的属性是静态的，则初始化的位置只能是
      1. 定义时
      2. 在静态代码块中
         不能再构造器中赋值（因为在类加载的时候final就必须赋初值，而写在构造器中，静态属性调用的时候，类加载了，但构造器不一定会被调用）
   4. final类不能继承，但是可以实例化对象
   5. 如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承
   6. 一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成为final方法
   7. final不能修饰构造方法（即构造器）
   8. final和static往往搭配使用，效率更高，不会导致类加载，底层编译器做了优化处理
   9. 包装类（如Integer、Double、Float、Boolean等）都是final，String也是final类

17、抽象类 （abstract）

1. 基本介绍
   当父类的某些方法，需要声明，但是又不确定如何实现 时，可以将其 声明为抽象方法，那么这个类就是抽象类
2. 语法
   用abstract关键字来修饰一个类的时候，这个类就叫抽象类，基本语法如下：

访问修饰符 abstract 类名{
    
    
  代码
}

例如把一个Animal做成抽象类：

abstract class Animal{
    
    
	String name;
	int age;
	abstract public void cry();//抽象方法，子类可以将其重写
}

3. 抽象类的价值更多作用是在于设，是设计者设计好后，让子类继承并实现抽象类

4. 抽象类在框架和设计模式中使用较多

5. 抽象可以有任意成员（抽象类还是类），比如非抽象方法、构造器、静态属性等等

6. 抽象方法不能有主体，即不能加“{}”，加了就相当于有了主体
   

7. 如果一个类继承了抽象类，则必须事项抽象类的所有方法，除非它自己也声明成abstract类

8. 抽象方法不能使用private、final、static来修饰，因为这些关键字都是和重写相违背的

18、接口类

1. 基本介绍：接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来
2. 语法：

interface 接口名{
    
    
	//属性
	//方法（抽象方法、默认实现方法、静态方法）
}

class 类名 implements 接口名{
    
    
	自己属性；
	自己方法；
	必须实现的接口的抽象方法
}

3. 注意事项和细节

   1. 接口不能被实例化
   2. 接口中所有的方法是public，接口中的抽象方法可以不用abstract修饰
   3. 一个普通类实现接口，就不许将该接口的所有方法都实现
   4. 抽象类实现接口，可以不用实现接口的方法
   5. 一个类可以同时实现多个接口

   class 类名 implements 接口名1,接口名2{
         
         
   	...
   }
   

   6. 接口中的属性只能是final的，而且是public static final修饰符。比如int a = 1;实际上是public static final int a = 1;
   7. 接口中属性的访问形式：接口名.属性名
   8. 一个接口不能继承其他的类，但是一个接口可以继承多个不同的接口

   interface 类名 extends 接口名1,接口名2{
         
         
   	...
   }
   

   9. 接口的修饰符只能是public和默认，这一点和类的修饰符是一样的。

4. 小结

   1. 在jdk7之前，接口里所有方法都没有方法体
   2. jdk8后接口类可以有静态方法、默认方法，也就是说接口中可以有方法的具体实现

5. 接口和继承区别

   1. 接口和继承解决的问题不同
      继承的价值主要在于：解决代码的复用性和可维护性
      接口的价值主要在于：设计，设计好各种规范（方法），让其他类去实现这些方法
   2. 接口比继承更加灵活，继承满足的是is-a关系，而接口只需要满足like-a的关系
   3. 接口在一定程度上实现了代码的解耦
   4. 即 当子类继承了父类，就自动的拥有父类的功能；当子类需要扩展功能，可以通过实现接口的方式来扩展
   5. 可以理解为 实现接口是 Java单继承机制的一种
      

6. 接口的多态特性

   1. 多态参数
   2. 多态数组
   3. 接口的多态传递现象

19、内部类

1. 基本介绍
   一个类的内部有完整的嵌入了另一个类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。
   内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系
2. 基本语法

class Outer{
    
    //外部类
	class Inner{
    
    内部类
	
	}
}

3. 类的五大成员
   属性、方法、代码块、构造器、内部类

4. 内部类的分类

   1. 定义在外部类局部位置上（比如方法内）：
      1. 局部内部类（有类名）
      2. 匿名内部类（没有类名，重点）
   2. 定义在外部类的成员位置上：
      1. 成员内部类（没有static修饰）
      2. 静态内部类（使用static修饰）

5. 局部内部类的使用

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

6. 匿名内部类的使用

   1. 匿名内部类时定义在外部类的局部位置，比如方法中，并且没有类名，同时还是一个对象
   2. 匿名内部类的基本语法

   new 类或接口（参数列表）{
         
         
   	类体
   }
   

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

7. 成员内部类的使用

   1. 成员内部类是定义再外部类的成员位置，并且没有static修饰
   2. 可以直接访问外部类的所有成员，包括私有
   3. 可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员
   4. 作用域和外部类的其他成员一样，为整个类体
   5. 成员内部类----访问---->外部类（访问方式：直接访问）
   6. 外部类----访问---->内部类（访问方式：创建对象，再访问）
   7. 外部其他类----访问---->成员内部类
   8. 使用成员内部类的三种方法：
      1. 第一种方法，在主方法中创建对象
         语法：外部类类名.内部类类名.内部类对象名 = 外部类对象名.new 内部类类名()
      2. 第二种方法，在外部类中，编写一个方法，可以返回内部类对象
   9. 如果外部类和内部类的成员重名时，内部类访问的话，遵循就近原则，如果想访问外部类的成员，则可以使用外部类名.this.成员去访问

8. 静态内部类的使用

   1. 静态内部类时定义在外部类的成员位置上，并且有static修饰
   2. 可以直接访问外部类的所有静态成员，包括私有，但是不能访问非静态成员
   3. 可以添加任意访问修饰符
   4. 作用域：同其他的成员，为整个类体
   5. 静态内部类----访问---->外部类（比如静态方法）（访问方式：直接访问所有静态成员）
   6. 外部类----访问---->静态内部类（访问方式：创建对象，再访问）
   7. 外部其他类----访问---->静态内部类
   8. 如果外部类和静态内部类的成员重名时，静态内部类时，默认遵循就近原则，如果想访问外部类的成员，则可以使用外部类名.成员去访问

20、注解（Annotation）

1. 使用Annotation时要在其前面增加@符号，并把该Annotation当成一个修饰符使用，用于修饰它支持的程序元素
2. 三个基本的Annotation：
   1. @Override：限定某个方法，是重写父类方法，该注解只能用于方法。
   2. @Depreecated：用于表示某个程序元素（类，方法等）已过时
   3. @SuppressWarnings：抑制编译器警告
3. 元注解（了解）
   1. JDK的元注解用于修饰其他注解
   2. 本身作用不大
   3. 元注解的种类：
      1. Retention：指定注解的作用范围，三种SOURCE，CLASS，RUNTIME
      2. Target：指定注解可以再哪些地方使用
      3. Documented：指定该注解是否会在javadoc体现
      4. Inherited：子类会继承父类注解