Java篇（三）

大大应届生

已于 2023-08-31 22:29:41 修改

阅读量46

点赞数

分类专栏： JAVA及相关基础文章标签： java 开发语言

于 2023-07-27 22:12:37 首次发布

本文链接：https://blog.csdn.net/weixin_45913657/article/details/131969525

版权

JAVA及相关基础专栏收录该内容

22 篇文章 0 订阅

订阅专栏

1、方法重载和重写的区别？

方法重载（Method Overloading）和方法重写（Method Overriding）是Java中两个不同的概念，它们有以下区别：

方法重载（Method Overloading）：
- 方法重载指的是在同一个类中定义多个方法，它们具有相同的名称但不同的参数列表（参数类型或参数个数不同）。
- 方法重载可以在一个类中实现多个功能相似但参数不同的方法，提高了代码的灵活性和可读性。
- 方法重载是在编译时静态绑定的，即在调用方法时，根据传入的参数类型来决定调用哪个重载的方法。

public class MyClass {
    public void print(int num) {
        System.out.println("Print int: " + num);
    }

    public void print(String str) {
        System.out.println("Print String: " + str);
    }
}

方法重写（Method Overriding）：
- 方法重写指的是在子类中重新定义一个与父类中具有相同名称、参数列表和返回类型的方法。
- 方法重写是为了实现多态性，即子类对象可以替代父类对象，调用相同的方法但执行不同的行为。
- 方法重写是在运行时动态绑定的，即在调用方法时，根据对象的实际类型来决定调用哪个重写的方法。

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

总结：

方法重载用于在同一个类中定义多个相似功能的方法，方法名相同但参数列表不同。
方法重写用于子类重新定义父类中的方法，方法名、参数列表和返回类型都必须相同，目的是实现多态性。

2、接口与抽象类区别？

接口（Interface）和抽象类（Abstract Class）是Java中两种用于实现多态性和实现代码重用的机制，它们有以下区别：

定义方式：
- 接口：使用 interface 关键字来定义接口，接口中的方法默认是抽象的，不包含方法体。
- 抽象类：使用 abstract 关键字来定义抽象类，抽象类可以包含抽象方法和具体方法（带有方法体的方法）。

// 接口的定义
public interface MyInterface {
    void method1(); // 抽象方法，无方法体
    void method2();
}

// 抽象类的定义
public abstract class MyAbstractClass {
    abstract void method1(); // 抽象方法，无方法体
    void method2() {
        // 具体方法，有方法体
        System.out.println("This is a concrete method.");
    }
}

继承关系：
- 接口：一个类可以实现多个接口，通过 implements 关键字来实现接口。
- 抽象类：一个类只能继承一个抽象类，通过 extends 关键字来继承抽象类。

// 实现接口
public class MyClass implements MyInterface {
    @Override
    public void method1() {
        // 实现接口中的抽象方法
    }

    @Override
    public void method2() {
        // 实现接口中的抽象方法
    }
}

// 继承抽象类
public class MySubClass extends MyAbstractClass {
    @Override
    void method1() {
        // 实现抽象类中的抽象方法
    }
}

构造方法：
- 接口：接口不能有构造方法，因为接口中的成员变量默认是 public static final 类型，不能被初始化。
- 抽象类：抽象类可以有构造方法，并且在实例化抽象类的子类时，会调用其父类的构造方法来完成初始化。
成员变量：
- 接口：接口中的成员变量默认是 public static final 类型，即常量，必须在接口中初始化，并且不能被子类修改。
- 抽象类：抽象类中可以包含普通的成员变量，且可以被子类继承和修改。

总结：

接口用于定义一组抽象方法，实现类通过实现接口来达到多继承的效果。
抽象类用于封装共用的功能，并可以包含具体方法，子类通过继承抽象类来获取这些功能。

3、常见的Exception有哪些？

在Java中，常见的Exception主要分为两类：Checked Exception（检查异常）和 Unchecked Exception（非检查异常）。它们都继承自Throwable类。下面是常见的Exception示例：

