Java编程全攻略：李兴华的学习笔记

最新推荐文章于 2025-11-15 14:42:43 发布

原创最新推荐文章于 2025-11-15 14:42:43 发布 · 595 阅读

本内容遵循CC 4.0 BY-SA版权协议

简介：《李兴华Java笔记》是一份详尽的Java学习资源，内容从基础到高级主题，适合各类读者学习Java语言。虽然它不是为Java 8特制的，但包含了Java编程的众多关键概念，如面向对象编程、异常处理、集合框架、字符串操作、I/O流、多线程、反射与注解等，并对Java标准库及JVM有深入介绍。读者通过这份笔记，可以全面了解Java编程，并将其应用于实际项目中。
李兴华Java笔记

1. Java基础概念

Java是一门被广泛使用的编程语言，以其平台无关性和面向对象的特性深受开发者的青睐。本章将介绍Java的几个核心基础概念，为后续深入学习Java编程打下坚实的基础。

1.1 Java语言特点

Java语言以其简单、面向对象、分布式、解释执行、健壮、安全、跨平台等显著特点而闻名。Java的设计哲学是“一次编写，到处运行”，这得益于其独特的Java虚拟机（JVM）架构，使Java字节码可以在任何支持JVM的操作系统上运行。

1.2 Java程序结构

Java程序通常包含一个或多个类定义。每个类都可能包含变量、方法和嵌套类。程序的入口点是包含 main 方法的类，方法签名通常为 public static void main(String[] args) 。Java的执行过程包括源码编译成字节码，然后由JVM加载并执行。

1.3 Java开发工具

为了编写、编译和运行Java程序，通常需要一些开发工具。最常用的开发工具是Java开发工具包（JDK），它包括Java编译器（javac）、Java虚拟机（java）和其它一些用于开发Java程序的工具。此外，许多集成开发环境（IDEs）如Eclipse、IntelliJ IDEA和NetBeans，提供了更便捷的开发体验和额外的辅助功能。

通过本章的介绍，读者应该能够了解到Java作为一种编程语言的基本概念和结构，为后续章节中更高级的话题打下坚实的基础。

2. 面向对象编程技巧

2.1 类与对象的本质

2.1.1 类的定义和对象的创建

面向对象编程（OOP）是Java语言的核心特征之一。类是创建对象的模板或蓝图。在Java中，定义一个类意味着创建一个具有属性（成员变量）和行为（方法）的新类型。

public class Person {
    // 成员变量（属性）
    private String name;
    private int age;

    // 构造方法，用于创建对象时初始化属性
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法（行为）
    public void introduce() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

// 创建Person类的实例（对象）
public static void main(String[] args) {
    Person person = new Person("Alice", 30);
    person.introduce();
}

在这个例子中， Person 类定义了两个成员变量 name 和 age ，以及一个构造方法用来在创建对象时初始化这些变量。还定义了一个 introduce 方法用于打印个人介绍。

创建对象的过程是通过使用 new 关键字来完成的，这实际上是在堆内存中分配了一个新的 Person 对象，并通过构造函数对其成员变量进行了初始化。

2.1.2 类的继承与多态实现

继承是面向对象编程中一个核心概念，它允许创建一个类（子类）继承另一个类（父类）的属性和方法。多态允许子类重写父类的方法以提供特定的实现。

class Employee extends Person {
    private String employeeId;

    public Employee(String name, int age, String employeeId) {
        super(name, age); // 调用父类的构造方法
        this.employeeId = employeeId;
    }

    @Override
    public void introduce() {
        System.out.println("Hello, I'm an employee with ID: " + employeeId);
    }
}

// 使用子类创建对象
public static void main(String[] args) {
    Employee employee = new Employee("Bob", 25, "E123");
    employee.introduce();
}

在上面的例子中， Employee 类继承自 Person 类，并添加了 employeeId 属性和覆盖了 introduce 方法。创建 Employee 对象时，调用了 Person 类的构造函数（通过 super 关键字），这就是多态的一个表现。

多态允许程序在运行时确定实际调用的是哪个方法版本。这通常通过方法重写（如上面的 introduce 方法）来实现，允许子类为特定行为提供自定义实现。

2.2 封装、继承与多态的深入理解

2.2.1 封装的概念及其重要性

封装是将数据（属性）和代码（方法）绑定到一起的过程，形成一个独立的单元—类。封装可以隐藏对象的内部状态和行为细节，只暴露有限的接口供外部使用。

封装提高了代码的模块化，使数据和实现细节分离，从而减少了代码之间的耦合，并增强了安全性。

public class BankAccount {
    // 私有属性，外部无法直接访问
    private int balance;

