JavaSE 学习记录

fatfishccc

已于 2024-06-06 17:47:41 修改

阅读量506

点赞数 5

分类专栏： Java基础文章标签： Java JavaSE 重载重写 OOP 接口抽象类

于 2024-05-26 22:16:21 首次发布

本文链接：https://blog.csdn.net/weixin_44553952/article/details/139222053

版权

Java基础专栏收录该内容

8 篇文章 0 订阅

订阅专栏

我的相关文章：
1. Java 内存
2. `this` VS `super`
3. `重载(Overload)` VS `重写(Override)`
4. 面向对象编程（OOP）的三大特性
5. `instanceof`
6. 静态代码块、匿名代码块和构造方法的执行顺序
7. 接口（Interface）和抽象类（Abstract Class）
8. Java 内部类
9. `Error` VS `Exception`
10. JavaSE 总结
参考

1. Java 内存

在这里插入图片描述

2. `this` VS `super`

this和super是两个关键字，用于引用当前对象和其父类对象

this 关键字：

this 关键字用于引用当前对象，即调用该关键字的方法所属的对象。
主要用途包括：
- 在类的实例方法中，通过 this 来引用当前对象的实例变量或调用当前对象的其他方法。
- 在构造方法中，通过 this 来调用其他构造方法this()或this(...)或引用当前对象的实例变量this.instanceVariable。

super 关键字：

super 关键字用于引用父类的成员，即调用父类的方法或访问父类的实例变量。
主要用途包括：
- 在子类中，通过 super 来调用父类的构造方法super()或super(...)或访问父类的方法和实例变量super.xxx。

注意：
super调用父类的构造方法，必须在构造方法的第一个（this() 也必须在第一个，所以不能同时调用 --> 3.）
super必须只能出现在子类的方法或者构造方法中！
super和this不能同时调用构造方法！

3. `重载(Overload)` VS `重写(Override)`

重载：在一个类中同一个方法的不同实现
- 方法名必须相同；
- 参数列表必须不同（参数个数或者参数类型不同）
- 修饰符可以相同也可以不同（修饰符不能作为判断是否重写的标志）
- 抛出的异常同修饰符，可以相同也可以不同，不能作为判断是否重写的标志
重写：需要有继承关系，子类重写父类的方法！
- 方法名必须相同;
- 参数列表列表必须相同;
- 修饰符：范围可以扩大但不能缩小: public>Protected>Default>private
- 抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException–> Exception(大)

4. 面向对象编程（OOP）的三大特性

面向对象编程（OOP）的三大特性是封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。

封装（Encapsulation）：
- 封装是指将对象的状态（数据）和行为（方法）包装在一起，并对外部隐藏对象的内部实现细节。
- 通过封装，对象的内部细节对外部不可见，只提供有限的接口供外部访问和操作，从而提高了代码的可维护性、可重用性和安全性。
- 例如，使用私有（private）访问修饰符来限制对对象的状态的直接访问，通过公有（public）方法来提供对状态的间接访问。
继承（Inheritance）：
- 继承是指一个类（子类）可以从另一个类（父类）继承其属性和方法，并且可以新增或修改已继承的属性和方法。
- 继承可以帮助代码实现重用，避免重复编写相似的代码，同时也可以通过建立类之间的层次结构来组织和管理代码。
- 通过继承，子类可以拥有父类的属性和方法，从而实现代码的扩展和复用。
多态（Polymorphism）：
- 多态是指同一个方法调用可以在不同的对象上具有不同的行为。
- 多态通过方法重写（Override）和方法重载（Overload）来实现。
- 方法重写是指子类可以重写父类的方法，从而在运行时根据对象的实际类型来调用相应的方法实现，实现了动态绑定。
  
  存在条件：继承条件！方法需要重写！父类引用指向子类对象（Object o = new Person()）！
- 方法重载是指在一个类中定义多个同名但参数列表不同的方法，编译器根据方法的参数列表选择合适的方法进行调用，实现了静态绑定。
- 多态提高了代码的灵活性和可扩展性，使得代码可以更加通用和可维护。

5. `instanceof`

instanceof 是 Java 中的一个关键字，用于检查一个对象是否是一个类的实例，或者是否是该类的子类的实例。它的语法形式如下：

object instanceof Class

其中，object 是要检查的对象，Class 是要检查的类或接口。

instanceof 操作符的返回结果有两种可能：

如果 object 是 Class 的实例，或者是 Class 的子类的实例，或者是实现了 Class 接口的实例，则返回 true。
如果 object 不是 Class 的实例，则返回 false。

6. 静态代码块、匿名代码块和构造方法的执行顺序

静态代码块按照声明顺序执行。
匿名代码块在每次创建对象时执行，按照声明顺序执行。
构造方法在匿名代码块执行之后执行。

7. 接口（Interface）和抽象类（Abstract Class）

成员方法：

接口中的方法默认是抽象的，即接口中的方法没有具体的实现，而抽象类中可以包含抽象方法和具体方法的实现。
在接口中声明的方法都是隐式地声明为 public abstract，而抽象类中的抽象方法必须使用 abstract 关键字显式声明。

多继承：

