Java面试复习大纲

你不懂、、、

已于 2025-02-13 14:05:27 修改

阅读量1.1k

点赞数 23

CC 4.0 BY-SA版权

分类专栏：面试文章标签：面试职场和发展 java

于 2024-08-14 15:07:21 首次发布

本文链接：https://blog.youkuaiyun.com/zhangzhanbin/article/details/141191386

在这里插入图片描述

下面我将对集合、多线程、反射、注解和动态代理等基础开发技术进行更详细的介绍。

1. 集合框架

Java的集合框架提供了一种用于存储和操作对象的结构。它包括一组接口和类，能够支持动态地存储对象，并提供对这些对象的操作，如查找、添加、删除等。主要接口和类包括：

接口：
- Collection：集合的根接口，表示一组对象的集合。
  - List：有序集合，允许重复元素。常用实现有：
    - ArrayList：基于动态数组实现，提供快速随机访问。
    - LinkedList：基于双向链表实现，适合频繁插入和删除。
  - Set：不允许重复元素的集合。常用实现有：
    - HashSet：基于哈希表实现，提供快速查找。
    - TreeSet：基于红黑树实现，自动排序。
- Map：键值对的集合，不允许重复键。常用实现有：
  - HashMap：基于哈希表实现，查找速度快。
  - TreeMap：基于红黑树实现，键有序。
常用方法：
- add(), remove(), contains(), size()等方法用于管理集合中的元素。
- 使用迭代器（Iterator）遍历集合元素。

2. 多线程

多线程是指在一个程序中并发执行多个线程，每个线程都是独立执行的任务。Java提供了丰富的多线程支持。

创建线程：
- 继承Thread类：重写run()方法，并调用start()方法启动线程。
- 实现Runnable接口：实现run()方法，将其作为参数传递给Thread构造器。
线程管理：
- 状态：线程有新建、就绪、运行、阻塞和死亡等状态。
- 方法：
  - sleep(long millis)：使当前线程休眠指定时间。
  - join()：等待线程结束。
  - yield()：主动让出CPU使用权。
线程安全：在多线程环境下，多个线程可能同时访问共享资源，这可能导致数据不一致。可以使用以下方式实现线程安全：
- synchronized关键字：用于同步方法或代码块。
- Lock接口：Java提供的更灵活的锁机制。

3. 反射

反射是Java的一种机制，允许程序在运行时检查和操作类及其属性、方法、构造函数等。

使用场景：
- 动态加载类。
- 动态调用方法。
- 访问和修改对象属性。
主要类和方法：
- Class类：提供对类的信息。
  - getDeclaredMethods()：获取类的所有方法。
  - getDeclaredFields()：获取类的所有字段。
- Method类：表示类的方法。
  - invoke(Object obj, Object... args)：动态调用方法。
- Field类：表示类的字段。
  - get(Object obj)和set(Object obj, Object value)：获取和修改字段值。

4. 注解

注解是Java的一种元数据机制，可以为程序中的类、方法、字段等提供额外的信息。注解不会直接影响程序的逻辑，但可以被编译器或运行时工具使用。

内置注解：
- @Override：指示子类的方法重写了父类的方法。
- @Deprecated：指示某个元素是过时的。
- @SuppressWarnings：抑制编译器警告。

自定义注解：

使用@interface定义注解。
可以添加元注解，如@Retention, @Target等。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation{
     
    String value();
}

使用注解：可以通过反射读取注解信息。

在类的方法上使用注解：

public class MyClass {
   
    @MyAnnotation("Hello, Annotation!")
    public void myMethod() {
   
        // do something
    }
}

在myMethod()方法上使用了MyAnnotation注解，并传递了一个字符串参数。

使用反射读取注解信息：

import java.lang.annotation.*;
import java.lang.reflect.*;

public class Main {
   