    // 构造方法
    public BankAccount(int initialBalance) {
        this.balance = initialBalance;
    }

    // 公共方法用于存取款
    public void deposit(int amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public boolean withdraw(int amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }

    // 获取余额，但不允许外部修改
    public int getBalance() {
        return balance;
    }
}

通过封装， balance 属性被设置为私有（ private ），这防止了外部代码直接修改余额，而必须通过提供的 deposit 和 withdraw 方法来进行操作。这样就保证了数据的完整性和安全性。

2.2.2 继承的规则和设计模式

继承允许一个类继承另一个类的属性和方法，有助于代码重用和创建一个类层次结构。在Java中，类的继承通过关键字 extends 实现。

class SavingsAccount extends BankAccount {
    private double interestRate;

    public SavingsAccount(int initialBalance, double interestRate) {
        super(initialBalance); // 调用父类的构造方法
        this.interestRate = interestRate;
    }

    public void addInterest() {
        int interest = (int)(getBalance() * interestRate);
        deposit(interest);
    }
}

// 使用继承的类创建对象
public static void main(String[] args) {
    SavingsAccount savingsAccount = new SavingsAccount(1000, 0.05);
    savingsAccount.deposit(500);
    savingsAccount.addInterest();
    System.out.println("Total balance: " + savingsAccount.getBalance());
}

在该例子中， SavingsAccount 类继承自 BankAccount 类。通过继承， SavingsAccount 可以使用 BankAccount 的方法，并添加了新的行为 addInterest 来计算并添加利息。

设计模式，如工厂模式和单例模式，通常依赖于继承来实现其结构。这些模式使得代码更加灵活、可扩展，并且容易维护。

2.2.3 多态的实现机制和应用

多态是面向对象编程的另一个核心概念，它允许开发者通过父类的引用来操作子类的对象。这样，同一类型的代码可以适用于不同的对象类型。

class Vehicle {
    public void start() {
        System.out.println("Vehicle starts.");
    }
}

class Car extends Vehicle {
    @Override
    public void start() {
        System.out.println("Car engine starts.");
    }
}

class Motorcycle extends Vehicle {
    @Override
    public void start() {
        System.out.println("Motorcycle engine starts.");
    }
}

public static void main(String[] args) {
    Vehicle vehicle = new Car(); // 多态，vehicle可以引用Car对象
    vehicle.start();             // 输出 "Car engine starts."

    vehicle = new Motorcycle();  // 多态，vehicle可以引用Motorcycle对象
    vehicle.start();             // 输出 "Motorcycle engine starts."
}

在这个例子中， Car 和 Motorcycle 类都继承自 Vehicle 类，并重写了 start 方法。通过多态机制，可以在不知道具体类型的情况下调用 start 方法，运行时决定调用哪个版本。

多态的实现依赖于继承和方法重写。它在运行时确定对象的实际类型，并调用相应的方法版本，这使得程序更加灵活并易于扩展。

2.3 面向对象设计原则

2.3.1 SOLID设计原则概述

SOLID是五个面向对象设计原则的首字母缩写，旨在使软件更加可维护和可扩展。它们分别是：

单一职责原则（Single Responsibility Principle, SRP）
开闭原则（Open/Closed Principle, OCP）
里氏替换原则（Liskov Substitution Principle, LSP）
接口隔离原则（Interface Segregation Principle, ISP）
依赖倒置原则（Dependency Inversion Principle, DIP）

下面将详细解释每个原则，并展示如何在Java中应用它们。

2.3.2 设计模式在面向对象编程中的应用实例

设计模式是解决特定问题的通用解决方案，它们是根据经验总结出的最佳实践。设计模式可以帮助编写出结构良好、易于维护的代码。

下面将探讨一些设计模式在Java面向对象编程中的应用实例。

创建型模式

创建型模式关注对象的创建过程，它们有助于隐藏对象创建细节，使代码更加灵活和易管理。

单例模式（Singleton） ：确保一个类只有一个实例，并提供一个全局访问点。

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

工厂方法模式（Factory Method） ：定义一个创建对象的接口，但让子类决定实例化哪个类。

public abstract class Product {
}

public class ConcreteProduct extends Product {
}

public abstract class Creator {
    public abstract Product factoryMethod();
}

public class ConcreteCreator extends Creator {
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}

结构型模式

结构型模式关注如何组合类和对象以获得更大的结构。

适配器模式（Adapter） ：允许不兼容的接口之间能够合作。

public interface Target {
    void request();
}

public class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee specific request.");
    }
}

