一、知识点复习

1-关键字：static

文章链接：
Java面向对象（高级）-- static关键字的使用-CSDN博客

1、知识点

【static关键字的使用】

1. static: 静态的

2. static 用来修饰的结构：属性、方法; 代码块、内部类；（构造器不能够用static修饰）

3. static修饰属性
   3.1 复习：变量的分类
   方式1：按照数据类型：基本数据类型、引用数据类型
   方式2：按照类中声明的位置：
   成员变量：按照是否使用static修饰进行分类：
   使用static修饰的成员变量：静态变量、类变量
   不使用static修饰的成员变量：非静态变量、实例变量

   局部变量：方法内、方法形参、构造器内、构造器形参、代码块内等。

3.2 静态变量：类中的属性使用static进行修饰。
对比静态变量与实例变量：
① 个数
>静态变量：在内存空间中只有一份，被类的多个对象所共享。
>实例变量：类的每一个实例（或对象）都保存着一份实例变量。
② 内存位置
>静态变量：jdk6及之前：存放在方法区。 jdk7及之后：存放在堆空间
>实例变量：存放在堆空间的对象实体中。
③ 加载时机
>静态变量：随着类的加载而加载，由于类只会加载一次，所以静态变量也只有一份。
>实例变量：随着对象的创建而加载。每个对象拥有一份实例变量。
④ 调用者
>静态变量：可以被类直接调用，也可以使用对象调用。
>实例变量：只能使用对象进行调用。
⑤ 判断是否可以调用 —> 从生命周期的角度解释
类变量 实例变量
类 yes no
对象 yes yes

⑥ 消亡时机
>静态变量：随着类的卸载而消亡
>实例变量：随着对象的消亡而消亡

4. static修饰方法：（类方法、静态方法）
   随着类的加载而加载
   可以通过“类.静态方法”的方式，直接调用静态方法
   静态方法内可以调用静态的属性或静态的方法。（属性和方法的前缀使用的是当前类，可以省略）
   不可以调用非静态的结构。（比如：属性、方法）

                 类方法         实例方法
      类            yes            no
      对象          yes            yes
   

   static修饰的方法内，不能使用this和super

补充：在类的非静态方法中，可以调用当前类中的静态结构（属性、方法）或非静态结构（属性、方法）

5. 开发中，什么时候需要将属性声明为静态的？
   判断当前类的多个实例是否能共享此成员变量，且此成员变量的值是相同的。
   开发中，常将一些常量声明是静态的。比如：Math类中的PI

   什么时候需要将方法声明为静态的？
   方法内操作的变量如果都是静态变量（而非实例变量）的话，则此方法建议声明为静态方法
   开发中，常常将工具类中的方法，声明为静态方法。比如：Arrays类、Math类

2、重点

• static：静态的，随着类的加载而加载、执行。
• static用来修饰：属性、方法、代码块、内部类 （不能用来修饰构造器）
• 熟悉：static修饰的类变量、类方法与不使用static修饰的区别。
  • 类变量：类的生命周期内，只有一个。被类的多个实例共享。
• 掌握：我们遇到属性或方法时，需要考虑是否声明为static的。

2-单例模式（或单子模式）

文章链接：
Java面向对象（高级）-- 单例(Singleton)设计模式-CSDN博客

1、知识点

1. 设计模式概述：
   设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。
   就像是经典的棋谱，不同的棋局，我们用不同的棋谱。“套路”
   经典的设计模式一共有23种。

2. 何为单例模式(Singleton)：
   所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

3. 如何实现单例模式（掌握）:
   饿汉式
   懒汉式

4. 对比两种模式（特点、优缺点）
   特点：
   饿汉式：“立即加载”,随着类的加载，当前的唯一实例就创建了
   懒汉式：“延迟加载”,在需要使用的时候，进行创建。

优缺点：

饿汉式：（优点）写法简单，由于内存中较早加载，使用更方便、更快。是线程安全的。 （缺点）内存中占用时间较长。

懒汉式：（缺点）线程不安全 （放到多线程章节时解决）（优点）在需要的时候进行创建，节省内存空间。

2、重点

• 经典的设计模式有23种
• 解决的问题：在整个软件系统中，只存在当前类的唯一实例。
• 实现方式：饿汉式、懒汉式、枚举类等
• 对比饿汉式和懒汉式
  • 饿汉式：“立即加载”，线程安全的。
  • 懒汉式：“延迟加载”，线程不安全。
• 需要会手写饿汉式和懒汉式

3-理解main()方法

文章链接：
Java面向对象（高级）-- 单例(Singleton)设计模式-CSDN博客

1、知识点

【main()方法的剖析】

public static void main(String args[]){}

1. 理解1：看做是一个普通的静态方法
   理解2：看做是程序的入口，格式是固定的。

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、知识点

