一、知识点复习
1-关键字：static
文章链接：
Java面向对象（高级）-- static关键字的使用-CSDN博客
1、知识点
【static关键字的使用】
static: 静态的
static 用来修饰的结构：属性、方法; 代码块、内部类；（构造器不能够用static修饰）
static修饰属性
3.1 复习：变量的分类
方式1：按照数据类型：基本数据类型、引用数据类型
方式2：按照类中声明的位置：
成员变量：按照是否使用static修饰进行分类：
使用static修饰的成员变量：静态变量、类变量
不使用static修饰的成员变量：非静态变量、实例变量局部变量：方法内、方法形参、构造器内、构造器形参、代码块内等。
3.2 静态变量：类中的属性使用static进行修饰。
对比静态变量与实例变量：
① 个数
>静态变量：在内存空间中只有一份，被类的多个对象所共享。
>实例变量：类的每一个实例（或对象）都保存着一份实例变量。
② 内存位置
>静态变量：jdk6及之前：存放在方法区。 jdk7及之后：存放在堆空间
>实例变量：存放在堆空间的对象实体中。
③ 加载时机
>静态变量：随着类的加载而加载，由于类只会加载一次，所以静态变量也只有一份。
>实例变量：随着对象的创建而加载。每个对象拥有一份实例变量。
④ 调用者
>静态变量：可以被类直接调用，也可以使用对象调用。
>实例变量：只能使用对象进行调用。
⑤ 判断是否可以调用 —> 从生命周期的角度解释
类变量 实例变量
类 yes no
对象 yes yes
⑥ 消亡时机
>静态变量：随着类的卸载而消亡
>实例变量：随着对象的消亡而消亡
static修饰方法：（类方法、静态方法）
随着类的加载而加载
可以通过“类.静态方法”的方式，直接调用静态方法
静态方法内可以调用静态的属性或静态的方法。（属性和方法的前缀使用的是当前类，可以省略）
不可以调用非静态的结构。（比如：属性、方法）类方法 实例方法 类 yes no 对象 yes yesstatic修饰的方法内，不能使用this和super
补充：在类的非静态方法中，可以调用当前类中的静态结构（属性、方法）或非静态结构（属性、方法）
开发中，什么时候需要将属性声明为静态的？
判断当前类的多个实例是否能共享此成员变量，且此成员变量的值是相同的。
开发中，常将一些常量声明是静态的。比如：Math类中的PI什么时候需要将方法声明为静态的？
方法内操作的变量如果都是静态变量（而非实例变量）的话，则此方法建议声明为静态方法
开发中，常常将工具类中的方法，声明为静态方法。比如：Arrays类、Math类
2、重点
- static：静态的，随着类的加载而加载、执行。
- static用来修饰：属性、方法、代码块、内部类 （不能用来修饰构造器）
- 熟悉：static修饰的类变量、类方法与不使用static修饰的区别。
- 类变量：类的生命周期内，只有一个。被类的多个实例共享。
- 掌握：我们遇到属性或方法时，需要考虑是否声明为static的。
2-单例模式（或单子模式）
文章链接：
Java面向对象（高级）-- 单例(Singleton)设计模式-CSDN博客
1、知识点
设计模式概述：
设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。
就像是经典的棋谱，不同的棋局，我们用不同的棋谱。“套路”
经典的设计模式一共有23种。何为单例模式(Singleton)：
所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如何实现单例模式（掌握）:
饿汉式
懒汉式对比两种模式（特点、优缺点）
特点：
饿汉式：“立即加载”,随着类的加载，当前的唯一实例就创建了
懒汉式：“延迟加载”,在需要使用的时候，进行创建。
优缺点：
饿汉式：（优点）写法简单，由于内存中较早加载，使用更方便、更快。是线程安全的。 （缺点）内存中占用时间较长。
懒汉式：（缺点）线程不安全 （放到多线程章节时解决）（优点）在需要的时候进行创建，节省内存空间。
2、重点
- 经典的设计模式有23种
- 解决的问题：在整个软件系统中，只存在当前类的唯一实例。
- 实现方式：饿汉式、懒汉式、枚举类等
- 对比饿汉式和懒汉式
- 饿汉式：“立即加载”，线程安全的。
- 懒汉式：“延迟加载”，线程不安全。
- 需要会手写饿汉式和懒汉式
3-理解main()方法
文章链接：
Java面向对象（高级）-- 单例(Singleton)设计模式-CSDN博客
1、知识点
【main()方法的剖析】
public static void main(String args[]){}
理解1：看做是一个普通的静态方法
理解2：看做是程序的入口，格式是固定的。与控制台交互
如何从键盘获取数据？
方式1：使用Scanner
方式2：使用main()的形参进行传值。
2、重点
public static void main(String[] args){}- public：公共的 、static：由类进行调用 （拿对象来调用不合适，因为这是程序入口，造对象也需要通过入口进去） 、void：不需要返回值 、String[] args：形参，可以传递参数，之前演示了通过命令行、IDEA来传递参数
- 理解1：作为程序的入口；普通的静态方法
- 理解2：如何使用main()与控制台进行数据的交互。
- 命令行：java 类名 “Tom” “Jerry” “123”
4-类的成员之四：代码块
文章链接：
Java面向对象（高级）-- 类的成员之四：代码块-CSDN博客
1、知识点
【类的成员之四：代码块】
回顾：类中可以声明的结构：属性、方法、构造器；代码块（或初始化块）、内部类
代码块：从长的样子来看的（就是封装了一下代码）
初始化块：从它的作用的角度
代码块（或初始化块）的作用：
用来初始化类或对象的信息（即初始化类或对象的成员变量）代码块的修饰：
只能使用static进行修饰。代码块的分类：
静态代码块：使用static修饰
非静态代码块：没有使用static修饰具体使用：
4.1 静态代码块：
随着类的加载而执行（它没有名字，就不能显示地调用它）
由于类的加载只会执行一次，进而静态代码块的执行，也只会执行一次
作用：用来初始化类的信息
内部可以声明变量、调用属性或方法、编写输出语句等操作。
静态代码块的执行要先于非静态代码块的执行
如果声明有多个静态代码块，则按照声明的先后顺序执行
静态代码块内部只能调用静态的结构（即静态的属性、方法），不能调用非静态的结构（即非静态的属性、方法）
4.2 非静态代码块：
随着对象的创建而执行
每创建当前类的一个实例，就会执行一次非静态代码块
作用：用来初始化对象的信息
内部可以声明变量、调用属性或方法、编写输出语句等操作。
如果声明有多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内部可以调用静态的结构（即静态的属性、方法），也可以调用非静态的结构（即非静态的属性、方法）
2、重点
- 分类：静态代码块、非静态代码块
- 使用频率上来讲：用的比较少。
- 静态代码块：随着类的加载而执行
- 非静态代码块：随着对象的创建而执行
【属性赋值的过程】
文章链接：
Java面向对象（高级）-- 类中属性赋值的位置及过程_java 给属性赋值-CSDN博客
可以给类的非静态的属性（即实例变量）赋值的位置有：
① 默认初始化
② 显式初始化 或 ⑤ 代码块中初始化
③ 构造器中初始化
####################################
④ 有了对象以后，通过"对象.属性"或"对象.方法"的方法进行赋值执行的先后顺序：
① - ②/⑤ - ③ - ④(超纲)关于字节码文件中的的简单说明：(通过插件jclasslib bytecode viewer查看)
方法在字节码文件中可以看到。每个方法都对应着一个类的构造器。（类中声明了几个构造器就会有几个）
编写的代码中的构造器在编译以后就会以方法的方式呈现
方法内部的代码包含了实例变量的显示赋值、代码块中的赋值和构造器中的代码。
方法用来初始化当前创建的对象的信息的。给实例变量赋值的位置很多，开发中如何选？
显示赋值：比较适合于每个对象的属性值相同的场景
构造器中赋值：比较适合于每个对象的属性值不相同的场景
5-关键字：final
文章链接：
Java面向对象（高级）-- final关键字的使用-CSDN博客
1、知识点
【final关键字的使用】
final的理解：最终的
final可以用来修饰的结构：类、方法、变量
具体说明：
3.1 final修饰类：表示此类不能被继承。
比如：String、StringBuffer、StringBuilder类
3.2 final修饰方法：表示此方法不能被重写
比如：Object类中的getClass()
3.3 final修饰变量：既可以修饰成员变量，也可以修饰局部变量。
此时的"变量"其实就变成了"常量"，意味着一旦赋值，就不可更改。
3.3.1 final修饰成员变量: 有哪些位置可以给成员变量赋值？
显式赋值
代码块中赋值
构造器中赋值
3.3.2 final修饰局部变量：一旦赋值就不能修改
方法内声明的局部变量：在调用局部变量前，一定需要赋值。而且一旦赋值，就不可更改
方法的形参：在调用此方法时，给形参进行赋值。而且一旦赋值，就不可更改
- final与static搭配：修饰成员变量时，此成员变量称为：全局常量。
比如：Math的PI
2、重点
- 最终的
- 用来修饰：类、方法、变量（成员变量、局部变量）
- 类：不能被继承
- 方法：不能被重写
- 变量：是一个“常量”，一旦赋值不能修改。
- 成员变量能赋值的位置：显示初始化、代码块中初始化、构造器中初始化 （在造对象结束之前需要把实例变量赋上值）
- 静态修饰的成员变量能赋值的位置：显示初始化、静态代码块中赋值（构造器中就不要赋值了，因为静态变量不一定调构造器造对象）
- 局部变量：在调用之前赋值就可以了，一旦赋值就不要修改了。
6-关键字：abstract
文章链接：
Java面向对象（高级）-- 抽象类与抽象方法(或abstract关键字)-CSDN博客
1、知识点
【抽象类与抽象方法】
- 案例引入
举例1：GeometricObject-Circle-Rectangle
abstract class GeometricObject{
//几何图形
//求面积 （只能考虑提供方法的声明，而没有办法提供方法体。所以，此方法适合声明为抽象方法）
//求周长（只能考虑提供方法的声明，而没有办法提供方法体。所以，此方法适合声明为抽象方法）
}
class Circle extends GeometricObject{
//求面积 （必须重写（或实现）父类中的抽象方法）
//求周长（必须重写（或实现）父类中的抽象方法）
}
class Rectangle extends GeometricObject{
//求面积 （必须重写（或实现）父类中的抽象方法）
//求周长（必须重写（或实现）父类中的抽象方法）
}
举例2：Account-SavingAccount-CheckAcount
abstract class Account{
double balance;//余额
//取钱 （声明为抽象方法）
//存钱 （声明为抽象方法）
}
class SavingAccount extends Account{
//储蓄卡
//取钱 （需要重写父类中的抽象方法）
//存钱（需要重写父类中的抽象方法）
}
class CheckAccount extends Account{
//信用卡
//取钱（需要重写父类中的抽象方法）
//存钱（需要重写父类中的抽象方法）
}
//....
abstract的概念：抽象的
abstract可以用来修饰：类、方法
具体的使用：
4.1 abstract修饰类：
此类称为抽象类
抽象类不能实例化。
抽象类中是包含构造器的，因为子类对象实例化时，需要直接或间接的调用到父类的构造器。
抽象类中可以没有抽象方法。反之，抽象方法所在的类，一定是抽象类。
4.2 abstract修饰方法：
此方法即为抽象方法
抽象方法只有方法的声明，没有方法体。
抽象方法其功能是确定的（通过方法的声明即可确定），只是不知道如何具体实现（体现为没有方法体）
子类必须重写父类中的所有的抽象方法之后，方可实例化。否则，此子类仍然是一个抽象类。
- abstract不能使用的场景：
5.1 abstract 不能修饰哪些结构？
属性、构造器、代码块等。
5.2 abstract 不能与哪些关键字共用？（自洽）
不能用abstract修饰私有方法、静态方法、final的方法、final的类。
私有方法不能重写
避免静态方法使用类进行调用
final的方法不能被重写
final修饰的类不能有子类
2、重点
- 抽象的
- 用来修饰：类、方法
- 类：抽象类：不能实例化。
- 方法：抽象方法：没有方法体，必须由子类实现此方法。
7-关键字：interface
文章链接：
Java面向对象（高级）-- 接口(interface)-CSDN博客
1、知识点
【接口的使用】
接口的理解：接口的本质是契约、标准、规范，就像我们的法律一样。制定好后大家都要遵守。
定义接口的关键字：interface
接口内部结构的说明：
可以声明：
属性：必须使用public static final修饰
方法：jdk8之前：声明抽象方法，修饰为public abstract
jdk8:声明静态方法、默认方法
jdk9:声明私有方法不可以声明：构造器、代码块等
接口与类的关系 ：实现关系
格式：class A extends SuperA implements B,C{}
A相较于SuperA来讲，叫做子类
A相较于B,C来讲，叫做实现类。满足此关系之后，说明：
类可以实现多个接口。
类针对于接口的多实现，一定程度上就弥补了类的单继承的局限性。
类必须将实现的接口中的所有的抽象方法都重写（或实现），方可实例化。否则，此实现类必须声明为抽象类。接口与接口的关系：继承关系，且可以多继承
接口的多态性： 接口名 变量名 = new 实现类对象;
面试题：区分抽象类和接口
共性：都可以声明抽象方法
都不能实例化
不同：① 抽象类一定有构造器。接口没有构造器
② 类与类之间继承关系，类与接口之间是实现关系，接口与接口之间是多继承关系
2、重点
- interface：接口，用来定义一组规范、一种标准。
- 掌握：接口中可以声明的结构。
- 属性：使用
public static final修饰 （可以省略） - 方法：jdk8之前：只能声明抽象方法，使用public abstract修饰
jdk8中：声明static方法、default方法。
jdk9中：声明private方法。
- 属性：使用
- 笔试题：抽象类、接口的对比。
8-类的成员之五：内部类
文章链接：
Java面向对象（高级）-- 类的成员之五：内部类（InnerClass)-CSDN博客
1、知识点
【类的成员之五：内部类】
什么是内部类？
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类（InnerClass），类B则称为外部类（OuterClass）。为什么需要内部类？
具体来说，当一个事物A的内部，还有一个部分需要一个完整的结构B进行描述，而这个内部的完整的结构B又只为外部事物A
提供服务，不在其他地方单独使用，那么整个内部的完整结构B最好使用内部类。
总的来说，遵循高内聚、低耦合的面向对象开发原则。内部类使用举例：
Thread类内部声明了State类，表示线程的生命周期
HashMap类中声明了Node类，表示封装的key和value内部类的分类：（参考变量的分类）
成员内部类：直接声明在外部类的里面。
使用static修饰的：静态的成员内部类
不使用static修饰的：非静态的成员内部类局部内部类：声明在方法内、构造器内、代码块内的内部类
匿名的局部内部类
非匿名的局部内部类内部类这节要讲的知识：
成员内部类的理解
如何创建成员内部类的实例
如何在成员内部类中调用外部类的结构
局部内部类的基本使用关于成员内部类的理解：
从类的角度看：
- 内部可以声明属性、方法、构造器、代码块、内部类等结构
- 此内部类可以声明父类，可以实现接口
- 可以使用final修饰
- 可以使用abstract修饰从外部类的成员的角度看：
- 在内部可以调用外部类的结构。比如：属性、方法等
- 除了使用public、缺省权限修饰之外，还可以使用private、protected修饰
- 可以使用static修饰关于局部内部类的说明：
2、重点
成员内部类的理解
如何创建成员内部类的实例
如何在成员内部类中调用外部类的结构
局部内部类的基本使用（关注：如何在方法内创建匿名局部内部类的对象）
9-枚举类：enum
文章链接：
Java面向对象（高级）-- 枚举类的使用-CSDN博客
1、知识点
【枚举类的使用】
枚举类的理解：
枚举类型本质上也是一种类，只不过是这个类的对象是有限的、固定的几个，不能让用户随意创建。举例：
星期：Monday(星期一)…Sunday(星期天)性别：Man(男)、Woman(女)月份：January(1月)…December(12月)季节：Spring(春节)…Winter(冬天)三原色：red(红色)、green(绿色)、blue(蓝色)支付方式：Cash（现金）、WeChatPay（微信）、Alipay(支付宝)、BankCard(银行卡)、CreditCard(信用卡)就职状态：Busy(忙碌)、Free(空闲)、Vocation(休假)、Dimission(离职)订单状态：Nonpayment（未付款）、Paid（已付款）、Fulfilled（已配货）、Delivered（已发货）、Checked（已确认收货）、Return（退货）、Exchange（换货）、Cancel（取消）线程状态：创建、就绪、运行、阻塞、死亡
开发中的建议：
开发中，如果针对于某个类，其实例是确定个数的。则推荐将此类声明为枚举类。
如果枚举类的实例只有一个，则可以看做是单例的实现方式。JDK5.0 之前如何自定义枚举类 （了解）
见代码JDK5.0中使用enum定义枚举类
见代码Enum中的常用方法:
6.1 使用enum关键字定义的枚举类，默认其父类是java.lang.Enum类
使用enum关键字定义的枚举类，不要再显示的定义其父类。否则报错。
6.2 熟悉Enum类中常用的方法
String toString(): 默认返回的是常量名（对象名），可以继续手动重写该方法！
(关注)static 枚举类型[] values():返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值，是一个静态方法
(关注)static 枚举类型 valueOf(String name)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
String name():得到当前枚举常量的名称。建议优先使用toString()。
int ordinal():返回当前枚举常量的次序号，默认从0开始枚举类实现接口的操作
情况1：枚举类实现接口，在枚举类中重写接口中的抽象方法。当通过不同的枚举类对象调用此方法时，执行的是同一个方法。
情况2：让枚举类的每一个对象重写接口中的抽象方法。当通过不同的枚举类对象调用此方法时，执行的是不同的实现的方法。
2、重点
- 掌握：使用enum关键字定义枚举类即可。
10-注解:Annotation
文章链接：
Java面向对象（高级）-- 注解(Annotation)-CSDN博客
1、知识点
【注解的使用】
Annotation的理解
注解（Annotation）是从JDK5.0开始引入，以“@注解名”在代码中存在。
Annotation 可以像修饰符一样被使用，可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明。
还可以添加一些参数值，这些信息被保存在 Annotation 的 “name=value” 对中。
注解可以在类编译、运行时进行加载，体现不同的功能。注解的应用场景：
示例1：生成文档相关的注解
示例2：在编译时进行格式检查(JDK内置的三个基本注解)
示例3：跟踪代码依赖性，实现替代配置文件功能Java基础涉及到的三个常用注解
@Override: 限定重写父类方法，该注解只能用于方法
@Deprecated: 用于表示所修饰的元素(类，方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
@SuppressWarnings: 抑制编译器警告自定义注解
以@SuppressWarnings为参照，进行定义即可。元注解的理解：
元注解：对现有的注解进行解释说明的注解。
讲4个元注解：
（1）@Target：用于描述注解的使用范围
可以通过枚举类型ElementType的10个常量对象来指定
TYPE，METHOD，CONSTRUCTOR，PACKAGE…
（2）@Retention：用于描述注解的生命周期
可以通过枚举类型RetentionPolicy的3个常量对象来指定s
SOURCE（源代码）、CLASS（字节码）、RUNTIME（运行时）
唯有RUNTIME阶段才能被反射读取到。
（3）@Documented：表明这个注解应该被 javadoc工具记录。
（4）@Inherited：允许子类继承父类中的注解
拓展： 元数据。
String name = “Tom”;
框架 = 注解 + 反射 + 设计模式
2、重点
- 框架 = 注解 + 反射 + 设计模式
- Java基础阶段：简单。@Override 、 @Deprecated、@SuppressWarnings
- 元注解：对现有的注解进行解释说明。
- @Target：表明可以用来修饰的结构
- @Retation：表明生命周期
- 如何自定义注解。
11-包装类的使用
文章链接：
Java面向对象（高级）-- 包装类（wrapper）的使用-CSDN博客
1、知识点
【包装类的使用】
为什么要使用包装类？
为了使得基本数据类型的变量具备引用数据类型变量的相关特征（比如：封装性、继承性、多态性），我们给各个基本数据
类型的变量都提供了对应的包装类。(掌握)基本数据类型对应的包装类类型
byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double ->Double
char -> Character
boolean -> Boolean
掌握基本数据类型 与 包装类之间的转换。
3.1 为什么需要转换
一方面，在有些场景下，需要使用基本数据类型对应的包装类的对象。此时就需要将基本数据类型的变量转换为
包装类的对象。比如：ArrayList的add(Object obj);Object类的equals(Object obj)
对于包装类来讲，既然我们使用的是对象，那么对象是不能进行+ - * /等运算的。为了能够进行这些运算，就
需要将包装类的对象转换为基本数据类型的变量。3.2 如何转换：
（装箱）基本数据类型 —> 包装类：① 使用包装类的构造器 ② （建议）调用包装类的valueOf(xxx xx)
（拆箱）包装类 —> 基本数据类型：调用包装类的xxxValue()注意：原来使用基本数据类型变量的位置，改成包装类以后，对于成员变量来说，其默认值变化了！
jdk5.0新特性：自动装箱、自动拆箱。String 与 基本数据类型、包装类之间的转换。
基本数据类型、包装类 —> String类型：① 调用String的重载的静态方法valueOf(xxx xx) ; ② 基本数据类型的变量 + “”String类型 —> 基本数据类型、包装类: 调用包装类的静态方法：parseXxx()
2、重点
- 掌握：基本数据类型对应的包装类都有哪些？
- 掌握：基本数据类型、包装类、String三者之间的转换
- 基本数据类型 <-> 包装类：自动装箱、自动拆箱
- 基本数据类型、包装类 <-> String （转换成谁，就在谁里面找方法）
- String的valueOf(xxx)
- 包装类的parseXxx(String str)
12-IDEA:快捷键和debug
文章链接：
IntelliJ IDEA快捷键及调试-CSDN博客
1、知识点
【IDEA常用快捷键】
第1组：通用型
说明 快捷键
--------------------------------
复制代码-copy ctrl + c
粘贴-paste ctrl + v
剪切-cut ctrl + x
撤销-undo ctrl + z
反撤销-redo ctrl + shift + z
保存-save all ctrl + s
全选-select all ctrl + a
第2组：提高编写速度（上）
说明 快捷键
-------------------------------------------------------------------
智能提示-edit alt + enter
提示代码模板-insert live template ctrl+j
使用xx块环绕-surround with ... ctrl+alt+t
调出生成getter/setter/构造器等结构-generate ... alt+insert
自动生成返回值变量-introduce variable ... ctrl+alt+v
复制指定行的代码-duplicate line or selection ctrl+d
删除指定行的代码-delete line ctrl+y
切换到下一行代码空位-start new line shift + enter
切换到上一行代码空位-start new line before current ctrl +alt+ enter
向上移动代码-move statement up ctrl+shift+↑
向下移动代码-move statement down ctrl+shift+↓
向上移动一行-move line up alt+shift+↑
向下移动一行-move line down alt+shift+↓
方法的形参列表提醒-parameter info ctrl+p
第3组：提高编写速度（下）
说明 快捷键
---------------------------------------------------------
批量修改指定的变量名、方法名、类名等-rename shift+f6
抽取代码重构方法-extract method ... ctrl+alt+m
重写父类的方法-override methods ... ctrl+o
实现接口的方法-implements methods ... ctrl+i
选中的结构的大小写的切换-toggle case ctrl+shift+u
批量导包-optimize imports ctrl+alt+o
第4组：类结构、查找和查看源码
说明 快捷键
-----------------------------------------------------------------------------------------
如何查看源码-go to class... ctrl + 选中指定的结构 或 ctrl+n
显示当前类结构，支持搜索指定的方法、属性等-file structure ctrl+f12
退回到前一个编辑的页面-back ctrl+alt+←
进入到下一个编辑的页面-forward ctrl+alt+→
打开的类文件之间切换-select previous/next tab alt+←/→
光标选中指定的类，查看继承树结构-Type Hierarchy ctrl+h
查看方法文档-quick documentation ctrl+q
类的UML关系图-show uml popup ctrl+alt+u
定位某行-go to line/column ctrl+g
回溯变量或方法的来源-go to implementation(s) ctrl+alt+b
折叠方法实现-collapse all ctrl+shift+ -
展开方法实现-expand all ctrl+shift+ +
第5组：查找、替换与关闭
说明 快捷键
--------------------------------------------------------------
查找指定的结构 ctrl+f
查找与替换-replace ctrl+r
直接定位到当前行的首位-move caret to line start home
直接定位到当前行的末位 -move caret to line end end
全项目搜索文本-find in path ... ctrl+shift+f
第6组：调整格式
说明 快捷键
--------------------------------------------------------------
格式化代码-reformat code ctrl+alt+l
使用单行注释-comment with line comment ctrl + /
使用/取消多行注释-comment with block comment ctrl + shift + /
选中数行，整体往后移动-tab tab
选中数行，整体往前移动-prev tab shift + tab
【IDEA中调试程序】
为什么需要Debug?
编好的程序在执行过程中如果出现错误，该如何查找或定位错误呢？简单的代码直接就可以看出来，
但如果代码比较复杂，就需要借助程序调试工具（Debug）来查找错误了。Debug的步骤
1、添加断点
2、启动调试
3、单步执行
4、观察变量和执行流程，找到并解决问题
2、重点
- 掌握如何调试
二、企业真题
1- static关键字
题1
🌋1、静态变量和实例变量的区别？（保*丰、*软国际、软华、北京明**信）
类似问题：
> 说明静态变量和实例变量之间的区别和使用场景（上海*动）
🍺答：
【区别】
① 个数
>静态变量：在内存空间中只有一份，被类的多个对象所共享。
>实例变量：类的每一个实例（或对象）都保存着一份实例变量。
② 内存位置
>静态变量：jdk6及之前：存放在方法区。 jdk7及之后：存放在堆空间
>实例变量：存放在堆空间的对象实体中。
③ 加载时机
>静态变量：随着类的加载而加载，由于类只会加载一次，所以静态变量也只有一份。
>实例变量：随着对象的创建而加载。每个对象拥有一份实例变量。
④ 调用者
>静态变量：可以被类直接调用，也可以使用对象调用。
>实例变量：只能使用对象进行调用。
⑤ 判断是否可以调用 —> 从生命周期的角度解释
类变量 实例变量
类 yes no
对象 yes yes
⑥ 消亡时机
>静态变量：随着类的卸载而消亡
>实例变量：随着对象的消亡而消亡
【使用场景】
什么时候需要将属性声明为静态的？
> 判断当前类的多个实例是否能共享此成员变量，且此成员变量的值是相同的。
> 开发中，常将一些常量声明是静态的。比如：Math类中的PI
什么时候需要将方法声明为静态的？
> 方法内操作的变量如果都是静态变量（而非实例变量）的话，则此方法建议声明为静态方法
> 开发中，常常将工具类中的方法，声明为静态方法。比如：Arrays类、Math类
题2
🌋2、静态属性和静态方法是否可以被继承？是否可以被重写？以及原因？（*度）
类似问题：
> 在java中，可以重载一个static方法吗？可以覆盖一个static方法吗？（Vi*o）
答：静态方法可以重载，可以重载一个static方法。
不能覆盖一个static方法（重写）。
🍺答：
静态属性和静态方法可以被继承，子类当中可以使用父类中静态的结构（条件允许的情况下可以直接调用），拿子类.调用。
静态方法不能被重写，因为和对象没有关系。不存在多态性。
这里稍微说一下这个问题，举个例子。
【StaticTest.java】
package yuyi03;
/**
* ClassName: StaticTest
* Package: yuyi03
* Description:
*
* @Author 雨翼轻尘
* @Create 2023/12/27 0027 11:13
*/
public class StaticTest {
public static void main(String[] args) {
Person p1=new Student();
p1.eat();
}
}
class Person{
public void eat(){
System.out.println("人吃饭");
}
}
class Student extends Person{
@Override
public void eat() {
System.out.println("学生吃饭");
}
}
输出：
此时没有任何问题，接下来让父类中的方法为静态方法。
父类中的方法是静态的，那么子类不能与父类定义同名同参数的。如下：
若子类中出现了同名同参数的，就说明它想重写，父类中是静态的，那么需要保证子类中也是静态。
但此时也不能叫重写了。
若子类、父类中出现了同名同参数的方法，那么这两个方法要么都是static，要么全不是static。
不是static的时候叫重写，是static的时候仅仅是这两个方法同名而已。
静态方法随着类的加载而加载，两个同名的static方法就是相当于是两个不同的方法。
那么有什么影响呢？
看一下现在的代码：
package yuyi03;
/**
* ClassName: StaticTest
* Package: yuyi03
* Description:
*
* @Author 雨翼轻尘
* @Create 2023/12/27 0027 11:13
*/
public class StaticTest {
public static void main(String[] args) {
Person p1=new Student();
p1.eat();
}
}
class Person{
public static void eat(){
System.out.println("人吃饭");
}
}
class Student extends Person{
public static void eat() {
System.out.println("学生吃饭");
}
}
现在还是一个多态场景，调用了eat()方法，注意这里是拿对象p1调用的。（其实和对象没有关系）
这时候结果就是父类里面的了，如下：
其实此时这样写也不会报错：
Person p2=null; //没有空指针异常
p2.eat();
输出结果和对象没有关系，根本不看是谁的对象，只看是什么类型。由类发起对方法的调用。
多态只是对象的事，现在是静态的方法，跟多态没有关系。
所以静态的方法不能被重写，也不能被覆盖。也不存在多态性。
静态方法可以重载，重载只和方法名、参数有关。比如：
class Person{
public static void eat(){
System.out.println("人吃饭");
}
public static void food(String food){
System.out.println("人喜欢吃"+food);
}
}
题3
🌋3、是否可以从一个static方法内部发出对非static方法的调用？（同*顺）
🍺答：
只能通过对象来对非静态方法调用。
比如main方法，它是静态方法，所以在main方法里面要对非静态方法调用的时候，需要使用对象来调用。
题4
🌋4、被static修饰的成员(类、方法、成员变量)能否再使用private进行修饰？（联*优势）
🍺答：
完全可以。除了代码块（代码块本身不能用权限修饰符来修饰）。
被static修饰的类肯定是内部类，private体现封装性（能不能被调用）。
被static修饰的成员随着类的加载而加载，该被修饰的可以被修饰。
2- 设计模式
题1
🌋1、知道哪些设计模式？（*通快递、蚂**服）
🍺答：
单例模式、模板方法设计模式、享元设计模式
题2
🌋2、开发中都用到了那些设计模式?用在什么场合? （久*国际物流）
🍺答：
略（目前无法回答，后续学到再说）
3- main()
题1
🌋1、main()方法的public能不能换成private，为什么（凡科技、顺）
🍺答：
可以改。
但是改完以后就不是程序入口了，就是一个普通的静态方法，权限是私有的。
题2
🌋2、main()方法中是否可以调用非静态方法？（浩*科技）
🍺答：
只能通过对象来对非静态方法调用。
4- 代码块
题1
🌋1、类的组成和属性赋值执行顺序?（航*拓普）
类似问题：
> Java中类的变量初始化的顺序？（*壳）
🍺答：
可以给类的非静态的属性（即实例变量）赋值的位置有：
① 默认初始化
② 显式初始化 或 ⑤ 代码块中初始化
③ 构造器中初始化
###############################
④ 有了对象以后，通过"对象.属性"或"对象.方法"的方法进行赋值
执行的先后顺序：
① - ②/⑤ - ③ - ④
这里拿实例变量来说的，实际上类变量（不考虑构造器）也可以。
题2
🌋2、静态代码块，普通代码块，构造方法，从类加载开始的执行顺序？（恒*电子）
类似问题：
> 类加载成员变量、静态代码块、构造器的加载顺序（*科软、软**力、同*顺）
> static代码块(静态代码块)是否在类的构造函数之前被执行（联*优势）
🍺答：
静态代码块（类加载） --> 普通代码块 --> 构造器
在字节码文件中，会将“普通代码块”和“构造器”合在一起形成方法，关于变量的显示赋值也会放到里面。
其实“静态代码块”也会以一种方法的形式呈现。
比如：
package yuyi03;
/**
* ClassName: BlockTest
* Package: yuyi03
* Description:
*
* @Author 雨翼轻尘
* @Create 2023/12/27 0027 21:49
*/
public class BlockTest {
//静态代码块
static{
System.out.println("abc");
}
//普通代码块
{
System.out.println("hello");
}
//无参构造器
public BlockTest(){
}
//有参构造器
public BlockTest(int id){
}
}
字节码文件：
5- final关键字
题1
🌋1、描述一下对final理解（华**博普）
🍺答：
- 最终的
- 用来修饰：类、方法、变量（成员变量、局部变量）
- 类：不能被继承
- 方法：不能被重写
- 变量：是一个“常量”，一旦赋值不能修改。
题2
🌋2、判断题：使用final修饰一个变量时，是引用不能改变，引用指向的对象可以改变？（*米）
🍺答：
引用不能改变。
引用指向的对象实体中的属性，如果没有使用final修饰，则可以改变。
题3
🌋3、判断题：final不能用于修饰构造方法？（联*优势）
🍺答：
是的。若用final修饰方法就是不能变，不能重写，但修饰构造器没有意义。
题4
🌋4、final或static final 修饰成员变量，能不能进行++操作？（佳*贸易）
🍺答：
不能进行++操作。但是可以进行+1操作，因为变量本身没有变。
6- 抽象类与接口
题1
🌋1、什么是抽象类？如何识别一个抽象类？（易*支付）
🍺答：
使用abstract修饰的就是一个抽象类。
题2
🌋2、为什么不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法？（止**善）
🍺答：
为了语言的自洽。这些都不能被重写，而abstract修饰则必须重写其内容。
abstract 不能与哪些关键字共用？（自洽）
不能用abstract修饰私有方法、静态方法、final的方法、final的类。
私有方法不能重写
避免静态方法使用类进行调用
final的方法不能被重写
final修饰的类不能有子类
题3
🌋3、接口与抽象类的区别？（字跳动、阿校招、度校招、**计算机技术及应用研究所、航拓普、纬*、招晟、汇*云通、数信科技、北京永鼎力、上海连科技）
🍺答：
题4
🌋4、接口是否可继承接口？抽象类是否可实现（implements）接口？抽象类是否可继承实现类（concrete class）？（航*拓普、蝶、深圳德科技）
类似问题：
> 接口A可以继承接口B吗?接口A可以实现接口B吗?（久*国际物流）
🍺答：
是；是；是。
接口可以继承接口；
抽象类可以实现接口（比如一个类实现了一个接口，这个接口里面有两个抽象方法，它就重写了一个方法，另一个没有重写，那么这个类就是抽象类）；
抽象类可以继承实现类（即非抽象类，没有写父类就是abstract，abstract就是非抽象的）。
题5
🌋5、接口可以有自己属性吗？（华*中盛）
🍺答：
可以。必须是public static final的。
题6
🌋6、访问接口的默认方法如何使用(上海*思)
🍺答：
使用实现类的对象进行调用。而且实现类还可以重写此默认方法。
7- 内部类
题1
🌋1、内部类有哪几种？（华油**普、来*科技）
🍺答：
内部类的分类：（参考变量的分类）
成员内部类：直接声明在外部类的里面。
使用static修饰的：静态的成员内部类
不使用static修饰的：非静态的成员内部类
局部内部类：声明在方法内、构造器内、代码块内的内部类
匿名的局部内部类
非匿名的局部内部类
题2
🌋2、内部类的特点说一下（招通**）
类似问题：
> 说一下内部类的好处（北京楚*龙）
> 使用过内部类编程吗，有什么作用（软**力）
🍺答：
关于成员内部类的理解：
从类的角度看：
- 内部可以声明属性、方法、构造器、代码块、内部类等结构
- 此内部类可以声明父类，可以实现接口
- 可以使用final修饰
- 可以使用abstract修饰
从外部类的成员的角度看：
- 在内部可以调用外部类的结构。比如：属性、方法等
- 除了使用public、缺省权限修饰之外，还可以使用private、protected修饰
- 可以使用static修饰
题3
🌋3、匿名类说一下（阿校招、上海立网络）
🍺答：
有的时候不想显示地造一个实现类，就像临时拿一个用，就可以使用匿名类。
8- 枚举类
题1
🌋1、枚举可以继承吗?（顺*）
🍺答：
使用enum定义的，其父类就是Enum类，就不要再继承其他的类了。（如果要写就会报错）
如果是自定义（不使用enum），是自己写的class，想继承啥都可以啦。
9- 包装类
题1
🌋1、Java基本类型与包装类的区别（凡*科技）
🍺答：
包装类可以造对象、调方法，Java基本类型就不行。
10- 综合
题1
🌋1、谈谈你对面向对象的理解(君科技、航拓普、…)。
🍺答：
- 面向对象的两个要素：类（抽象的 概念上的定义）、对象（类创造出来的实打实的对象实体，具体存在的一个一个的个体） —> 面向对象编程（在完成具体功能的时候，通常由对象出发，对类中声明的方法进行调用）。“万事万物皆对象”。
- 面向对象的三大特征
- 接口，与类并列的结构，作为一个补充：类可以实现多个接口，弥补单继承的局限性。
题2
🌋2、面向对象的特征有哪些方面? （北京楚龙、深圳德科技、直科技、米奇网络、航*拓普）
类似问题：
> 面向对象核心是什么？（平**服）
答:面向对象的编程的核心思想是，将程序中的实体、数据和功能抽象为单独的对象，并在这些对象之间建立联系。
🍺答：封装、继承、多态