Checked Exception（检查异常）：
- 这类异常在编译时必须进行处理，即要么捕获并处理，要么在方法签名中使用throws关键字声明抛出。
- 例如：IOException、SQLException等。

try {
    // 读取文件的代码
} catch (IOException e) {
    // 处理IOException异常
}

Unchecked Exception（非检查异常）：
- 这类异常是RuntimeException及其子类，通常是由程序逻辑错误导致的，不要求在编译时处理。
- 例如：NullPointerException、ArrayIndexOutOfBoundsException等。

int[] arr = {1, 2, 3};
System.out.println(arr[5]); // 会抛出ArrayIndexOutOfBoundsException

此外，还有一种特殊的异常Error，它表示严重的系统问题，一般不捕获和处理。例如：OutOfMemoryError、StackOverflowError等。Error通常表示程序无法继续执行，很少直接由程序代码引起，而是由于系统环境或虚拟机出现问题。

总结：

Checked Exception（检查异常）需要在编译时处理，常见的有IOException、SQLException等。
Unchecked Exception（非检查异常）通常是由程序逻辑错误引起，不要求在编译时处理，常见的有NullPointerException、ArrayIndexOutOfBoundsException等。
Error表示系统问题，一般不捕获和处理，常见的有OutOfMemoryError、StackOverflowError等。

4、Error和Exception的区别？

在Java中，Error和Exception都是Throwable类的子类，用于表示不同类型的异常情况，它们有以下区别：

Error：
- Error是表示严重问题或系统错误的异常类型。
- Error通常由虚拟机或系统发生的问题引起，而不是由程序本身的逻辑错误导致的。
- Error表示的是一种无法恢复或无法继续执行的错误，通常不应该捕获和处理Error。
- 常见的Error包括OutOfMemoryError（内存溢出）、StackOverflowError（栈溢出）等。

public class Main {
    public static void main(String[] args) {
        try {
            // 代码可能会引发Error
        } catch (Error e) {
            // 不建议捕获和处理Error
        }
    }
}

Exception：
- Exception是表示非正常情况或错误的异常类型，包括Checked Exception和Unchecked Exception。
- Checked Exception是需要在编译时进行处理的异常，通常由外部环境或用户的操作引起，例如IOException、SQLException等。
- Unchecked Exception是不需要在编译时处理的异常，通常是由程序逻辑错误引起，例如NullPointerException、ArrayIndexOutOfBoundsException等。

public class Main {
    public static void main(String[] args) {
        try {
            // 代码可能会引发Exception
        } catch (Exception e) {
            // 捕获和处理Exception
        }
    }
}

总结：

Error表示严重的系统问题，通常不应该捕获和处理，而应该由虚拟机或系统进行处理。
Exception表示非正常情况或错误，分为Checked Exception和Unchecked Exception，需要根据情况捕获和处理。

5、运行时异常和非运行时异常（checked）的区别？

在Java中，异常可以分为运行时异常（RuntimeException）和非运行时异常（Checked Exception）。它们的区别主要体现在是否需要在编译时处理，具体如下：

运行时异常（RuntimeException）：
- 运行时异常是RuntimeException及其子类的异常，它们是一类不需要在编译时强制处理的异常。
- 运行时异常通常由程序逻辑错误引起，例如空指针异常（NullPointerException）、数组越界异常（ArrayIndexOutOfBoundsException）等。
- 在编写代码时，可以选择是否处理这类异常，但不强制要求使用try-catch块进行捕获，也不需要在方法签名中声明抛出。

public class Main {
    public static void main(String[] args) {
        // 不需要在编译时处理运行时异常
        int[] arr = {1, 2, 3};
        System.out.println(arr[5]); // 可能引发ArrayIndexOutOfBoundsException，但不强制处理
    }
}

非运行时异常（Checked Exception）：
- 非运行时异常是Exception的子类中，除了RuntimeException及其子类以外的异常，需要在编译时进行强制处理。
- 非运行时异常通常由外部环境或用户操作引起，例如IO操作可能引发的IOException、数据库操作可能引发的SQLException等。
- 在编写代码时，必须使用try-catch块捕获这类异常，或在方法签名中使用throws关键字声明抛出，否则会产生编译错误。