【类的成员之四：代码块】

回顾：类中可以声明的结构：属性、方法、构造器；代码块（或初始化块）、内部类

代码块：从长的样子来看的（就是封装了一下代码）

初始化块：从它的作用的角度

1. 代码块（或初始化块）的作用：
   用来初始化类或对象的信息（即初始化类或对象的成员变量）

2. 代码块的修饰：
   只能使用static进行修饰。

3. 代码块的分类：
   静态代码块：使用static修饰
   非静态代码块：没有使用static修饰

4. 具体使用：
   4.1 静态代码块：
   随着类的加载而执行（它没有名字，就不能显示地调用它）
   由于类的加载只会执行一次，进而静态代码块的执行，也只会执行一次
   作用：用来初始化类的信息
   内部可以声明变量、调用属性或方法、编写输出语句等操作。
   静态代码块的执行要先于非静态代码块的执行
   如果声明有多个静态代码块，则按照声明的先后顺序执行
   静态代码块内部只能调用静态的结构（即静态的属性、方法），不能调用非静态的结构（即非静态的属性、方法）

4.2 非静态代码块：
随着对象的创建而执行
每创建当前类的一个实例，就会执行一次非静态代码块
作用：用来初始化对象的信息
内部可以声明变量、调用属性或方法、编写输出语句等操作。
如果声明有多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内部可以调用静态的结构（即静态的属性、方法），也可以调用非静态的结构（即非静态的属性、方法）

2、重点

• 分类：静态代码块、非静态代码块
• 使用频率上来讲：用的比较少。
• 静态代码块：随着类的加载而执行
• 非静态代码块：随着对象的创建而执行

【属性赋值的过程】

文章链接：

Java面向对象（高级）-- 类中属性赋值的位置及过程_java 给属性赋值-CSDN博客

1. 可以给类的非静态的属性（即实例变量）赋值的位置有：
   ① 默认初始化
   ② 显式初始化 或 ⑤ 代码块中初始化
   ③ 构造器中初始化
   ####################################
   ④ 有了对象以后，通过"对象.属性"或"对象.方法"的方法进行赋值

2. 执行的先后顺序：
   ① - ②/⑤ - ③ - ④

3. (超纲)关于字节码文件中的的简单说明：(通过插件jclasslib bytecode viewer查看)
   方法在字节码文件中可以看到。每个方法都对应着一个类的构造器。（类中声明了几个构造器就会有几个）
   编写的代码中的构造器在编译以后就会以方法的方式呈现
   方法内部的代码包含了实例变量的显示赋值、代码块中的赋值和构造器中的代码。
   方法用来初始化当前创建的对象的信息的。

4. 给实例变量赋值的位置很多，开发中如何选？
   显示赋值：比较适合于每个对象的属性值相同的场景
   构造器中赋值：比较适合于每个对象的属性值不相同的场景

5-关键字：final

文章链接：
Java面向对象（高级）-- final关键字的使用-CSDN博客

1、知识点

【final关键字的使用】

1. final的理解：最终的

2. final可以用来修饰的结构：类、方法、变量

3. 具体说明：
   3.1 final修饰类：表示此类不能被继承。
   比如：String、StringBuffer、StringBuilder类

3.2 final修饰方法：表示此方法不能被重写
比如：Object类中的getClass()

3.3 final修饰变量：既可以修饰成员变量，也可以修饰局部变量。
此时的"变量"其实就变成了"常量"，意味着一旦赋值，就不可更改。

3.3.1 final修饰成员变量: 有哪些位置可以给成员变量赋值？
显式赋值

代码块中赋值

构造器中赋值

3.3.2 final修饰局部变量：一旦赋值就不能修改
方法内声明的局部变量：在调用局部变量前，一定需要赋值。而且一旦赋值，就不可更改
方法的形参：在调用此方法时，给形参进行赋值。而且一旦赋值，就不可更改

4. final与static搭配：修饰成员变量时，此成员变量称为：全局常量。
   比如：Math的PI

2、重点

• 最终的
• 用来修饰：类、方法、变量（成员变量、局部变量）
  • 类：不能被继承
  • 方法：不能被重写
  • 变量：是一个“常量”，一旦赋值不能修改。
• 成员变量能赋值的位置：显示初始化、代码块中初始化、构造器中初始化 （在造对象结束之前需要把实例变量赋上值）
• 静态修饰的成员变量能赋值的位置：显示初始化、静态代码块中赋值（构造器中就不要赋值了，因为静态变量不一定调构造器造对象）
• 局部变量：在调用之前赋值就可以了，一旦赋值就不要修改了。

6-关键字：abstract

文章链接：
Java面向对象（高级）-- 抽象类与抽象方法(或abstract关键字)-CSDN博客

1、知识点

