Java学习日记day11
内部类：
一个类中存在另一个类
内部类的分类：
成员内部类（非静态内部类） 静态内部类 局部内部类（匿名内部类）
内部类的成员方法中调用同名外部类的成员变量：外部类.this.变量名
调用同名内部类的成员变量：this.变量名
调用方法内的局部变量：直接变量名
成员内部类特点：
可以使用的内部修饰符：public private protected default
1. 内部类中，可以随意调用外部类成员
2. 外部类中，使用内部类成员是，需要创建内部类对象
3. 无关类中使用成员内部类
A．间接调用 在外部类中的方法创建类的对象
b. 直接调用 创建内部类对象
局部内部类[匿名内部类]
局部变量：
- 在方法内部定义的类，只在方法中有效
- 在局部内部类中，使用局部变量，必须是final修饰的
- 一次性的类，只能使用一次
- 没有访问修饰符
- 作用：结合抽象类/接口使用
[*匿名内部类]
作用：实现接口/继承抽象类
缺点：一次性使用
语法： 接口/抽象类 引用名 = new 接口/抽象类（）{实现类实现的抽象方法}
Lambda表达式：特殊用法，需要一个只有一个抽象方法的接口
用法：定义一个参数为接口的方法 调用这个方法 例如：
接口：public interface InterfaceA {
void doSomething();
}
方法 ：public void lambda(InterfaceA Interface){
Interface.doSomething();
}
具体实现
lambda(()->{System.out.println("use lambda do something!!!!");});
匿名对象：
只能使用一次，只能调用一次方法（可以在所有类的范围内适用）
静态内部类
静态内部类不能调用非静态的成员变量和方法
复习：
面向对象
类和对象
类
类是抽象的，不真实存在
类的结构：class 类名{成员变量，成员方法，构造方法，静态变量，静态方法，代码块，静态代码块}
类的特点：具有相同的属性和方法
对象
对象是真实存在的，是类的实例化
创建对象:对象都是通过new创建出来的
类名 对象名 = new 类名()；
使用对象
使用变量 : 对象.属性
使用方法 ： 对象.方法名()
类和对象的关系
1.先定义/声明类 ps: class Student{ }
2.再创建类的对象 -> main方法中创建 ps: Student stu = new Student
变量
局部变量
声明位置
形参（方法参数中定义的变量）
方法中
代码块中
初始化
使用前必须初始化，否则通不过编译，局部变量没有默认初始值
个数
声明个数
JVM内存图中位置：存在栈内存中
注意：局部变量不能加static，包括protected, private, public这些也不能加。局部变量保存在栈中。
局部编程必须在声明时初始化。
成员变量
实例变量
声明位置：类中
初始化
声明同时初始化
代码块中初始化
构造方法中初始化
个数：由对象决定，有几个对象就有几个成员变量
JVM内存图中位置：存在于堆内存中
静态变量
声明位置：类中
初始化
在声明同时初始化
静态代码块中初始化
个数
只有1个
JVM内存图中位置：存在于方法区中
实例变量的静态变量的区别
语法上
静态变量：前面要加static关键词
实例变量：不用加
程序上
静态变量：属于类，只要进行了类加载，就会分配空间并使用
实例变量：属于对象，必须创建对象，才会分配空间，才能使用这个实例变量
代码块
静态代码块
结构： static { }
位置：存在类中
执行时机：在虚拟机加载类的时候就会进行加载，并且只执行一次
作用：有些代码需要在项目启动时就执行的，就需要使用静态代码块
比如一个项目启动需要加载很多配置文件等资源，就可以都放在静态代码块中。
代码块
结构： { }
位置：存在类中
执行时机：在创建对象的时候执行，每次创建对象都会执行一次
作用：提取构造方法中相同部分，并且初始化成员变量，会在构造方法之前执行
构造方法
作用
给成员变量初始化
语法：修饰符 没有返回值类型 类名(参数){ }
无参数是无参构造器
有参数是有参构造器
使用
1.对象创建时调用相对应的构造方法
2.默认调用无参构造器
3.如果指定添加有参构造器，无参构造器就不添加
4.建议：什么情况下都建议手动添加无参构造器，方便调用
构造方法和普通方法的区别
执行时间不同
构造方法：对象创建时调用相对应的构造构造方法
2.普通方法：只有被调用时才会执行
方法
普通成员方法
语法上：没有static修饰的方法
位置：存在于类中
方法的调用： 对象.成员方法
静态成员方法
语法上：有static修饰的方法
位置：存在于类中
方法的调用： 类.静态方法
注意
1.静态方法只能访问静态成员（即静态成员变量和静态方法）
2.普通方法可以访问静态成员，也可以访问其它普通方法
继承
继承的概念
继承就是⼦类继承⽗类的属性和⾏为，使得⼦类对象具有与⽗类相同的属性、相同的⾏为。
继承的特点
1.子类拥有父类中非private的属性和方法
2.子类可以拥有自己的属性和方法，即子类可以对父类进行扩充
3.java中的继承只能单继承，即子类只能有一个父类
4.父类可以有多个子类，并且子类之间没有直接联系
5.子类可以用自己的方式实现父类方法 - 重写
继承的关键字
extends 和 implements 继承类 和实现接口
super 和 this 关键字
this
指当前对象
1.this可以调用自己的成员变量，也可以调用自己的成员方法
2.this可以调用自己的构造方法，this关键词不能省，调用时只能放在构造方法的第一行，并且不能同时互相调用
super
对父类对象的引用 - （在对象内部使用）
1.子类构造方法中一定都会先默认调用父类的无参构造器，使用super关键词调用
2.super()只能放在构造方法中的第一行
final关键词
final：表示最终的，不可被改变的
final修饰的特点
1.final修饰的类，不能被继承
2.final修饰的方法，不能被覆盖
3.final修饰的变量，不能被修改 - 变量的值只能赋一次值，即变为常量
继承中的构造器
1.子类不能继承父类中的构造方法
2.子类会默认调用父类的无参构造器
3.如果父类中只有，有参构造器，则需要在子类构造器中手动调用父类的有参构造器
方法的重写和方法的重载
方法的重写
重写的规则
1.子类中定义的方法, 方法返回值类型\方法名\参数列表都和父类中定义的方法完全一致
2.子类重写方法的访问权限不能比父类中被重写方法的访问权限低
3.声明为final的方法不能被重写
4.构造方法不能被重写
5.存在父类和子类中，子类重写父类中相同的方法
方法的重载
重载的规则
1.重载的只跟方法名和方法参数有关（参数：个数/顺序/类型）
2.重载跟返回值类型无关
3.存在同一个类中
封装
概念
1.封装戏就是把属性私有化，不让外部可以访问
2.给外部提供一个公开的方法:get/set方法
访问修饰符
public
全部可见
protected
同一个包下，子类，本类
default
只能在本类和同一个包中可以见
private
本类可见
多态
存在的必要条件
1.必须有继承关系存在
2.方法重写
3.父类引用指向子类对象(向上造型)
例如： Animal an = new Dog（）；
多态的转型
向上转型
ps: Animal an = new Dog（）；
父类型的引用 指向 子类型的对象
注意：只可以调用父类中所声明的属性和方法
向下转型
ps： Dog d = (Dog)an； ->通过父类实例化子类
注意：只有转换回子类真实类型，才能调用子类独有的属性和方法
instanceof关键词
作用：防止发生类型转换异常（ClassCastException）
用法: if（对象 instanceof 类型）{ }
返回结果：boolean类型
成员访问特点
成员变量：编译看左边，运行看左边
成员方法：编译看左边，运行看右边
静态方法：编译看左边，运行看左边
抽象
抽象类
abstract修饰
类
抽象类，不具体的类（没有包含足够的信息来描绘一个具体的对象）
特征
1.抽象类不能被实例化，也就是不能new对象，只能被继承
2.含有抽象方法的类，一定是抽象类。反之，抽象类中可以没有抽象方法
3.抽象类可以包含属性、方法、构造方法，但构造方法不能用来实例化对象，只能被子类调用。
方法
抽象方法
特征
1.只有方法声明没有方法体
2.抽象方法必须存在抽象类中
3.子类重写父类时，必须重写父类中所有的抽象方法
4.使用抽象方法时不能使用private修饰，因为抽象方法必须被子类重写，如果使用了private声明，则子类无法重写
5.abstract只能用于修饰普通方法，不能用于static方法或构造方法中
变量 -> 没有意义
接口(interface)
定义：接口是一种特殊的抽象类
特点
1.接口中包含
变量
变量名前面默认添加：public static final ->静态常量
声明的同时初始化
方法
抽象方法
没有方法体的方法
方法前面默认添加：public abstract
作用：供子类重写
静态方法
有方法体的方法
使用static修饰，供接口直接调用
默认方法
有方法体的方法
使用default修饰，不可省略，供子类调用或子类重写
改成默认方法后可以选择重写与否
default修饰方法只能在接口中使用，标记为普通方法
私有方法
有方法体的方法
使用private修饰，供接口中的默认方法或静态方法调用
静态私有
private static 修饰
普通私有
private 修饰
2.接口没有构造方法，不能被实例化
3.接口支持多继承，但接口只能继承接口，不能继承类
4.一个类可以同时实现多个接口，使用时必须实现接口中的所有抽象方法，否则该类必须被定义为抽象类
内部类
作用：间接解决java中类不能多继承的问题
种类
成员内部类
1.作为成员存在，可以被权限修饰符修饰
2.可以调用外部所有信息
3.可以和外部类属性/方法重名， 调用时：外部类名。this。属性/方法
静态内部类
1.作为静态成员属性存在，可以被任意权限修饰符修饰
2.可以直接调用外部类static相关的属性和方法
3.访问外部类普通属性和方法，则需要通过new外部类去访问
局部内部类
1.存在方法之中，只能在方法中使用，类前不能有访问权限
2.局部内部类只在当前方法中有效
3.不能定义static成员，因为在方法结束后，内存需要释放
4.局部内部类中可以访问外部类的所有成员
2.可以直接访问方法的局部变量，但无法修改,编译会出错
匿名内部类
1.作用：继承抽象类/实现接口
2.没有类名的内部类，必须在创建时使用new语句来声明类
ps：Outer o = new Outer(){ 重写 }
3.匿名类和局部内部类一样，存在方法中，可以访问外部类的所有成员。
4.匿名类中允许使用非静态代码块进行成员初始化操作
5.匿名类的非静态代码块会在父类的构造方法之后被执行
![Jmeter json请求中带汉字处理[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)