public class Adapter implements Target {
    private Adaptee adaptee = new Adaptee();
    public void request() {
        adaptee.specificRequest();
    }
}

装饰器模式（Decorator） ：动态地给一个对象添加一些额外的职责。

public interface Component {
    void operation();
}

public class ConcreteComponent implements Component {
    public void operation() {
        System.out.println("ConcreteComponent operation.");
    }
}

public abstract class Decorator implements Component {
    protected Component component;
    public Decorator(Component component) {
        this.component = component;
    }
    public void operation() {
        component.operation();
    }
}

public class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }
    public void addedBehavior() {
        System.out.println("ConcreteDecorator added behavior.");
    }
    public void operation() {
        super.operation();
        addedBehavior();
    }
}

行为型模式

行为型模式关注对象之间的通信。

观察者模式（Observer） ：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

import java.util.ArrayList;
import java.util.List;

public interface Observer {
    void update(String message);
}

public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String message);
}

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String message;

    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers(String message) {
        this.message = message;
        for (Observer observer : observers) {
            observer.update(message);
        }
    }

    public void someBusinessLogic() {
        // ...
        notifyObservers("Update message.");
    }
}

public class ConcreteObserver implements Observer {
    public void update(String message) {
        // Update logic.
        System.out.println("Observer: " + message);
    }
}

通过以上示例代码和对原则的解释，可以看到面向对象设计原则和设计模式如何在Java编程中实现，帮助开发者创建出灵活、可维护和易于扩展的软件系统。

SOLID原则和设计模式是面向对象设计的核心，通过理解并应用这些概念，Java程序员能够编写出更高质量的代码。在后续章节中，我们将探索其他面向对象的高级话题，例如异常处理、集合框架和JVM工作原理及性能优化。

3. 异常处理机制

3.1 异常处理基础

异常处理是Java编程中不可或缺的一部分，它允许程序以更优雅的方式处理错误，提高程序的健壮性和用户体验。

3.1.1 异常类的层次结构

Java中的异常类构成了一个层次结构，其根源来自 java.lang.Throwable 类。 Throwable 有两个直接子类： Error 和 Exception 。

Error 类用于表示严重的错误，通常是虚拟机层面的错误，如 OutOfMemoryError 或 StackOverflowError 。这类错误通常不由应用程序来处理。
Exception 类及其子类代表了可恢复的异常情况，这是开发者需要关注的。 Exception 又有两个主要的子类： RuntimeException 和非 RuntimeException 。

RuntimeException 是那些由程序逻辑错误引起的异常，例如访问空指针或数组越界，通常表示“程序员错误”，在编译时不需要特别处理。而非 RuntimeException 是必须被程序员显式处理的异常，通常这些异常会在方法签名中通过 throws 声明来表示该方法可能抛出的异常。

3.1.2 try-catch-finally的使用方法

异常处理的语法通过 try 、 catch 、 finally 和 throw 关键字实现。

try 块中包含可能会抛出异常的代码。
catch 块用于捕获 try 块中抛出的异常，并可以执行一些处理逻辑。
finally 块无论是否抛出或捕获异常，都会执行，常用于清理资源，如关闭文件流。

举个简单的例子：

try {
    int result = divide(10, 0);
} catch (ArithmeticException e) {
    // 处理除数为零的异常
    System.err.println("Division by zero not allowed.");
} finally {
    // 关闭资源，例如数据库连接或文件流
    System.out.println("Cleanup resources here...");
}

在上述代码中，如果 divide(10, 0) 方法调用抛出 ArithmeticException ，程序将跳过 try 块中剩余的代码，直接执行匹配的 catch 块中的逻辑。无论是否有异常发生， finally 块中的代码都会执行。

异常处理机制确保了程序的健壮性，允许开发者在出现错误时进行适当的错误处理和恢复，防止程序直接崩溃。

3.2 自定义异常类和异常链

3.2.1 自定义异常类的意义和方法

在一些复杂的应用场景中，标准的异常类可能无法完全满足需求。这时，我们可以创建自己的异常类，称为自定义异常。

自定义异常可以帮助我们定义更精确的错误类型，使调用者更容易理解和处理错误情况。例如，创建一个 InsufficientFundsException 来表示银行账户余额不足的特定错误。

自定义异常类通常继承自 Exception 或者其子类，并且可以添加额外的构造器和方法来提供更多的错误信息：

public class InsufficientFundsException extends Exception {
    private double amount;

    public InsufficientFundsException(double amount) {
        super("Insufficient funds to complete transaction");
        this.amount = amount;
    }

    public double getAmount() {
        return amount;
    }
}

