1写出Java的四类八种基本数据类型

1.1背会：

1.2理解：

1.3boolean类型的特殊说明

1.3.1单独使用时

1.3.2放在数组中

2& 和 && 的区别

2.1背会

• 左边表达式 & 右边表达式：即使左边表达式计算结果为false可以推断出整体结果，但仍然会执行右边表达式
• 左边表达式 && 右边表达式：如果左边表达式计算结果为false可以推断出整体结果，所以右边表达式将不再执行，提高代码执行效率

2.2&运算符可以计算的数据类型

2.2.1整数类型

• byte
• short
• int
• long

2.2.2布尔类型

2.2.3字符类型

2.3应用场景

boolean result = (a > 0) & ((b = number * 100) > 100); 假设这里必须给b变量赋值，那么右边表达式就一定要执行

2.4优先级

int a = 10;
boolean b = true;
boolean result = false && true & ((a = 20) == 20);
System.out.println("result = " + result);
System.out.println("a = " + a);
 参照如下代码示例，证明二者优先级：

3switch的参数可以是什么类型

3.1背会

3.2理解

3.2.1JDK1.6及以前版本

3.2.2JDK 1.7及以后版本

3.2.3JDK21版本

public static String formatterSwitch(Object o) {
    return switch (o) {
        case Integer i -> String.format("int %d", i);
        case Long l  -> String.format("long %d", l);
        case Double d -> String.format("double %f", d);
        case String s -> String.format("String %s", s);
        default    -> o.toString();
    };
}

3.2.4所有版本

3.2.5特殊注意

4实例变量和局部变量的区别是什么？

4.1背记

4.1.1代码位置

• 实例变量：类中方法外
• 局部变量：方法中或方法定义的小括号里面

4.1.2内存位置

• 实例变量：作为对象的组成部分，成员变量在堆内存中
• 局部变量：作为方法执行过程中的临时数据，通常在栈内存中（栈帧）

4.1.3生命周期

• 实例变量：作为对象的组成部分，随着对象创建而产生，随着对象的消失而消失
• 局部变量：作为方法执行过程中的临时数据，随着方法的调用而产生，随着方法调用结束而消失

4.1.4有无默认值

• 实例变量：有默认值

• 局部变量：没有默认值，使用的时候必须先赋值

4.2理解

4.2.1作用范围

4.2.2生命周期

4.2.3初始化

5static关键字都能修饰什么？ 都有什么特点

5.1背记

• 修饰成员变量，使成员变量变成静态的类变量；
  • 由于类只加载一份，所以静态变量（也叫类变量）也只有一份
  • 静态变量可以在一定范围内共享，但具体范围需要参照权限修饰符
• 修饰方法，方法就成了静态方法: 可以直接使用类名.方法名进行调用；
• 修饰代码块，就得到了静态代码块，在类加载过程中执行；
• 修饰类，只有内部类可以使用static修饰，此时内部类变成了静态内部类；

5.2理解

5.2.1类级属性

5.2.2无需实例化

5.2.3限制访问非静态成员

5.2.4继承特性

5.2.5默认值

5.2.6静态代码块

6overload和override的区别

6.1背记

6.1.1定义

6.1.2参数列表

6.1.3返回类型

6.1.4作用域

6.1.5编译时决定

为什么『重写』是动态绑定？ 答：有的时候确实要在运行的时候才知道对象的具体类型是什么。比如： walk(Animal animal)这个方法接收Animal类型的参数，这就需要运行时才知道具体传入的是Cat还是Dog

6.1.6口诀

• 重载：方法名相同，参数列表不同，其它不要求
• 重写：两同两小一大
  • 两同：方法名相同、形参列表相同
  • 两小：
    • 子类方法返回值类型小于等于父类方法返回值类型
    • 子类方法throws异常类型小于等于父类方法返回值类型
  • 一大：子类方法权限修饰符大于等于父类方法权限修饰符

