Java笔试05

在Java中，final 关键字可以用于修饰类、方法和变量：

修饰类：

- 被 final 修饰的类不能被继承，即不能有子类。
- 这通常用于工具类或者不希望被扩展的类。

修饰方法：

- 被 final 修饰的方法不能被子类覆盖。
- 这通常用于确保类的行为不会被改变，或者在性能优化时，因为方法覆盖检查会带来一定的开销。

但是：

不能被重写（Override）：final方法不能在子类中被重写。这是因为final方法的设计意图是让这个方法在继承链中不再改变，确保所有继承这个类的子类都使用同一个方法实现。
可以被重载（Overload）：尽管final方法不能被重写，但它们仍然可以被重载。重载是指在同一个类中定义多个同名方法，但这些方法的参数列表必须有所不同（参数的数量、类型或顺序不同）。

修饰变量：

- 被 final 修饰的变量是常量，一旦赋值后就不能被修改。
- 常量名通常以大写字母开始，并使用下划线分隔单词，以提高可读性。
- 修饰成员变量：类中被声明为 final 的成员变量必须在声明时初始化或者在构造器中初始化，之后不能被修改。
- 修饰局部变量：方法中被声明为 final 的局部变量必须在声明时初始化或者在声明后的立即一次赋值，之后不能被修改。

private 和 protected 访问修饰符，控制成员变量和方法的可见性：

private：

- private 成员变量或方法只能在声明它的类内部访问。
- private 方法不能被子类继承，子类无法访问父类的 private 方法。
- private 变量同样不能被子类继承或访问。
- private 修饰的成员是最不可见的。

protected：

- protected 成员变量或方法可以在同一个包内的其他类以及不同包中的子类中访问。
- protected 方法可以被子类继承，子类可以访问父类的 protected 方法。
- protected 变量也可以被子类继承和访问。
- protected 修饰的成员比 private 可见性高，但比 public 可见性低。

区别：

可见性：private 只能被同一个类访问，而 protected 可以被同一个包内的类以及所有子类访问。
继承：private 成员和方法不参与继承，而 protected 成员和方法会被子类继承。
封装：private 提供了最强的封装，因为它完全限制了外部访问。protected 则在封装和灵活性之间提供了一个折中。

在Java中，限定符通常指的是访问修饰符，它们控制成员的可见性。访问修饰符包括 public、private、protected 以及包级私有（没有修饰符）。

abstract：是一个非访问修饰符，它用于声明抽象类和抽象方法。抽象类不能被实例化，抽象方法没有具体的实现，必须由子类提供实现。

在Java中，“短路”（short-circuit）求值是指在布尔表达式中，如果表达式的结果已经可以确定，那么就不会对表达式的其他部分进行求值。这通常发生在逻辑运算中，特别是使用逻辑AND（&&）和逻辑OR（||）操作符时。

Java的基本数据类型及其占用的内存空间如下：

byte：8位，占用1个字节。
short：16位，占用2个字节。
int：32位，占用4个字节。
long：64位，占用8个字节。
float：32位，占用4个字节。
double：64位，占用8个字节。
char：16位，占用2个字节。
boolean：在Java虚拟机中没有定义其大小，但通常在数组中占用1个字节，在其他情况下占用4个字节。

Java中的多态性是面向对象编程（OOP）的一个核心概念。多态性使得同一个方法调用可以对不同的对象有不同的行为。

方法重载（Overloading）：

- 同一个类中可以有多个同名方法，但参数列表必须不同（参数的类型、数量或顺序不同）。
- 编译器根据方法调用时提供的参数列表来决定具体调用哪个方法。

方法覆盖（Overriding）：

- 子类可以覆盖（Override）父类中的方法，即子类提供了一个与父类方法同名、同参数列表的方法。
- 运行时多态性：在运行时，根据对象的实际类型来调用相应的方法。即使通过父类的引用调用该方法，如果对象是子类的实例，也会调用子类中覆盖的方法。

接口实现（Interface Implementation）：

- 一个类可以实现一个或多个接口，接口中的方法在实现类中必须被具体实现。
- 可以通过接口类型的引用调用实现类中的方法，实现多态性。

抽象类和抽象方法：

- 抽象类是不能实例化的类，它包含一个或多个抽象方法，这些方法没有具体的实现。
- 子类继承抽象类时，必须提供抽象方法的具体实现，除非子类也是抽象的。

泛型（Generics）：

- 从Java 5开始引入，允许在类、接口和方法中使用类型参数，以支持泛型编程。
- 泛型提供了一种方式来编写与类型无关的代码，可以提高代码的复用性和类型安全性。

抽象类：

抽象类可以包含没有具体实现的方法（抽象方法），也可以包含有具体实现的方法（非抽象方法）。
抽象类不能直接实例化，因为可能包含没有实现的方法。
如果子类不是抽象类，那么它必须实现父类中的所有抽象方法。如果一个抽象类的子类本身也是抽象类，那么它不需要实现父抽象类中的所有抽象方法。抽象类可以包含抽象方法，这些方法可以由更具体的子类来实现。如果子类也是抽象的，它可以推迟实现这些方法，直到有一个非抽象的子类出现。
抽象类可以实现一个或多个接口，并且必须提供接口中所有方法的实现，除非抽象类本身也是抽象的。

String 对象一旦创建，其内容就不能被改变。每次对 String 对象进行修改操作时，实际上都会生成一个新的 String 对象。而 StringBuilder 对象的内容可以被修改，这使得它在频繁修改字符串内容的场景下更加高效。

String 类和 StringBuilder 类都可以使用 + 运算符和 append() 方法进行字符串连接。不过，String 使用 + 运算符连接字符串时，每次连接都会生成新的 String 对象，而 StringBuilder 使用 append() 方法连接字符串时，是在原有对象上进行修改。