    public static void main(String[] args) throws Exception {
   
        MyClass obj = new MyClass();
        Method method = obj.getClass().getMethod("myMethod");

        // 检查方法是否存在注解
        if (method.isAnnotationPresent(MyAnnotation.class)) {
   
            MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
            String value = annotation.value();
            System.out.println("Annotation Value: " + value);
        } else {
   
            System.out.println("Annotation not found.");
        }
    }
}

在上述示例中，我们通过反射获取了myMethod()方法，并使用isAnnotationPresent()方法检查方法是否存在MyAnnotation注解。如果存在，我们使用getAnnotation()方法获取注解实例，然后读取注解的属性值。

运行以上代码，输出结果为：

Annotation Value: Hello, Annotation!

通过反射，我们成功读取了myMethod()方法上的注解信息。

反射提供了一种动态检查和处理注解的方式，使我们能够在运行时根据注解的信息执行特定的逻辑。这在一些框架和库中得到广泛应用，例如Spring框架的依赖注入和AOP编程。

5. 动态代理

动态代理是一种设计模式，允许在运行时创建一个代理对象，拦截方法调用。Java提供了java.lang.reflect.Proxy类和InvocationHandler接口来实现动态代理。

创建动态代理：
1. 定义接口。
2. 实现InvocationHandler接口，重写invoke()方法。
3. 使用Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)创建代理实例。
示例：

import java.lang.reflect.*;

interface MyInterface {
   
    void myMethod();
}

class MyInvocationHandler implements InvocationHandler {
   
    private Object target;

    public MyInvocationHandler(Object target) {
   
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        System.out.println("Before method");
        Object result = method.invoke(target, args);
        System.out.println("After method");
        return result;
    }
}

class MyClass implements MyInterface {
   
    public void myMethod() {
   
        System.out.println("Executing myMethod");
    }
}

// 使用
MyInterface original = new MyClass();
MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
    original.getClass().getClassLoader(),
    original.getClass().getInterfaces(),
    new MyInvocationHandler(original)
);
proxy.myMethod();

在上述示例中，MyInvocationHandler会在调用myMethod之前和之后打印信息。

总结

集合、多线程、反射、注解和动态代理是Java开发中非常重要的基础技术。掌握这些技术可以帮助你更全面地理解Java的特性，更有效地进行软件开发。每个技术都有其独特的用法和最佳实践，建议通过项目实践加深理解。

设计模式是在软件设计中经常出现的常见问题的解决方案。它们是经过反复验证的，为了解决特定类型问题而诞生的模式化解决方案。设计模式可以帮助我们更好地组织代码结构，提高代码的可读性、可维护性和可扩展性。

下面我将详细介绍几种常见的设计模式，包括单例模式、策略模式和模板方法模式。

1. 单例模式（Singleton Pattern）

单例模式是一种创建型模式，它保证一个类只有一个实例，并提供一个全局访问点。单例模式的主要目的是确保在整个应用程序中，某个类只有一个实例存在。

public class Singleton {
   
    private static Singleton instance;

    private Singleton() {
   }  // 私有构造函数

    public static Singleton getInstance() {
   
        if (instance == null) {
   
            instance = new Singleton();
        }
        return instance;
    }
}

单例模式的优点包括：

对于频繁使用的对象，可以减少资源消耗。
某些场景下，如线程池、数据库连接等，确保只有一个实例可以有效地控制资源访问。

2. 策略模式（Strategy Pattern）

策略模式是一种行为型模式，它定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。策略模式允许算法的变化独立于使用算法的客户。

interface Strategy {
   
    int doOperation(int num1, int num2);
}

class OperationAdd implements Strategy {
   
    public int doOperation(int num1, int num2) {
   
        return num1 + num2;
    }
}

class OperationSubtract implements Strategy {
   
    public int doOperation(int num1, int num2) {
   
        return num1 - num2;
    }
}

class Context {
   
    private Strategy strategy;

    public Context(Strategy strategy) {
   
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
   
        return strategy.doOperation(num1, num2);
    }
}