【抽象类与抽象方法】

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{ //信用卡
    //取钱（需要重写父类中的抽象方法）

    //存钱（需要重写父类中的抽象方法）
}
//....

2. abstract的概念：抽象的

3. abstract可以用来修饰：类、方法

4. 具体的使用：
   4.1 abstract修饰类：
   此类称为抽象类
   抽象类不能实例化。
   抽象类中是包含构造器的，因为子类对象实例化时，需要直接或间接的调用到父类的构造器。
   抽象类中可以没有抽象方法。反之，抽象方法所在的类，一定是抽象类。

4.2 abstract修饰方法：
此方法即为抽象方法
抽象方法只有方法的声明，没有方法体。
抽象方法其功能是确定的（通过方法的声明即可确定），只是不知道如何具体实现（体现为没有方法体）
子类必须重写父类中的所有的抽象方法之后，方可实例化。否则，此子类仍然是一个抽象类。

5. abstract不能使用的场景：
   5.1 abstract 不能修饰哪些结构？
   属性、构造器、代码块等。

5.2 abstract 不能与哪些关键字共用？（自洽）

不能用abstract修饰私有方法、静态方法、final的方法、final的类。

私有方法不能重写

避免静态方法使用类进行调用

final的方法不能被重写

final修饰的类不能有子类

2、重点

• 抽象的
• 用来修饰：类、方法
  • 类：抽象类：不能实例化。
  • 方法：抽象方法：没有方法体，必须由子类实现此方法。

7-关键字：interface

文章链接：
Java面向对象（高级）-- 接口(interface)-CSDN博客

1、知识点

【接口的使用】

1. 接口的理解：接口的本质是契约、标准、规范，就像我们的法律一样。制定好后大家都要遵守。

2. 定义接口的关键字：interface

3. 接口内部结构的说明：
   可以声明：
   属性：必须使用public static final修饰
   方法：jdk8之前：声明抽象方法，修饰为public abstract
   jdk8:声明静态方法、默认方法
   jdk9:声明私有方法

   不可以声明：构造器、代码块等

4. 接口与类的关系 ：实现关系

5. 格式：class A extends SuperA implements B,C{}
   A相较于SuperA来讲，叫做子类
   A相较于B,C来讲，叫做实现类。

6. 满足此关系之后，说明：
   类可以实现多个接口。
   类针对于接口的多实现，一定程度上就弥补了类的单继承的局限性。
   类必须将实现的接口中的所有的抽象方法都重写（或实现），方可实例化。否则，此实现类必须声明为抽象类。

7. 接口与接口的关系：继承关系，且可以多继承

8. 接口的多态性： 接口名 变量名 = new 实现类对象;

9. 面试题：区分抽象类和接口
   共性：都可以声明抽象方法
   都不能实例化

不同：① 抽象类一定有构造器。接口没有构造器
② 类与类之间继承关系，类与接口之间是实现关系，接口与接口之间是多继承关系

2、重点

• interface：接口，用来定义一组规范、一种标准。
• 掌握：接口中可以声明的结构。
  • 属性：使用public static final修饰 （可以省略）
  • 方法：jdk8之前：只能声明抽象方法，使用public abstract修饰
    jdk8中：声明static方法、default方法。
    jdk9中：声明private方法。
• 笔试题：抽象类、接口的对比。

8-类的成员之五：内部类

文章链接：
Java面向对象（高级）-- 类的成员之五：内部类（InnerClass)-CSDN博客

1、知识点

【类的成员之五：内部类】

1. 什么是内部类？
   将一个类A定义在另一个类B里面，里面的那个类A就称为内部类（InnerClass），类B则称为外部类（OuterClass）。

2. 为什么需要内部类？
   具体来说，当一个事物A的内部，还有一个部分需要一个完整的结构B进行描述，而这个内部的完整的结构B又只为外部事物A
   提供服务，不在其他地方单独使用，那么整个内部的完整结构B最好使用内部类。
   总的来说，遵循高内聚、低耦合的面向对象开发原则。

3. 内部类使用举例：
   Thread类内部声明了State类，表示线程的生命周期
   HashMap类中声明了Node类，表示封装的key和value

4. 内部类的分类：（参考变量的分类）
   成员内部类：直接声明在外部类的里面。
   使用static修饰的：静态的成员内部类
   不使用static修饰的：非静态的成员内部类

   局部内部类：声明在方法内、构造器内、代码块内的内部类
   匿名的局部内部类
   非匿名的局部内部类

5. 内部类这节要讲的知识：
   成员内部类的理解
   如何创建成员内部类的实例
   如何在成员内部类中调用外部类的结构
   局部内部类的基本使用