6.2理解

6.2.1Overload（重载）

6.2.2Override（重写）

7final和finally的区别

7.1背记

7.1.1总体对比

7.1.2细节：final

• 类：被final修饰的类不能被继承（可以正常创建对象）
• 方法：被final修饰的类不能被重写（可以正常调用）
• 变量：被final修饰的变量只能被赋值一次，于是这个变量也就成了常量

7.1.3细节：finally

7.2理解

• final关键字提供了不可变性的特性，用于确保特定的类、方法或变量的不可更改性，从而保护数据的一致性和安全性。
• finally 是异常处理机制的一部分，它与 try 和 catch 一起使用，形成 try-catch-finally 块。 finally 块中的代码无论异常是否发生，都会被执行。这通常用于放置一些必须执行的清理代码，如关闭文件、释放资源等，以确保资源的正确释放和程序的稳定性。

8this和super都能用到哪些地方？

8.1背记：

8.1.1访问成员变量

• this：可以用于区分成员变量与局部变量重名的情况，如果本类没有这个成员变量，也可以调用父类的成员变量。
• super：可以用于区分本类成员变量与父类成员变量重名的情况，只能调用父类的成员变量。

8.1.2访问成员方法

• this：可以调用本类的成员方法，如果本类没有这个成员方法，也可以调用父类的成员方法。
• super：只能调用父类的成员方法。

8.1.3访问构造器

• this：可以通过this()或this(参数)在当前构造器中调用其它构造器
• super：子类通过super()或super(参数)调用父类构造器

8.2理解：

8.2.1this

8.2.2super

9接口与抽象类的区别

9.1背记

9.1.1关键字

• 抽象类：使用abstract关键字定义
• 接口：使用interface关键字定义

9.1.2设计

• 抽象类：代表对事物通用特性的抽象，可以包含属性和方法
• 接口：主要关注事物的行为，所以它是方法的集合

9.1.3构造器和成员变量

• 抽象类：有构造器，有普通成员变量
• 接口：没有构造器和普通成员变量，其内部变量默认为public static final类型

9.1.4方法实现

• 抽象类：可以包含抽象方法和非抽象方法
• 接口：只能声明抽象方法，但在Java 8起可以有默认方法和静态方法

9.1.5继承与实现

9.1.6访问修饰符

• 抽象类：抽象方法可以有修饰符
• 接口：抽象方法只能是public类型

9.1.7实例化

9.2理解

9.2.1设计层面

• 抽象类：定义一个基础的对象类型，让其他类继承这些基本特征
  • 例如：有一个系统需要处理不同类型的图形，可以定义一个抽象类Shape ，它包含一些如getArea()的抽象方法，然后让Circle、 Rectangle等具体形状类继承Shape并实现这些方法。
• 接口：定义一组不相关类的共同行为
  • 例如：系统中有多种类型的对象需要进行比较，可以实现一个Comparable接口，该接口中定义了compareTo()方法，然后让需要比较的类实现这个接口。

9.2.2功能实现

• 抽象类：表达类型上的从属关系，比如“鸽子是鸟的一种”则更适合使用抽象类来表示这种层次关系，因为抽象类可以包含具体的方法实现。
• 接口：对于需要多个不相关类共有的行为，比如“飞”这个动作，无论是鸟还是飞机都可以飞，这时可以使用接口来定义“飞”的行为，不同的类实现该接口并提供具体的飞行方式。

9.2.3实际应用中的选择

10静态变量与实例变量的区别

10.1背记

• 静态变量是类级别的，是类信息的一部分
• 实例变量是对象级别的，是对象数据的一部分

10.2理解

10.2.1声明

10.2.2存储位置

• 静态变量属于类级别，不依赖于任何对象实例，即使没有创建类的实例，静态变量也存在。
• 实例变量存在于对象实例中，每个对象实例都有自己的实例变量副本。

10.2.3使用方式