通过提供一个包含错误信息和额外数据的自定义异常类，我们可以使错误处理更加清晰和专业。

3.2.2 异常链的构建及其用途

异常链是一种将底层异常信息传递到更高层的方法，这样高层异常就可以提供更丰富的上下文信息，同时保留底层异常的详细信息。

在Java中，可以使用 Throwable 类提供的 initCause() 方法和 getCause() 方法来构建和查询异常链。

try {
    // 可能抛出底层异常的代码
} catch (IOException e) {
    throw new Exception("Higher-level exception message", e);
}

在上面的代码片段中，我们在捕获到 IOException 时，创建了一个新的 Exception 实例，并将 IOException 作为底层原因传入。这样，高层异常保留了原始异常的信息，并通过调用 getCause() 可以查询到它。

异常链的用途在于，它允许异常被处理多次，每层可以添加新的信息，而不丢失任何异常的上下文。这种机制在复杂应用中非常有用，可以帮助开发者或最终用户更好地理解错误原因和传播途径。

3.3 异常处理的最佳实践

3.3.1 异常处理策略

处理异常的策略包括何时捕获异常以及如何记录异常。

仅在你能够处理异常的情况下捕获它。
记录异常信息时，应该包括足够的上下文信息，使得异常能够被理解和调试。
不要捕获 Throwable 类，它也包括了 Error 类， Error 类通常不应当被捕获。
使用 finally 块释放资源，或者使用try-with-resources语句自动管理资源。

最佳实践还建议避免异常的滥用，例如使用异常作为普通的返回值来控制程序流程。

3.3.2 日志记录和异常报告的最佳实践

正确地记录和报告异常可以大大简化问题的调试和定位。

使用日志框架如Log4j、SLF4J等进行日志记录，不要直接使用 System.out.println 进行异常打印。
记录异常时，应当包括异常的堆栈跟踪信息（ e.printStackTrace() 或 logger.error("Error message", e) ）。
不要记录过于冗长的堆栈信息，应该只记录对问题诊断最有用的部分。
在生产环境中，应避免记录过于详细的信息，这可能会影响性能和安全性。
在报告异常时，应当提供足够的上下文信息，让开发者能够理解发生错误时的具体情况。

异常处理的最佳实践涉及很多方面，从代码编写的那一刻起，就需要考虑异常的定义、传播和处理，以确保程序的健壮性和易于维护。

4. 集合框架详解

集合框架是Java编程语言的核心组件之一，它为组织和操作对象集合提供了丰富的数据结构和算法。随着Java版本的演进，集合框架也在不断发展和完善，为开发者提供了更多灵活性和强大的工具。在本章中，我们将深入分析Java集合框架，探讨其基本结构、使用技巧、性能考量，以及并发集合和原子操作的高级应用。

4.1 集合框架的基本结构

集合框架提供了多种接口，用于存储和操作数据集合。理解这些接口及其实现类的特性对于编写高效和可维护的代码至关重要。

4.1.1 集合框架的接口与实现

集合框架主要分为两大类：Collection和Map。Collection接口是单列集合的根接口，它有两个直接子接口：List和Set。Map接口则用于存储键值对集合。

List接口 ：代表有序集合，允许重复元素。主要实现类有ArrayList、LinkedList和Vector。ArrayList基于动态数组实现，擅长随机访问；LinkedList基于双向链表实现，擅长在列表中间进行插入和删除操作；Vector是ArrayList的同步版本，但在多线程环境下有更好的性能。
Set接口 ：代表不允许重复元素的集合。主要实现类有HashSet、LinkedHashSet和TreeSet。HashSet基于HashMap实现，不保证元素的顺序；LinkedHashSet维护了元素插入的顺序；TreeSet基于红黑树实现，可以按照自然顺序或自定义比较器排序元素。
Map接口 ：存储键值对，且键是唯一的。主要实现类有HashMap、LinkedHashMap、TreeMap、Hashtable等。HashMap不保证元素的顺序；LinkedHashMap保持了插入顺序；TreeMap按照键的自然顺序或比较器顺序进行排序；Hashtable是线程安全的，但在多线程环境下，HashMap是更佳的选择。

4.1.2 List, Set, Map的主要实现类和特性

不同实现类有其特定的使用场景和性能特点，以下是一些关键点：

