Java必须掌握的权限修饰符和代码块（含知识点和源码）

在Java中，权限修饰符（Access Modifiers）和代码块（Code Blocks）是两个基本但重要的概念，经常会在面试中被提及。理解这些概念对于编写安全和高效的代码至关重要。

Java权限修饰符

权限修饰符定义了Java类中成员（变量、方法）的访问权限。Java提供了四种访问级别：

1. private：该修饰符的成员只能被其所在类访问。
2. default（无修饰符）：如果不指定修饰符（即默认），成员可以被同一个包内的类访问。
3. protected：该修饰符的成员可以被同一个包内的类以及其他包中的该类的子类访问。
4. public：成员可以被任何其他类访问。

访问权限从严格到宽松依次是：private < default < protected < public。

Java代码块

Java中的代码块用于组织代码，可以提高代码的可读性和执行效率。代码块主要有以下几种类型：

1. 普通代码块：在方法或语句中使用，用于限定变量的生命周期，通常由大括号 {} 包围。
2. 静态代码块（static block）：使用 static 关键字，它在类加载时执行一次，常用于初始化静态变量。
3. 实例初始化块（instance initializer block）：在创建对象时执行，每次创建对象时都会执行，并且在构造函数之前执行。
4. 同步代码块（synchronized block）：用于多线程编程，保证该代码块内的操作对于同一时间只有一个线程可以执行。

示例

下面是一些使用权限修饰符和代码块的Java代码示例：

public class Test {

    private int privateVar = 1;
    int defaultVar = 2;
    protected int protectedVar = 3;
    public int publicVar = 4;

    // 静态代码块
    static {
        System.out.println("静态代码块执行。");
    }

    // 实例初始化块
    {
        System.out.println("实例初始化块执行。");
    }

    public Test() {
        System.out.println("构造函数执行。");
    }

    public void method() {
        // 普通代码块
        {
            int localVar = 5;
            System.out.println("普通代码块中的局部变量：" + localVar);
        }

        // 同步代码块
        synchronized (this) {
            System.out.println("同步代码块执行。");
        }
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.method();
    }
}

在准备面试时，不仅要理解每种权限修饰符和代码块的基本概念和用法，还应该能够解释它们在实际编程中的应用场景和重要性。希望这些信息能帮助你在面试中表现出色！如果你有其他问题或需要更多的帮助，请随时告诉我。为了帮助你更好地准备Java面试，我会提供三个面试常见的题目，这些题目覆盖了基础算法、设计模式及并发编程等方面，每个题目都将包含问题描述和Java源代码解决方案。

题目1：反转链表

问题描述： 实现一个函数来反转一个单链表。

解决方案：

public class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

public class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode nextTemp = curr.next;
            curr.next = prev;
            prev = curr;
            curr = nextTemp;
        }
        return prev;
    }
}

题目2：单例模式

问题描述： 实现一个线程安全的单例模式。

解决方案（双重校验锁）：

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

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

题目3：生产者-消费者问题

问题描述： 使用Java多线程编程实现生产者-消费者模式。

解决方案（使用Object的wait()和notify()方法）：

import java.util.LinkedList;
import java.util.Queue;

public class ProducerConsumerExample {
    private static final int MAX_SIZE = 10;
    private final Queue<Integer> queue = new LinkedList<>();

    public void produce() throws InterruptedException {
        int value = 0;
        while (true) {
            synchronized (this) {
                while (queue.size() == MAX_SIZE) {
                    wait();
                }
                System.out.println("Produced: " + value);
                queue.add(value++);
                notify();
                Thread.sleep(1000);
            }
        }
    }

    public void consume() throws InterruptedException {
        while (true) {
            synchronized (this) {
                while (queue.isEmpty()) {
                    wait();
                }
                int value = queue.poll();
                System.out.println("Consumed: " + value);
                notify();
                Thread.sleep(1000);
            }
        }
    }

    public static void main(String[] args) {
        ProducerConsumerExample example = new ProducerConsumerExample();
        Thread producerThread = new Thread(() -> {
            try {
                example.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                example.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

这些题目和解决方案覆盖了Java面试中的重要知识点，希望它们能帮助你在面试中展示你的编程能力和对Java核心概念的理解。练习这些题目之外，也不要忘记复习Java的基础知识，以及其他高级概念和最佳实践。祝你面试成功！如果你有任何问题或需要进一步的帮助，请随时联系我。