• 静态变量可以通过类名直接访问，无需创建类的实例。
• 实例变量必须通过对象实例来访问。

10.2.4内存位置

• 静态变量在方法区中（方法区存放类的信息）
• 实例变量在堆内存中（堆内存存放对象数据）

10.2.5生命周期

• 静态变量随着.class文件加载而产生,随着.class文件结束而结束
• 实例变量随着对象的创建而产生,随着对象的结束而结束

10.2.6调用方式

• 静态变量既可以通过『类名.变量名』方式直接进行调用，也可以通过『对象.变量名』方式进行调用（当然本质上都是先找到类，然后在找类变量）
• 实例变量只能通过『对象.变量名』方式进行访问

11throw和throws 的区别

11.1关键要点

• throw动真格
• throws吓唬人

11.2具体细节

11.2.1使用位置

• throw：在方法体内使用，用来真实抛出一个异常对象
• throws：在方法声明位置使用，用来告诉方法的调用者，这个方法有抛出这些异常的风险，仅仅只是风险，不代表调用时一定会抛出

11.2.2使用效果

• throw：真实抛出异常
• throws：声明方法运行中有可能发生的风险

11.2.3后跟类型

• throw：后跟具体的异常对象，只能是一个
• throws：后跟异常类型，可以多个

11.3有趣发现：throws为什么加“s”？

12String、StringBuilder 与 StringBuffer 的区别

12.1背记

12.2细节

12.2.1可变性

• Java中String类型的字符串是不可改变的字符序列
• String类型的对象一旦创建，其内容就不可改变
• 对String进行任何修改操作，都是创建一个新的String对象
• StringBuilder和StringBuffer是可变的，可以在原有对象的基础上进行修改，不会导致新对象的创建。这使得它们在频繁修改字符串时比 String更加高效。

12.2.2性能

12.2.3线程安全

13==和equals()的区别

13.1背记

• 双等号：
  • 基本数据类型：比较数据本身
  • 引用类型：比较引用地址
• equals()：仅限于引用类型之间比较
  • Object类中未被重写的equals()：使用双等号比较引用地址
  • 官方代码重写equals()之后：比较内容，例如String、Integer等
  • 自定义重写equals()之后：根据重写后的代码逻辑决定

13.2使用建议

• 基本数据类型使用双等号比较
• 引用类型使用equals()比较，如有需要，由开发人员重写equals()方法

14包装类拆箱装箱

14.1背记

• 装箱：将基本数据类型数据转换为包装类型对象
• 拆箱：将包装类型对象转换为基本数据类型数据

14.2理解

14.2.1装箱

• 概念：是指将基本数据类型的值转换成对应包装类的实例对象的过程。
• 方法：可以通过调用包装类的构造器或valueOf()方法来实现手动装箱。
• 自动装箱：从Java 5开始，编译器会自动将基本类型转换为包装类，这称为自动装箱。

14.2.2拆箱

• 概念：是指将包装类对象转换回其对应的基本数据类型的过程。
• 方法：可以通过调用包装类的xxxValue()方法（如 intValue() 、 doubleValue() 等）来实现手动拆箱。
• 自动拆箱：与自动装箱类似，当需要基本数据类型的值时，如果操作的对象是包装类类型，编译器会自动将其转换为基本类型，这称为自动拆箱。

14.2.3注意事项

15异常结构图

16请谈一下Java中I/O技术体系中包含哪些种类的流？

16.1背记

• 按照数据内容分类：
  • 字节流：万能流，可以处理任意类型的文件，主要用于处理二进制数据，如图片、视频等
  • 字符流：非万能，主要用来处理文本文件，提供了对字符数据的高效读写
• 按照数据流动方向分类：
  • 输入流：从源头读取数据，比如从文件中读取
  • 输出流：向目标写入数据，比如写入到文件中