Java 接口支持多继承，一个类可以实现多个接口，从而具备多个接口的特性。
Java 抽象类不支持多继承，一个类只能继承一个抽象类，但可以同时实现多个接口。

变量：

接口中的变量默认是 public static final 类型的常量，可以省略这些修饰符，因为它们是隐式的。
抽象类中可以包含实例变量和静态变量，可以拥有各种访问修饰符。

构造方法：

接口中不能包含构造方法，因为接口中的方法都是抽象的，无法实例化。

抽象类可以包含构造方法，用于初始化抽象类的实例。

public abstract class MyAbstractClass {
    int b = 1;
    public MyAbstractClass(int b) {
        this.b = b;
    }
    public abstract void method();
}

        MyAbstractClass myAbstractClass = new MyAbstractClass(1) {
            @Override
            public void method() {}
        };

实现方式：

类通过 implements 关键字来实现接口，而通过 extends 关键字来继承抽象类。

8. Java 内部类

成员内部类（Member Inner Class）

成员内部类是定义在另一个类中的类。它与外部类有关联，并可以访问外部类的成员，包括私有成员。成员内部类可以有访问修饰符，并且可以被外部类的成员方法或其他类使用。
```
OuterClass.InnerClass inner = outer.new InnerClass();
```
静态内部类（Static Inner Class）

静态内部类是定义在另一个类中的静态类。它与外部类的实例无关，并且可以直接访问外部类的静态成员，但不能访问外部类的非静态成员。静态内部类可以有自己的静态成员和方法。
```
OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();
```
局部内部类（Local Inner Class）

局部内部类是定义在方法内部的类。它只在定义它的方法内部可见，不能被方法之外的其他类访问。局部内部类可以访问外部方法的局部变量，但必须为 final 或等效的变量。
匿名内部类（Anonymous Inner Class）

匿名内部类是没有名字的内部类，通常用于创建一个实现接口或继承抽象类的临时类实例。它一般在创建实例的同时进行类的定义，并且不能有显式的构造方法。

9. `Error` VS `Exception`

Error 和 Exception 都是继承自 Throwable 类的子类，用于表示在程序执行过程中可能发生的问题，但它们之间有一些重要的区别。

Error（错误）：

Error 代表了严重的系统问题，通常是由于虚拟机（JVM）运行环境出现了错误导致的，例如内存不足、栈溢出等。Error 通常是无法恢复或处理的，应用程序不应该捕获 Error。
一旦发生 Error，程序通常无法继续执行，并且会导致程序终止。常见的 Error 包括 OutOfMemoryError、StackOverflowError 等。

Exception（异常）：

Exception 也代表了程序执行过程中的问题，但相比 Error，Exception 更多地表示的是可以被程序本身处理的异常情况。Exception 分为两种类型：可检查异常（checked exception）和运行时异常（runtime exception）。
可检查异常（checked exception）：编译器会强制要求程序员处理这类异常，要么使用 try-catch 块捕获并处理异常，要么在方法签名中使用 throws 关键字声明抛出异常。
运行时异常（runtime exception）：这类异常通常是由程序错误导致的，编译器不会强制要求程序员处理这些异常。常见的运行时异常包括 NullPointerException、ArrayIndexOutOfBoundsException 等。

Error 如内存不足、栈溢出等在哪些情况下会发生？

内存不足（OutOfMemoryError）：当 Java 程序请求的内存超出了 JVM 可用的内存资源时，会抛出 OutOfMemoryError。这可能是因为程序内存泄漏、创建了过多的对象、处理大量数据等原因导致的。

栈溢出（StackOverflowError）：当方法调用层级过深，栈空间无法容纳更多的方法调用时，会发生栈溢出。这通常是由于递归调用或者无限循环导致的。

虚拟机错误（VirtualMachineError）：这类错误包括 InternalError、UnknownError 等，通常是指 JVM 本身发生了无法处理的错误，例如 JVM 内部出现问题。

类加载错误（LinkageError）：当 Java 虚拟机尝试加载类时出现问题，可能会抛出 LinkageError，例如版本不匹配、类文件损坏等情况。

其他错误（Error）：除了上述常见的错误外，还有一些其他的 Error 类型，如 AssertionError、NoClassDefFoundError 等。

这些 Error 类型通常表示了严重的系统问题，需要进行相应的处理或者对系统进行调整。

受检异常和非受检异常包括哪些异常？

受检异常（Checked Exception）：这些异常在编译时就需要程序员处理，否则编译器会报错。常见的受检异常包括：

IOException：输入输出操作异常，如文件读写异常。
SQLException：数据库操作异常。
ClassNotFoundException：类未找到异常，通常发生于使用反射加载类时。

非受检异常（Unchecked Exception）：也称为运行时异常（Runtime Exception），这些异常不需要在编译时处理，但程序在运行时可能会抛出。常见的非受检异常包括：

NullPointerException：空指针异常，尝试在空对象上调用方法或访问属性时抛出。
ArrayIndexOutOfBoundsException：数组越界异常，访问数组时超出了合法范围。
ArithmeticException：算术异常，例如除以零。
IllegalArgumentException：非法参数异常，传递给方法的参数不合法。