策略模式的优点包括：

算法可以自由切换。
它可以避免使用多重条件判断。

3. 模板方法模式（Template Method Pattern）

模板方法模式是一种行为型模式，用于定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变算法的结构即可重新定义算法的某些步骤。

abstract class Game {
   
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();

    // 模板方法
    public final void play() {
   
        initialize();
        startPlay();
        endPlay();
    }
}

class Cricket extends Game {
   
    void initialize() {
   
        System.out.println("Cricket Game Initialized! Start playing.");
    }
    void startPlay() {
   
        System.out.println("Cricket Game Started. Enjoy the game!");
    }
    void endPlay() {
   
        System.out.println("Cricket Game Finished!");
    }
}

模板方法模式的优点包括：

提供结构良好的、可扩展的代码。
通过在父类中提供默认实现，能够提高代码复用性。

这三种设计模式都是在软件开发中非常有用的，它们可以帮助我们更好地组织和管理代码，提高代码的灵活性和可维护性。

场景及案例

单例模式适用于以下场景：

当一个类只能有一个实例，并且客户端需要全局访问这个实例时，可以使用单例模式。例如，配置信息类、日志记录类等通常适合使用单例模式，以确保全局只有一个实例，且所有代码都共享这个实例。
当这个唯一实例需要延迟初始化时，也可以使用单例模式。单例模式可以确保只在需要时才创建实例。

下面是一个使用单例模式的简单代码示例：

public class Singleton {
   
    // 使用一个私有静态变量来存储单例实例
    private static Singleton instance;

    // 将构造方法设为私有，禁止通过new关键字实例化对象
    private Singleton() {
   }

    // 提供一个静态方法来获取单例实例
    public static Singleton getInstance() {
   
        // 延迟初始化：第一次调用时才创建实例
        if (instance == null) {
   
            instance = new Singleton();
        }
        return instance;
    }

    // 添加其他业务方法
    public void doSomething() {
   
        System.out.println("Doing something...");
    }
}

// 测试
public class Main {
   
    public static void main(String[] args) {
   
        // 获取单例实例
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();

        // 判断是否为同一个实例
        System.out.println(singleton1 == singleton2);  // 输出 true

        // 调用单例实例的方法
        singleton1.doSomething();
    }
}

在上述示例中，Singleton类使用私有静态变量instance来存储单例实例，并将构造方法设为私有，以防止通过new关键字实例化对象。通过提供一个静态方法getInstance()来获取单例实例，同时使用延迟初始化确保只在需要时才创建实例。

在测试代码中，我们可以看到通过多次调用getInstance()方法获得的实例都是同一个，证明了单例模式的实现。

策略模式适用于以下场景：

多种算法或行为的选择：当有多种算法或行为可以选择，并且需要在运行时动态地决定使用哪种算法或行为时，可以使用策略模式。通过定义不同的策略类，每个策略类封装了一个具体的算法或行为，可以在运行时根据需要灵活地选择使用不同的策略。
避免使用大量的条件判断语句：当一个类有多个条件判断语句，并且每个条件下执行的逻辑不同时，可以使用策略模式来避免使用大量的条件判断语句。将不同的条件逻辑封装到不同的策略类中，每个策略类负责执行特定的逻辑，可以提高代码的可读性和可维护性。
替代继承实现变化行为：当需要在不同的子类中实现一些共同的行为，但又不想使用继承来实现时，可以使用策略模式。通过将共同的行为抽象为一个策略接口，并将具体的行为实现封装在不同的策略类中，可以避免使用继承，减少类的层次结构复杂性。
可扩展性与维护性：策略模式使得新增、修改或删除一种算法或行为变得更加简单。由于每个策略类都是相互独立的，对一个策略类的修改不会影响到其他策略类，可以灵活地增加、修改或删除特定的策略，提高代码的可扩展性和维护性。

下面是一个使用策略模式的简单代码示例：