import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try {
            // 需要在编译时处理非运行时异常
            throw new IOException(); // 编译错误，需要捕获或声明抛出IOException
        } catch (IOException e) {
            // 处理IOException
        }
    }
}

总结：

运行时异常是RuntimeException及其子类的异常，不需要在编译时处理。
非运行时异常是Exception的子类，除了RuntimeException及其子类以外的异常，需要在编译时进行强制处理。

6、throw和throws的区别？

throw 和 throws 是Java中用于处理异常的两个关键字，它们的作用和用法有所不同：

throw：
- throw 关键字用于抛出一个异常对象，用于在代码中主动触发异常情况。
- 当某个条件满足时，可以使用 throw 关键字抛出一个异常对象，将控制权交给异常处理机制，从而中断当前方法的执行。
- throw 后面通常跟着一个异常对象，该对象必须是一个已经实例化的异常类的对象。

public void checkNumber(int num) throws IllegalArgumentException {
    if (num <= 0) {
        throw new IllegalArgumentException("Number must be positive.");
    }
}

throws：
- throws 关键字用于在方法签名中声明该方法可能抛出的异常。
- 当一个方法可能会抛出一个检查异常（非运行时异常）时，在方法的声明中可以使用 throws 关键字指定抛出的异常类型，以告诉调用者该方法可能会抛出哪些异常。
- 如果一个方法在执行过程中可能会抛出多种异常，可以在方法签名中使用 throws 声明多个异常类型，使用逗号分隔。

public void readFile() throws IOException, FileNotFoundException {
    // 方法可能会抛出IOException或FileNotFoundException
}

总结：

throw 用于抛出一个异常对象，主动触发异常。
throws 用于在方法签名中声明该方法可能抛出的异常类型，告诉调用者可能的异常情况。

7、通过故事讲清楚NIO

假设有一个小快递员小明（Representing NIO，即New I/O）和一个大快递公司（Representing I/O，即传统的I/O）。

故事开始：

一天，小明接到快递公司的任务，需要去派送10份快递到不同的地址。传统的快递公司规定，每次只能派送一份快递，所以小明要一个一个地去送。

然而，小明是个聪明的快递员，他想到了一种更高效的方式。他准备使用一辆小型货车（Representing NIO的Selector）来同时运送多份快递。小明利用货车上的分区（Representing NIO的Channel）将不同地址的快递分别装载到不同的区域。

这样，小明只需一次性出发，将所有快递一起送出，不需要多次往返。他可以同时在货车上处理多份快递，从而提高了送货的效率。

另一方面，传统的快递公司（I/O）的快递员需要一个一个地送快递，每次只能携带一份快递。这样，快递员需要多次往返，效率较低。

这个故事中的小明就代表了NIO（New I/O）的特性。NIO允许在单个线程中处理多个连接，通过使用Selector来实现高效的事件驱动型I/O操作。这种方式可以提高系统的处理效率和性能。

相比之下，传统的I/O（Input/Output）模型，每个连接都需要一个独立的线程来处理，当连接数增加时，线程数量也会增加，可能会导致线程资源的浪费和性能问题。

总结：

NIO（New I/O）是一种高效的I/O模型，通过使用Selector来实现单线程处理多个连接，从而提高系统的处理效率和性能。这种方式类似于小快递员小明利用货车一次性运送多份快递的情景，而传统的I/O则类似于快递公司需要多个快递员分别送快递的方式。

8、BIO/NIO/AIO区别的区别？

BIO（Blocking I/O）、NIO（Non-blocking I/O）和AIO（Asynchronous I/O）是Java中三种不同的I/O模型，它们的主要区别在于处理I/O操作的方式和效率：