在Java中，即使使用 StringBuilder 或 StringBuffer 类型的对象，使用 + 号连接字符串时，Java编译器会将这个操作转换为使用 StringBuilder 的 append() 方法的调用来执行连接。这个过程实际上是创建了一个新的 StringBuilder 对象，然后在其上调用 append() 方法，最后通过 toString() 方法将结果转换为一个新的 String 对象。这意味着每次使用 + 连接操作时，都会生成一系列临时的 StringBuilder 对象和新的 String 对象。

(是+String，不是两个StringBuilder + )
StringBuilder 和 StringBuffer的区别

线程安全性：

- StringBuffer 是线程安全的。这意味着它的所有操作都是同步的，可以在多线程环境中使用而不会出现问题。
- StringBuilder 是非线程安全的。它的操作不是同步的，因此在单线程环境中性能更好，但在多线程环境中可能会遇到线程安全问题。

性能：

- 由于 StringBuilder 不需要进行线程同步，所以在单线程环境中，它通常比 StringBuffer 有更好的性能。
- StringBuffer 由于需要进行线程同步，所以在性能上可能会稍逊于 StringBuilder。

使用场景：

- 如果你的代码在单线程环境中运行，并且需要频繁地修改字符串，那么 StringBuilder 是更好的选择，因为它提供了更好的性能。
- 如果你的代码在多线程环境中运行，并且需要频繁地修改字符串，那么 StringBuffer 是更好的选择，因为它是线程安全的。

API：

- StringBuilder 和 StringBuffer 都提供了类似的API，包括 append()、insert()、delete()、replace() 等方法，用于操作字符串。

默认构造方法：

- StringBuilder 的默认构造方法创建的是一个空的字符串缓冲区。
- StringBuffer 的默认构造方法同样创建的是一个空的字符串缓冲区。

继承关系：

- StringBuilder 继承自 AbstractStringBuilder 类。
- StringBuffer 也继承自 AbstractStringBuilder 类。

创建新线程：

继承Thread类并重写run()方法。
通过创建一个继承自 Thread 类的子类，并重写 run() 方法，然后创建该子类的实例并调用其 start() 方法，可以创建并启动一个新线程。

实现Runnable接口并实现run()方法。
通过创建一个实现了 Runnable 接口的类，并实现 run() 方法，然后将该类的实例传递给 Thread 类的构造函数，再调用新 Thread 实例的 start() 方法，可以创建并启动一个新线程。

使用Executor框架。
Executor 框架是Java并发API的一部分，它提供了一种管理线程池和执行异步任务的方法。通过使用 Executors 类的工厂方法创建一个线程池，然后使用 execute 方法提交一个实现了 Runnable 接口的对象，可以创建并启动新线程。

使用Callable和Future接口。
Callable 和 Future 接口与 Executor 框架一起使用，可以创建新线程。Callable 与 Runnable 类似，但它可以返回一个结果和抛出异常。通过使用 Executors 类创建一个线程池，然后使用 submit 方法提交一个实现了 Callable 接口的对象，可以创建并启动新线程。Future 接口用于获取异步执行的结果。

Stack 是一种后进先出（LIFO）的数据结构。

LinkedList 实现了 List 接口，但它也提供了 add、offer 等方法来实现队列的行为。

PriorityQueue 是一种优先队列，元素的出队顺序是根据元素的优先级来决定的，而不是按照先进先出的顺序。

ArrayDeque 是双端队列，但它也提供了标准的队列操作，如 addFirst、addLast、pollFirst、pollLast 等，可以用来实现标准的先进先出队列。

Java中的构造器：

初始化对象：构造器的主要目的是在创建新对象时初始化对象的状态。它允许程序员为对象的属性设置初始值。
分配资源：构造器可以在对象创建时分配必要的资源，比如打开文件、网络连接或数据库连接。
执行验证：构造器可以包含逻辑来验证对象的状态是否有效。如果传入的参数不满足某些条件，构造器可以抛出异常。
控制对象的创建：通过构造器，可以控制对象的创建过程。例如，可以通过构造器中的逻辑来决定是否应该创建一个新的对象实例。
提供不同的构造方式：一个类可以有多个构造器，每个构造器可以有不同的参数列表，这样可以提供多种方式来创建和初始化对象。
继承和多态：在继承中，子类的构造器会调用父类的构造器来确保父类属性的正确初始化。同时，构造器也可以体现出多态性，即通过父类引用可以创建不同类型的子类对象。
封装：构造器有助于封装对象的创建细节，用户不需要知道对象是如何被创建和初始化的，只需要知道如何使用对象。
避免对象状态不一致：通过在构造器中设置对象的初始状态，可以避免对象在创建后立即处于不一致状态。
实现设计模式：某些设计模式，如单例模式（Singleton），可能会利用构造器的特性来控制对象的创建。

public class Person {
    // 类的属性
    private String name;
    private int age;

    // 构造器
    public Person(String name, int age) {
        this.name = name; // 使用this关键字来区分成员变量和参数
        this.age = age;
    }

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

transient修饰符用于声明一个变量不需要被序列化。

final和transient修饰符不能同时用于同一个变量。因为final变量的值是固定的，所以它不需要序列化，因为序列化是为了在反序列化时恢复对象的状态，而final变量的状态是不可变的。因此，同时使用final和transient修饰符是不合理的。

序列化（Serialization）和反序列化（Deserialization）是编程中的两个重要概念，尤其在对象持久化和网络传输中非常常见。这两个过程涉及到将对象的状态转换为可以存储或传输的格式，以及将这种格式转换回对象状态的过程。