// 定义策略接口
interface PaymentStrategy {
   
    void pay(double amount);
}

// 定义具体的策略类
class CreditCardStrategy implements PaymentStrategy {
   
    private String cardNumber;
    private String cvv;

    public CreditCardStrategy(String cardNumber, String cvv) {
   
        this.cardNumber = cardNumber;
        this.cvv = cvv;
    }

    public void pay(double amount) {
   
        System.out.println("Paying " + amount + " with credit card: " + cardNumber);
    }
}

class PayPalStrategy implements PaymentStrategy {
   
    private String email;
    private String password;

    public PayPalStrategy(String email, String password) {
   
        this.email = email;
        this.password = password;
    }

    public void pay(double amount) {
   
        System.out.println("Paying " + amount + " with PayPal: " + email);
    }
}

// 使用策略的上下文类
class ShoppingCart {
   
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
   
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(double amount) {
   
        paymentStrategy.pay(amount);
    }
}

// 测试
public class Main {
   
    public static void main(String[] args) {
   
        ShoppingCart cart = new ShoppingCart();

        // 使用信用卡支付
        PaymentStrategy creditCardStrategy = new CreditCardStrategy("1234567890", "123");
        cart.setPaymentStrategy(creditCardStrategy);
        cart.checkout(100.0);

        // 使用PayPal支付
        PaymentStrategy payPalStrategy = new PayPalStrategy("example@example.com", "password");
        cart.setPaymentStrategy(payPalStrategy);
        cart.checkout(200.0);
    }
}

在上述示例中，我们定义了一个策略接口PaymentStrategy，并提供了两个具体的策略类CreditCardStrategy和PayPalStrategy，每个策略类封装了不同的支付逻辑。ShoppingCart类作为使用策略的上下文类，可以在运行时选择不同的支付策略，通过调用checkout()方法进行支付。

模板方法模式适用于以下场景：

一次性实现一个算法的不变的部分，并将可变的行为留给子类来实现：模板方法模式适用于一次性实现一个算法的不变的部分，并将可变的部分留给子类来实现。这样可以在不改变算法结构的前提下，通过子类的重写来改变具体实现细节。
需要通过子类来实现特定的算法步骤：当一个算法有多个步骤，其中某些步骤可以有不同的实现方式，可以使用模板方法模式。通过将共同的步骤实现在父类的模板方法中，然后由子类来重写特定的步骤，实现特定的算法步骤。

下面是一个使用模板方法模式的简单代码示例：

// 抽象类定义模板方法
abstract class Game {
   
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();

    // 模板方法
    public final void play() {
   
        initialize();
        startPlay();
        endPlay();
    }
}

// 具体子类实现算法的特定步骤
class Cricket extends Game {
   
    void initialize() {
   
        System.out.println("Cricket Game Initialized! Start playing.");
    }
    void startPlay() {
   
        System.out.println("Cricket Game Started. Enjoy the game!");
    }
    void endPlay() {
   
        System.out.println("Cricket Game Finished!");
    }
}

class Football extends Game {
   
    void initialize() {
   
        System.out.println("Football Game Initialized! Start playing.");
    }
    void startPlay() {
   
        System.out.println("Football Game Started. Enjoy the game!");
    }
    void endPlay() {
   
        System.out.println("Football Game Finished!");
    }
}

// 测试
public class Main {
   
    public static void main(String[] args) {
   
        Game game = new Cricket();
        game.play();
        System.out.println();

        game = new Football();
        game.play();
    }
}

在上述示例中，我们定义了一个抽象类Game，其中包含一个模板方法play()和若干抽象方法initialize()、startPlay()和endPlay()。具体的子类Cricket和Football分别实现了这些抽象方法，以实现特定的算法步骤。

在测试代码中，我们可以看到当实例化Cricket和Football类时，它们都调用了play()方法，实现了模板方法模式的应用。