BIO（Blocking I/O）：
- 同步阻塞式I/O模型，传统的I/O模型。
- 在进行I/O操作时，线程会被阻塞，直到数据准备好或操作完成。
- 当有多个客户端连接时，需要为每个连接创建一个线程，线程之间的切换开销较大。
- 不适用于高并发的场景，容易导致线程资源浪费和性能下降。
NIO（Non-blocking I/O）：
- 同步非阻塞式I/O模型，引入了Channel和Selector的概念。
- 使用单线程（或少数几个线程）管理多个连接，在I/O操作时，线程不会被阻塞，而是不断轮询是否有数据准备好。
- 当有大量客户端连接时，使用单线程管理连接可以降低线程切换的开销，提高系统的性能和效率。
- 适用于高并发的场景，但在处理大量连接时，仍可能出现性能瓶颈。
AIO（Asynchronous I/O）：
- 异步非阻塞式I/O模型，引入了异步通道（AsynchronousChannel）的概念。
- 在进行I/O操作时，不需要等待数据准备或操作完成，而是通过回调方式来处理完成事件。
- 使用异步I/O可以提高系统的并发性能，特别适用于高并发、大量连接的场景。
- 与NIO相比，AIO更加高效，不需要通过轮询来等待数据准备好，而是可以直接处理数据。

选择使用哪种I/O模型取决于具体的应用场景和需求。对于普通的低并发场景，BIO可能足够满足要求。对于高并发、大量连接的场景，NIO和AIO更适合，其中AIO相对于NIO来说更加高效，但由于AIO在Java 7引入，需要考虑兼容性问题。

9、守护线程是什么？

守护线程（Daemon Thread）是一种特殊类型的线程，在Java中通过设置线程的daemon属性来标识。守护线程与普通线程（用户线程）在行为上有一些重要的区别：

守护线程的特点：
- 守护线程的作用是为其他线程提供服务，它并不属于程序中不可或缺的部分。
- 当所有的用户线程都执行完毕后，即使守护线程还在运行，JVM也会自动退出，从而终止所有守护线程。
- 守护线程通常用于执行后台任务或周期性的服务，如垃圾回收、定时任务等。
守护线程的创建：
- 在Java中，通过调用Thread类的setDaemon(true)方法将线程设置为守护线程。默认情况下，线程是普通线程，不是守护线程。

Thread daemonThread = new Thread(new Runnable() {
    public void run() {
        // 守护线程执行的任务
    }
});
daemonThread.setDaemon(true); // 设置为守护线程
daemonThread.start(); // 启动线程

守护线程的注意事项：
- 守护线程应该在启动其他线程之前设置，因为守护状态不能被修改。
- 守护线程不能用来执行需要完整执行的任务，因为它随时可能被终止。
- 守护线程通常不应该访问共享资源，因为在其他线程可能还在使用这些资源的时候，守护线程可能会被终止。

总结：守护线程是一种特殊类型的线程，用于为其他线程提供服务的后台线程。当所有的用户线程执行完毕后，即使守护线程还在运行，JVM也会自动退出，从而终止所有守护线程。

10、Java支持多继承吗？

Java 不支持多继承。在 Java 中，一个类只能继承自一个直接父类，即所谓的单继承。

这种设计是为了避免多继承可能导致的歧义和复杂性。如果 Java 支持多继承，即一个类可以同时继承自多个父类，那么在处理方法调用、字段访问等问题时可能出现歧义。例如，如果一个类同时继承自两个父类，并且这两个父类有相同的方法名，那么在调用这个方法时编译器就无法确定应该调用哪个父类的方法。

为了解决这个问题，Java 引入了接口（interface）的概念，使得类可以实现多个接口。接口允许定义一组方法的规范，而类可以通过实现接口来达到多继承的效果。一个类可以同时继承自一个父类，并实现多个接口，从而拥有多个接口的特性。

// 单继承，继承自一个父类
class Animal {
    // 父类的方法和字段
}

// 多实现接口，实现了多个接口
class Dog extends Animal implements Runnable, Serializable {
    // 实现接口的方法
}

通过接口的方式，Java 实现了一种灵活的多继承机制，使得类可以在继承一个父类的同时，还能实现多个接口，从而实现了多继承的部分特性。

11、如何实现对象克隆？

在Java中，有两种方式可以实现对象的克隆：

浅克隆（Shallow Clone）：
- 浅克隆是指复制对象时只复制对象本身和其内部的基本数据类型，而不复制对象内部的引用类型对象。
- 使用Object类的clone()方法可以实现浅克隆，前提是被克隆的类必须实现Cloneable接口，否则会抛出CloneNotSupportedException异常。