ArrayList ：在大多数情况下是List的最佳选择，特别是当你需要随机访问元素时。它在插入和删除元素时，特别是在列表的中间位置时，性能较差。
LinkedList ：当你需要在列表中频繁插入和删除元素时，特别是靠近列表两端的位置，应选择LinkedList。
HashSet ：当你需要快速访问元素，并且元素无需排序时，HashSet是最合适的选择。
LinkedHashSet ：当你需要维护插入顺序时，应该使用LinkedHashSet。
HashMap ：在不需要元素排序的情况下，HashMap提供了最快的键值对映射，特别是在需要高效查找时。
LinkedHashMap ：当你需要维护插入顺序或最近最少使用（LRU）缓存时，LinkedHashMap是个不错的选择。
TreeMap ：当你需要对键进行自然排序或自定义排序时，应选择TreeMap。

通过理解每个集合类的特性，你可以根据具体需求选择最合适的实现。

4.2 集合的使用技巧与性能考量

在使用集合时，需要掌握一些高级技巧来提高性能，同时也要进行性能分析和优化，以满足程序的需求。

4.2.1 集合操作的高级技巧

集合的高级技巧包括但不限于：

使用iterator()进行迭代 ：这是遍历集合的首选方式，因为它在迭代时支持集合的修改操作，而不会抛出ConcurrentModificationException异常。
使用增强for循环 ：这种方式代码更简洁，适用于不需要删除元素的情况。
使用ListIterator进行双向遍历 ：如果需要反向遍历列表或在遍历过程中修改列表，ListIterator是更好的选择。
使用Collections工具类 ：提供了多种集合操作的静态方法，如排序sort()、查找binarySearch()和同步synchronizedList()等。

4.2.2 集合性能分析和优化方法

性能分析和优化可以通过以下方法进行：

选择合适的数据结构 ：基于集合的使用场景和性能特点，选择最合适的数据结构。例如，对于需要快速查找的场景，使用HashMap而不是HashSet。
使用最佳的集合实现 ：根据集合的使用方式，选择性能最优的实现。例如，如果不需要列表的中间插入，应该优先考虑ArrayList而不是LinkedList。
减少不必要的自动装箱 ：自动装箱和拆箱在集合操作中会带来额外的性能开销。应该尽量使用基本类型或包装类，并利用Java的原始类型集合，如ArrayList 而不是List 。
使用并发集合 ：对于多线程环境中的集合操作，使用并发集合如ConcurrentHashMap可以提高性能。

4.3 并发集合与原子操作

并发集合和原子操作是Java集合框架在Java 5及以后版本中引入的新特性，它们为多线程编程提供了更好的工具。

4.3.1 并发集合的种类与特性

Java提供的并发集合主要包含以下几类：

ConcurrentHashMap ：提供了线程安全的HashMap实现，通过分段锁技术提供了高效的并发访问。
CopyOnWriteArrayList ：一种线程安全的ArrayList变体，通过复制底层数组来实现修改操作，适合读多写少的场景。
BlockingQueue ：提供了线程安全的队列实现，常用于生产者-消费者模式。主要有ArrayBlockingQueue、LinkedBlockingQueue和PriorityBlockingQueue等。
ConcurrentLinkedQueue ：基于链接节点实现的线程安全的队列，适用于高并发环境。

4.3.2 使用原子变量进行无锁编程

原子变量是Java并发包中的另一个重要概念。这些类位于java.util.concurrent.atomic包中，如AtomicInteger、AtomicLong和AtomicReference等。它们利用了现代处理器提供的原子操作指令，保证了操作的原子性。

原子变量的主要优点是它们可以实现无锁编程，即在多线程环境下，无需使用同步机制即可保持数据的一致性。这为性能提升带来了巨大潜力，尤其是在竞争激烈的高并发环境中。

要有效利用原子变量，需要对其API和背后的原子操作指令有深入理解。例如，使用compareAndSet()方法可以实现基于比较和交换的原子操作，这是无锁编程的核心。

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(0);
        // 假设这里启动了多个线程，对atomicInteger进行操作
        // 增加原子变量的值，如果当前值是预期值则增加
        int initialValue = atomicInteger.get();
        while (!atomicInteger.compareAndSet(initialValue, initialValue + 1)) {
            initialValue = atomicInteger.get();
        }
        // 最终atomicInteger的值为每个线程操作之和
        System.out.println("The final value is " + atomicInteger.get());
    }
}

这段代码展示了如何使用AtomicInteger的compareAndSet()方法来实现线程安全的计数器。

在本节中，我们深入了解了Java集合框架的各个组件，学习了如何选择和使用合适的集合类，并探索了并发集合和原子操作的强大功能。掌握这些知识可以帮助开发者编写出既高效又可靠的Java应用程序。

在下一节中，我们将探索Java虚拟机（JVM）的工作原理，学习性能优化的策略，并分析一些实际案例。