当谈论并发编程时，synchronized、volatile、AQS（AbstractQueuedSynchronizer）、CAS（Compare and Swap）和ReentrantLock是一些常见的并发技术和概念。下面我将为您详细介绍这些概念，并提供一些代码实现案例。

Synchronized

synchronized 是 Java 中用于实现线程安全的关键字，它是 Java 提供的最基本的同步机制之一。通过使用 synchronized，您可以确保在多线程环境中对共享资源的访问是安全的，避免了线程之间的竞争条件。下面将详细介绍 synchronized 的工作原理、用法、优缺点以及常见应用场景。

1. `synchronized` 的工作原理

监视器锁：每个 Java 对象都有一个监视器锁（monitor）。synchronized 关键字用于获取和释放这个锁。只有获得锁的线程可以执行被同步的方法或代码块，其他线程将被阻塞，直到锁被释放。
可重入性：Java 的 synchronized 是可重入的，这意味着同一个线程可以多次进入同步方法，而不会导致死锁。锁的计数器会增加，直到线程退出所有持有的锁，锁才会被释放。
内存可见性：当一个线程释放了锁，其他线程在获取这个锁时，可以看到先前线程对共享变量所做的任何修改。这确保了内存的可见性。

2. 使用方式

synchronized 主要有两种使用方式：

2.1. 修饰实例方法

当使用 synchronized 修饰实例方法时，该方法的锁是当前实例对象的锁。

public class SynchronizedInstanceMethod {
   
    private int count = 0;

    public synchronized void increment() {
   
        count++;
    }
}

在这个例子中，increment 方法是同步的，只有一个线程可以同时访问该方法，确保了对 count 的安全访问。

2.2. 修饰静态方法

当 synchronized 修饰静态方法时，锁是当前类的类对象的锁。也就是说，同一个类的所有实例共享这个锁。

public class SynchronizedStaticMethod {
   
    private static int count = 0;

    public static synchronized void increment() {
   
        count++;
    }
}

在这个例子中，increment 方法是同步的，意味着任何线程在调用这个静态方法时，必须获得类对象的锁。

2.3. 修饰代码块

您还可以将 synchronized 用于代码块，以更精细地控制锁的粒度。这样可以减少锁的范围，提高性能。

public class SynchronizedBlock {
   
    private int count = 0;

    public void increment() {
   
        synchronized (this) {
   
            count++;
        }
    }
}

在这个例子中，只有在进入同步块时才能访问 count，从而减少了锁的持有时间。

3. 优缺点

3.1. 优点

简单易用：使用 synchronized 非常简单，易于理解和实现。
自动释放锁：一旦线程退出同步方法或代码块，锁会自动释放，无需手动管理。

3.2. 缺点

性能问题：synchronized 的性能相对较低，尤其是在高竞争的场景中，线程可能会频繁地被阻塞和唤醒。
死锁风险：如果不慎设计不当，可能会导致死锁问题，即多个线程互相等待对方释放锁。
可扩展性差：在复杂的并发场景中，使用 synchronized 可能会导致可扩展性差。

4. 常见应用场景

共享资源的访问控制：在多线程环境中，访问共享资源（如共享变量、文件、数据库连接等）时，可以使用 synchronized 来确保线程安全。

public class Counter {
   
    private int count = 0;

    public synchronized void increment() {
   
        count++;
    }

    public synchronized int getCount() {
   
        return count;
    }
}

单例模式：在实现懒汉式单例模式时，可以使用 synchronized 确保实例的唯一性。

public class Singleton {
   
    private static Singleton instance;

    public static synchronized Singleton getInstance() {
   
        if (instance == null) {
   
            instance = new Singleton();
        }
        return instance;
    }
}

5. 示例代码

下面是一个简单的示例，演示 synchronized 的基本用法。

public class SynchronizedDemo {
   
    private int count = 0;

    public synchronized void increment() {
   
        count++;
    }

    public synchronized int getCount() {
   
        return count;
    }

    public static void main(String[] args