6. 关于成员内部类的理解：
   从类的角度看：
   - 内部可以声明属性、方法、构造器、代码块、内部类等结构
   - 此内部类可以声明父类，可以实现接口
   - 可以使用final修饰
   - 可以使用abstract修饰

   从外部类的成员的角度看：
   - 在内部可以调用外部类的结构。比如：属性、方法等
   - 除了使用public、缺省权限修饰之外，还可以使用private、protected修饰
   - 可以使用static修饰

7. 关于局部内部类的说明：

2、重点

成员内部类的理解

如何创建成员内部类的实例

如何在成员内部类中调用外部类的结构

局部内部类的基本使用（关注：如何在方法内创建匿名局部内部类的对象）

9-枚举类：enum

文章链接：
Java面向对象（高级）-- 枚举类的使用-CSDN博客

1、知识点

【枚举类的使用】

1. 枚举类的理解：
   枚举类型本质上也是一种类，只不过是这个类的对象是有限的、固定的几个，不能让用户随意创建。

2. 举例：

• 星期：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（取消）
• 线程状态：创建、就绪、运行、阻塞、死亡

3. 开发中的建议：
   开发中，如果针对于某个类，其实例是确定个数的。则推荐将此类声明为枚举类。
   如果枚举类的实例只有一个，则可以看做是单例的实现方式。

4. JDK5.0 之前如何自定义枚举类 （了解）
   见代码

5. JDK5.0中使用enum定义枚举类
   见代码

6. 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开始

7. 枚举类实现接口的操作
   情况1：枚举类实现接口，在枚举类中重写接口中的抽象方法。当通过不同的枚举类对象调用此方法时，执行的是同一个方法。
   情况2：让枚举类的每一个对象重写接口中的抽象方法。当通过不同的枚举类对象调用此方法时，执行的是不同的实现的方法。

2、重点

• 掌握：使用enum关键字定义枚举类即可。

10-注解:Annotation

文章链接：
Java面向对象（高级）-- 注解(Annotation)-CSDN博客

1、知识点

【注解的使用】

1. Annotation的理解
   注解（Annotation）是从JDK5.0开始引入，以“@注解名”在代码中存在。
   Annotation 可以像修饰符一样被使用，可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明。
   还可以添加一些参数值，这些信息被保存在 Annotation 的 “name=value” 对中。
   注解可以在类编译、运行时进行加载，体现不同的功能。

2. 注解的应用场景：
   示例1：生成文档相关的注解
   示例2：在编译时进行格式检查(JDK内置的三个基本注解)
   示例3：跟踪代码依赖性，实现替代配置文件功能

3. Java基础涉及到的三个常用注解
   @Override: 限定重写父类方法，该注解只能用于方法
   @Deprecated: 用于表示所修饰的元素(类，方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
   @SuppressWarnings: 抑制编译器警告

4. 自定义注解
   以@SuppressWarnings为参照，进行定义即可。

5. 元注解的理解：
   元注解：对现有的注解进行解释说明的注解。

讲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、知识点

【包装类的使用】

1. 为什么要使用包装类？
   为了使得基本数据类型的变量具备引用数据类型变量的相关特征（比如：封装性、继承性、多态性），我们给各个基本数据
   类型的变量都提供了对应的包装类。

2. (掌握)基本数据类型对应的包装类类型
   byte -> Byte
   short -> Short
   int -> Integer
   long -> Long
   float -> Float
   double ->Double

char -> Character
boolean -> Boolean

3. 掌握基本数据类型 与 包装类之间的转换。
   3.1 为什么需要转换
   一方面，在有些场景下，需要使用基本数据类型对应的包装类的对象。此时就需要将基本数据类型的变量转换为
   包装类的对象。比如：ArrayList的add(Object obj);Object类的equals(Object obj)
   对于包装类来讲，既然我们使用的是对象，那么对象是不能进行+ - * /等运算的。为了能够进行这些运算，就
   需要将包装类的对象转换为基本数据类型的变量。

   3.2 如何转换：
   （装箱）基本数据类型 —> 包装类：① 使用包装类的构造器 ② （建议）调用包装类的valueOf(xxx xx)
   （拆箱）包装类 —> 基本数据类型：调用包装类的xxxValue()

   注意：原来使用基本数据类型变量的位置，改成包装类以后，对于成员变量来说，其默认值变化了！
   jdk5.0新特性：自动装箱、自动拆箱。

4. 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中调试程序】

1. 为什么需要Debug?
   编好的程序在执行过程中如果出现错误，该如何查找或定位错误呢？简单的代码直接就可以看出来，
   但如果代码比较复杂，就需要借助程序调试工具（Debug）来查找错误了。

2. 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、面向对象的特征有哪些方面? （北京楚龙、深圳德科技、直科技、米奇网络、航*拓普）

类似问题：
> 面向对象核心是什么？（平**服）

答:面向对象的编程的核心思想是，将程序中的实体、数据和功能抽象为单独的对象，并在这些对象之间建立联系。

🍺答：封装、继承、多态