class Person implements Cloneable {
    private String name;
    private int age;

    // 省略构造方法、getter和setter

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

// 测试
Person p1 = new Person("Alice", 30);
Person p2 = (Person) p1.clone(); // 使用clone()方法实现浅克隆

深克隆（Deep Clone）：
- 深克隆是指复制对象时不仅复制对象本身，还复制对象内部的引用类型对象，使得克隆后的对象与原对象完全独立，对其中一个对象的修改不会影响另一个对象。
- 实现深克隆的方式较复杂，可以通过序列化和反序列化、递归复制等方式来实现。

import java.io.*;

class Address implements Serializable {
    private String city;
    private String street;

    // 省略构造方法、getter和setter
}

class Person implements Serializable {
    private String name;
    private int age;
    private Address address;

    // 省略构造方法、getter和setter

    // 使用序列化和反序列化实现深克隆
    public Person deepClone() throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);

        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (Person) ois.readObject();
    }
}

// 测试
Person p1 = new Person("Alice", 30, new Address("CityA", "StreetB"));
Person p2 = p1.deepClone(); // 使用序列化和反序列化实现深克隆

总结：

对象克隆可以通过浅克隆和深克隆来实现。
浅克隆只复制对象本身和其内部的基本数据类型，对于引用类型对象仍然共享同一个引用。
深克隆不仅复制对象本身，还复制对象内部的引用类型对象，使得克隆后的对象与原对象完全独立。

12、同步和异步的区别？

同步（Synchronous）和异步（Asynchronous）是两种不同的执行模式，用于描述任务的执行方式和调度方式：

同步（Synchronous）：
- 同步指的是任务按照顺序逐个执行，一个任务的执行需要等待上一个任务完成后才能开始。
- 在同步执行中，任务的执行是阻塞的，即任务执行过程中会一直等待直到任务完成，然后再执行下一个任务。
- 同步执行适用于简单的顺序任务，可以保证任务的执行顺序和结果的可靠性。
异步（Asynchronous）：
- 异步指的是任务的执行不按照顺序逐个执行，而是通过异步调度机制，任务的执行和结果处理可以是并行的。
- 在异步执行中，任务的执行是非阻塞的，即任务执行过程中不会等待任务完成，而是立即返回，继续执行后续的任务。
- 异步执行适用于需要较长时间的任务，如网络请求、文件读写等，可以提高系统的并发性和响应速度。

比喻：假设有一个人要做三件事情：洗衣服、煮饭、看电影。

同步执行：按照顺序逐个执行，先洗衣服，然后煮饭，最后看电影，每个任务都需要等待上一个任务完成后才能开始。
异步执行：通过异步调度机制，可以同时进行洗衣服、煮饭和看电影，每个任务的执行和结果处理可以是并行的，无需等待。

总结：

同步执行是按照顺序逐个执行任务，任务执行过程中阻塞等待任务完成。
异步执行是通过异步调度机制，任务的执行和结果处理可以是并行的，任务执行过程中不会阻塞等待。

13、阻塞和非阻塞的区别？

阻塞（Blocking）和非阻塞（Non-blocking）是两种不同的任务处理方式，用于描述任务在执行过程中是否会阻塞等待的情况：

阻塞（Blocking）：
- 阻塞指的是任务在执行过程中会等待某个操作完成后再继续执行，任务的执行会暂时停滞。
- 在阻塞模式下，任务会一直等待直到所需的资源或操作准备就绪，然后再继续执行。
- 阻塞适用于任务间的依赖关系或任务需要确保某些条件满足后才能继续执行的情况。
非阻塞（Non-blocking）：
- 非阻塞指的是任务在执行过程中不会等待某个操作完成，而是立即返回，继续执行后续的任务。
- 在非阻塞模式下，任务会尝试执行某个操作，如果操作不能立即完成，任务会立即返回并继续执行其他任务，不会等待操作完成。
- 非阻塞适用于任务之间相互独立，任务可以并行执行的情况。

比喻：假设有一个人要去银行取钱：