• 按照功能分类：
  • 节点流：直接与数据源相连，比如FileInputStream
  • 处理流：在节点流的基础上提供了额外的功能，比如BufferedInputStream通过缓冲区提高I/O效率，处理流都是对节点流的包装

16.2参考

16.3理解

16.3.1输入流

• InputStream：基于字节的输入流接口，它是最底层的流，能处理任何类型的数据传输，包括文字、图片、视频等
• Reader：基于字符的输入操作接口，用于更高效地处理文本数据。

16.3.2输出流

• OutputStream：基于字节的输出流接口，它同样可以处理各种类型的数据。
• Writer：基于字符的输出操作接口，专门用于文本数据的输出。

16.4思维导图

• I/O流
  • 字节流
    • InputStream输入流
      • FileInputStream
        • 从文件系统的某个文件中获得输入字节用于读取诸如图像数据之类的原始字节流
      • BufferedInputStream
        • 缓冲流，InputStream的间接子类
    • OutputStream输出流
      • FileOutputStream
        • 用于写入诸如图像数据之类的原始字节流
      • BufferedOutputStream
        • 缓冲流，OutputStream的间接子类
  • 字符流
    • Reader
      • InputStreamReader
        • 转换流，字节流通向字符流的桥梁
        • FileReader
          • 读取字符文件的便捷类
      • BufferedReader
        • 缓冲流，特有方法：readLine()
    • Writer
      • OutputStreamWriter
        • 转换流：字符流通向字节流的桥梁
        • FileWriter
          • 写入字符文件的便捷类
      • BufferedWriter
        • 缓冲流，特有方法：newLine()、write(String str)

17请谈谈你对反射的理解

17.1反射要解决的问题

• 编写代码时：无法确定对象的类型
• 运行时：动态判定对象的类型

17.2反射的原理

17.2.1光学中的反射

17.2.2Java 中的反射

17.3反射的具体实现

17.3.1获取Class对象

• Class.forName("全类名")
• 类名.class
• 对象.getClass()
• 类加载器对象.loadClass("全类名")

17.3.2分析类信息

17.3.3动态操作类

17.3.4异常处理

17.3.5性能优化（可选）

17.4示例

package com.atguigu.demo.reflective;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * @Author huzhongkui
 * @Date 2023--09--19:10:30
 * 聪明出于勤奋,天才在于积累
 **/
public class ReflectiveDemo {
    public static void main(String[] args) {
        try {
            // 1.获取任意一个对象所属的类
            Student student = new Student();
            Class<? extends Student> aClass1 = student.getClass();
            System.out.println(aClass1);
            
            // 2.构造任意一个类对象
            Student student1 = aClass1.newInstance();
            System.out.println(student1);
            
            // 3.获取任意一个类中的构造方法
            Class<?> aClass = Class.forName("se.reflective.Student");
            for (Constructor<?> declaredConstructor :
                    aClass.getDeclaredConstructors()) {
                Object instance = declaredConstructor.newInstance();
                System.out.println(instance);
            }
            
            // 4. 获取任意一个类中的方法
            for (Method declaredMethod : aClass.getDeclaredMethods()) {
                System.out.println("Student类中的方法:" + declaredMethod.getName());
            }
            
            // 5. 获取任意一个类中的成员变量
            for (Field declaredField : aClass.getDeclaredFields()) {
                System.out.println("Student类中的成员变量" + declaredField.getName());
            }
            
            // 6.调用任意一个对象的方法
            System.out.println(student1.getAge());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

18深拷贝和浅拷贝

18.1背记

• 相同点：
  • 都需要创建新对象
  • 原对象的基本数据类型属性都是复制值本身
• 不同点：对象的引用类型属性不一样
  • 浅拷贝：复制对象地址
  • 深拷贝：创建新对象，给每个属性复制内容，其内容如果还是引用类型则递归操作

18.2注意

18.3应用场景

• 浅拷贝：可以共享内部引用时使用
• 深拷贝：不能共享内部引用时使用