1. Java面向对象编程基础类与对象的核心概念在Java编程语言中类和对象是面向对象编程(OOP)的基石。对于初学者来说理解这两个概念是掌握Java的关键第一步。类可以看作是一个蓝图或模板它定义了对象的属性和行为而对象则是根据这个蓝图创建的具体实例。1.1 类的定义与组成一个标准的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, Im name , age years old.); } // Getter和Setter方法 public String getName() { return name; } public void setName(String name) { this.name name; } }提示初学者常犯的错误是混淆类与对象的概念。记住类是定义对象是根据这个定义创建的具体实例。1.2 对象的创建与使用创建对象是使用类的过程也称为实例化。在Java中我们使用new关键字来创建对象public class Main { public static void main(String[] args) { // 创建Person类的对象 Person person1 new Person(Alice, 25); Person person2 new Person(Bob, 30); // 调用对象的方法 person1.introduce(); // 输出: Hello, Im Alice, 25 years old. person2.introduce(); // 输出: Hello, Im Bob, 30 years old. } }每个对象都有自己独立的内存空间修改一个对象的属性不会影响其他对象person1.setName(Alice Smith); System.out.println(person1.getName()); // 输出: Alice Smith System.out.println(person2.getName()); // 输出: Bob (保持不变)2. Java类的深入解析2.1 构造方法详解构造方法是一种特殊的方法用于在创建对象时初始化对象。它具有以下特点方法名与类名完全相同没有返回类型连void都没有可以有多个重载版本public class Book { private String title; private String author; private double price; // 无参构造方法 public Book() { this.title Unknown; this.author Unknown; this.price 0.0; } // 带参数的构造方法 public Book(String title, String author, double price) { this.title title; this.author author; this.price price; } // 另一个重载版本 public Book(String title) { this(title, Unknown, 0.0); // 调用其他构造方法 } }注意如果没有显式定义任何构造方法Java会提供一个默认的无参构造方法。但一旦定义了任何构造方法默认的无参构造方法就不再自动提供。2.2 访问修饰符与封装Java提供了四种访问修饰符来控制类成员的可见性修饰符类内同包子类其他包public✓✓✓✓protected✓✓✓×默认(无修饰符)✓✓××private✓×××良好的封装实践建议将字段声明为private提供public的getter和setter方法来访问和修改字段在setter方法中可以添加验证逻辑public class Student { private String name; private int age; public void setAge(int age) { if(age 0 age 120) { // 添加验证逻辑 this.age age; } else { System.out.println(Invalid age!); } } public int getAge() { return age; } }3. 面向对象三大特性在Java中的实现3.1 封装(Encapsulation)封装是指将数据和对数据的操作捆绑在一起并隐藏内部实现细节。Java通过类和访问修饰符实现封装public class BankAccount { private String accountNumber; private double balance; public BankAccount(String accountNumber) { this.accountNumber accountNumber; this.balance 0.0; } public void deposit(double amount) { if(amount 0) { balance amount; } } public void withdraw(double amount) { if(amount 0 amount balance) { balance - amount; } } public double getBalance() { return balance; } }3.2 继承(Inheritance)继承允许我们基于现有类创建新类新类会继承父类的属性和方法// 父类 public class Animal { private String name; public Animal(String name) { this.name name; } public void eat() { System.out.println(name is eating.); } } // 子类 public class Dog extends Animal { public Dog(String name) { super(name); // 调用父类构造方法 } public void bark() { System.out.println(Woof! Woof!); } } // 使用示例 Dog myDog new Dog(Buddy); myDog.eat(); // 继承自Animal类的方法 myDog.bark(); // Dog类特有的方法提示Java只支持单继承一个类只能直接继承一个父类但可以实现多个接口。3.3 多态(Polymorphism)多态允许我们使用父类引用指向子类对象并在运行时确定实际调用的方法public class TestPolymorphism { public static void main(String[] args) { Animal myAnimal new Dog(Rex); // 父类引用指向子类对象 myAnimal.eat(); // 调用的是Animal类中定义的方法 // 编译时检查myAnimal的类型是Animal所以不能直接调用bark() // myAnimal.bark(); // 这行会报错 if(myAnimal instanceof Dog) { Dog myDog (Dog) myAnimal; // 向下转型 myDog.bark(); } } }4. 类与对象的高级特性4.1 static关键字static修饰的成员属于类本身而不是类的实例public class Counter { private static int count 0; // 静态变量 public Counter() { count; } public static int getCount() { // 静态方法 return count; } } // 使用示例 System.out.println(Counter.getCount()); // 0 new Counter(); new Counter(); System.out.println(Counter.getCount()); // 2静态方法只能直接访问静态成员不能直接访问实例成员。4.2 final关键字final可以修饰类、方法和变量final类不能被继承final方法不能被子类重写final变量只能赋值一次public final class Constants { // final类 public static final double PI 3.14159; // final变量 public final void showInfo() { // final方法 System.out.println(This is a constant class.); } }4.3 内部类Java允许在一个类中定义另一个类称为内部类public class Outer { private int outerField 10; // 成员内部类 public class Inner { public void display() { System.out.println(Outer field value: outerField); } } // 静态内部类 public static class StaticInner { public void show() { System.out.println(This is a static inner class.); } } // 方法内部类 public void methodWithLocalClass() { class LocalClass { public void print() { System.out.println(Local class inside method.); } } LocalClass lc new LocalClass(); lc.print(); } // 匿名内部类 public void anonymousClassExample() { Runnable r new Runnable() { Override public void run() { System.out.println(Anonymous class implementation.); } }; r.run(); } }5. 常见问题与解决方案5.1 对象比较问题初学者常犯的错误是使用比较对象内容String s1 new String(hello); String s2 new String(hello); System.out.println(s1 s2); // false比较的是引用 System.out.println(s1.equals(s2)); // true比较的是内容对于自定义类需要重写equals()方法public class Student { private String id; private String name; Override public boolean equals(Object obj) { if(this obj) return true; if(obj null || getClass() ! obj.getClass()) return false; Student student (Student) obj; return id.equals(student.id); } Override public int hashCode() { return id.hashCode(); } }5.2 NullPointerException这是Java中最常见的运行时异常之一发生在尝试访问null对象的成员时String str null; System.out.println(str.length()); // 抛出NullPointerException防御性编程建议在调用方法前检查对象是否为null使用Optional类(Java 8)合理设计方法避免返回null5.3 内存泄漏问题虽然Java有垃圾回收机制但不当的对象引用仍可能导致内存泄漏public class Stack { private Object[] elements; private int size 0; public Stack(int capacity) { elements new Object[capacity]; } public void push(Object e) { elements[size] e; } public Object pop() { if(size 0) throw new EmptyStackException(); Object result elements[--size]; elements[size] null; // 消除过期引用 return result; } }5.4 对象创建的最佳实践考虑使用静态工厂方法替代构造方法public class Complex { private final double real; private final double imaginary; private Complex(double real, double imaginary) { this.real real; this.imaginary imaginary; } public static Complex fromCartesian(double real, double imaginary) { return new Complex(real, imaginary); } public static Complex fromPolar(double modulus, double angle) { return new Complex(modulus * Math.cos(angle), modulus * Math.sin(angle)); } }考虑使用Builder模式创建复杂对象public class Computer { private final String cpu; private final String ram; private final String storage; private Computer(Builder builder) { this.cpu builder.cpu; this.ram builder.ram; this.storage builder.storage; } public static class Builder { private String cpu; private String ram; private String storage; public Builder cpu(String cpu) { this.cpu cpu; return this; } public Builder ram(String ram) { this.ram ram; return this; } public Builder storage(String storage) { this.storage storage; return this; } public Computer build() { return new Computer(this); } } } // 使用示例 Computer myPC new Computer.Builder() .cpu(Intel i7) .ram(16GB) .storage(512GB SSD) .build();6. Java常用类库中的类与对象6.1 String类String是Java中最常用的类之一具有以下特点不可变性(Immutable)字符串常量池优化丰富的操作方法String s1 hello; // 使用字符串常量池 String s2 new String(hello); // 创建新对象 // 常用方法 String str Hello, World!; System.out.println(str.length()); // 13 System.out.println(str.substring(7)); // World! System.out.println(str.toUpperCase()); // HELLO, WORLD! System.out.println(str.replace(World, Java)); // Hello, Java!6.2 集合框架中的类Java集合框架提供了多种数据结构的实现// List接口 ListString arrayList new ArrayList(); arrayList.add(Apple); arrayList.add(Banana); // Set接口 SetInteger hashSet new HashSet(); hashSet.add(1); hashSet.add(2); // Map接口 MapString, Integer hashMap new HashMap(); hashMap.put(John, 25); hashMap.put(Alice, 30);6.3 日期时间API(Java 8)Java 8引入了新的日期时间API解决了旧API的诸多问题// 当前日期 LocalDate today LocalDate.now(); // 特定日期 LocalDate birthday LocalDate.of(1990, Month.JANUARY, 1); // 日期运算 LocalDate nextWeek today.plusWeeks(1); // 日期比较 boolean isAfter today.isAfter(birthday); // 格式化 DateTimeFormatter formatter DateTimeFormatter.ofPattern(yyyy-MM-dd); String formattedDate today.format(formatter);7. 面向对象设计原则7.1 SOLID原则单一职责原则(SRP)一个类应该只有一个引起变化的原因每个类只负责一项职责开闭原则(OCP)软件实体应该对扩展开放对修改关闭通过抽象和继承实现里氏替换原则(LSP)子类必须能够替换它们的基类子类不应该破坏父类的行为接口隔离原则(ISP)客户端不应该被迫依赖它们不使用的接口将大接口拆分为更小、更具体的接口依赖倒置原则(DIP)高层模块不应该依赖低层模块两者都应该依赖抽象抽象不应该依赖细节细节应该依赖抽象7.2 组合优于继承继承虽然强大但过度使用会导致代码脆弱。组合提供了更灵活的替代方案// 使用继承 class Engine { void start() { /* ... */ } } class Car extends Engine { // 不好汽车是一个引擎 // ... } // 使用组合 class Car { private Engine engine; // 汽车有一个引擎 public Car(Engine engine) { this.engine engine; } void start() { engine.start(); } }8. Java类与对象的最佳实践8.1 不可变对象设计不可变对象具有线程安全、易于理解等优点public final class ImmutablePoint { private final int x; private final int y; public ImmutablePoint(int x, int y) { this.x x; this.y y; } public int getX() { return x; } public int getY() { return y; } public ImmutablePoint withX(int newX) { return new ImmutablePoint(newX, this.y); } public ImmutablePoint withY(int newY) { return new ImmutablePoint(this.x, newY); } }8.2 正确重写equals和hashCode当重写equals()方法时必须同时重写hashCode()方法public class Employee { private int id; private String name; Override public boolean equals(Object o) { if(this o) return true; if(o null || getClass() ! o.getClass()) return false; Employee employee (Employee) o; return id employee.id Objects.equals(name, employee.name); } Override public int hashCode() { return Objects.hash(id, name); } }8.3 有效使用toString方法良好的toString()实现可以大大简化调试public class Product { private String id; private String name; private double price; Override public String toString() { return Product{ id id \ , name name \ , price price }; } }8.4 使用枚举替代常量枚举类型比传统的常量更安全、更强大public enum Day { MONDAY(星期一), TUESDAY(星期二), // ... SUNDAY(星期日); private String chineseName; private Day(String chineseName) { this.chineseName chineseName; } public String getChineseName() { return chineseName; } }9. Java类加载与对象生命周期9.1 类的加载过程Java类加载分为以下几个阶段加载查找并加载类的二进制数据验证确保被加载的类的正确性准备为类的静态变量分配内存并设置默认初始值解析将符号引用转换为直接引用初始化执行类构造器 ()方法9.2 对象的生命周期创建阶段分配内存初始化实例变量执行构造方法使用阶段对象被引用方法被调用状态被修改不可达阶段不再被任何引用指向等待垃圾回收回收阶段被垃圾收集器回收内存被释放9.3 垃圾回收机制Java的垃圾回收器会自动管理内存主要关注以下几种引用类型强引用普通对象引用不会被回收软引用内存不足时可能被回收弱引用垃圾回收时会被回收虚引用用于跟踪对象被回收的状态// 弱引用示例 WeakReferenceObject weakRef new WeakReference(new Object()); Object obj weakRef.get(); // 可能返回null System.gc(); // 建议JVM进行垃圾回收 obj weakRef.get(); // 很可能返回null10. Java新版本中的类与对象特性10.1 Java 14的Record类Record是一种新的类声明方式用于简化不可变数据类的定义public record Point(int x, int y) { // 编译器自动生成 // - 私有final字段x和y // - 公共构造方法 // - 访问器方法x()和y() // - equals(), hashCode(), toString() } // 使用示例 Point p new Point(10, 20); System.out.println(p.x()); // 10 System.out.println(p); // Point[x10, y20]10.2 Java 16的Pattern Matching for instanceof简化了instanceof检查和类型转换Object obj hello; // 旧方式 if(obj instanceof String) { String s (String) obj; System.out.println(s.length()); } // 新方式 if(obj instanceof String s) { System.out.println(s.length()); }10.3 Java 17的密封类(Sealed Classes)密封类限制哪些其他类或接口可以继承或实现它们public sealed class Shape permits Circle, Rectangle, Triangle { // 父类定义 } public final class Circle extends Shape { private double radius; // 实现细节 } public final class Rectangle extends Shape { private double width, height; // 实现细节 } public final class Triangle extends Shape { private double base, height; // 实现细节 }在实际编码中我发现初学者最容易混淆类与对象的概念。一个简单的记忆方法是类就像饼干的模具而对象就是用这个模具压出来的饼干。每个饼干都是独立的但它们都有相同的形状和特征。理解这一点后面向对象编程的其他概念就会变得容易很多。 Java面向对象编程：类与对象核心概念详解
1. Java面向对象编程基础类与对象的核心概念在Java编程语言中类和对象是面向对象编程(OOP)的基石。对于初学者来说理解这两个概念是掌握Java的关键第一步。类可以看作是一个蓝图或模板它定义了对象的属性和行为而对象则是根据这个蓝图创建的具体实例。1.1 类的定义与组成一个标准的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, Im name , age years old.); } // Getter和Setter方法 public String getName() { return name; } public void setName(String name) { this.name name; } }提示初学者常犯的错误是混淆类与对象的概念。记住类是定义对象是根据这个定义创建的具体实例。1.2 对象的创建与使用创建对象是使用类的过程也称为实例化。在Java中我们使用new关键字来创建对象public class Main { public static void main(String[] args) { // 创建Person类的对象 Person person1 new Person(Alice, 25); Person person2 new Person(Bob, 30); // 调用对象的方法 person1.introduce(); // 输出: Hello, Im Alice, 25 years old. person2.introduce(); // 输出: Hello, Im Bob, 30 years old. } }每个对象都有自己独立的内存空间修改一个对象的属性不会影响其他对象person1.setName(Alice Smith); System.out.println(person1.getName()); // 输出: Alice Smith System.out.println(person2.getName()); // 输出: Bob (保持不变)2. Java类的深入解析2.1 构造方法详解构造方法是一种特殊的方法用于在创建对象时初始化对象。它具有以下特点方法名与类名完全相同没有返回类型连void都没有可以有多个重载版本public class Book { private String title; private String author; private double price; // 无参构造方法 public Book() { this.title Unknown; this.author Unknown; this.price 0.0; } // 带参数的构造方法 public Book(String title, String author, double price) { this.title title; this.author author; this.price price; } // 另一个重载版本 public Book(String title) { this(title, Unknown, 0.0); // 调用其他构造方法 } }注意如果没有显式定义任何构造方法Java会提供一个默认的无参构造方法。但一旦定义了任何构造方法默认的无参构造方法就不再自动提供。2.2 访问修饰符与封装Java提供了四种访问修饰符来控制类成员的可见性修饰符类内同包子类其他包public✓✓✓✓protected✓✓✓×默认(无修饰符)✓✓××private✓×××良好的封装实践建议将字段声明为private提供public的getter和setter方法来访问和修改字段在setter方法中可以添加验证逻辑public class Student { private String name; private int age; public void setAge(int age) { if(age 0 age 120) { // 添加验证逻辑 this.age age; } else { System.out.println(Invalid age!); } } public int getAge() { return age; } }3. 面向对象三大特性在Java中的实现3.1 封装(Encapsulation)封装是指将数据和对数据的操作捆绑在一起并隐藏内部实现细节。Java通过类和访问修饰符实现封装public class BankAccount { private String accountNumber; private double balance; public BankAccount(String accountNumber) { this.accountNumber accountNumber; this.balance 0.0; } public void deposit(double amount) { if(amount 0) { balance amount; } } public void withdraw(double amount) { if(amount 0 amount balance) { balance - amount; } } public double getBalance() { return balance; } }3.2 继承(Inheritance)继承允许我们基于现有类创建新类新类会继承父类的属性和方法// 父类 public class Animal { private String name; public Animal(String name) { this.name name; } public void eat() { System.out.println(name is eating.); } } // 子类 public class Dog extends Animal { public Dog(String name) { super(name); // 调用父类构造方法 } public void bark() { System.out.println(Woof! Woof!); } } // 使用示例 Dog myDog new Dog(Buddy); myDog.eat(); // 继承自Animal类的方法 myDog.bark(); // Dog类特有的方法提示Java只支持单继承一个类只能直接继承一个父类但可以实现多个接口。3.3 多态(Polymorphism)多态允许我们使用父类引用指向子类对象并在运行时确定实际调用的方法public class TestPolymorphism { public static void main(String[] args) { Animal myAnimal new Dog(Rex); // 父类引用指向子类对象 myAnimal.eat(); // 调用的是Animal类中定义的方法 // 编译时检查myAnimal的类型是Animal所以不能直接调用bark() // myAnimal.bark(); // 这行会报错 if(myAnimal instanceof Dog) { Dog myDog (Dog) myAnimal; // 向下转型 myDog.bark(); } } }4. 类与对象的高级特性4.1 static关键字static修饰的成员属于类本身而不是类的实例public class Counter { private static int count 0; // 静态变量 public Counter() { count; } public static int getCount() { // 静态方法 return count; } } // 使用示例 System.out.println(Counter.getCount()); // 0 new Counter(); new Counter(); System.out.println(Counter.getCount()); // 2静态方法只能直接访问静态成员不能直接访问实例成员。4.2 final关键字final可以修饰类、方法和变量final类不能被继承final方法不能被子类重写final变量只能赋值一次public final class Constants { // final类 public static final double PI 3.14159; // final变量 public final void showInfo() { // final方法 System.out.println(This is a constant class.); } }4.3 内部类Java允许在一个类中定义另一个类称为内部类public class Outer { private int outerField 10; // 成员内部类 public class Inner { public void display() { System.out.println(Outer field value: outerField); } } // 静态内部类 public static class StaticInner { public void show() { System.out.println(This is a static inner class.); } } // 方法内部类 public void methodWithLocalClass() { class LocalClass { public void print() { System.out.println(Local class inside method.); } } LocalClass lc new LocalClass(); lc.print(); } // 匿名内部类 public void anonymousClassExample() { Runnable r new Runnable() { Override public void run() { System.out.println(Anonymous class implementation.); } }; r.run(); } }5. 常见问题与解决方案5.1 对象比较问题初学者常犯的错误是使用比较对象内容String s1 new String(hello); String s2 new String(hello); System.out.println(s1 s2); // false比较的是引用 System.out.println(s1.equals(s2)); // true比较的是内容对于自定义类需要重写equals()方法public class Student { private String id; private String name; Override public boolean equals(Object obj) { if(this obj) return true; if(obj null || getClass() ! obj.getClass()) return false; Student student (Student) obj; return id.equals(student.id); } Override public int hashCode() { return id.hashCode(); } }5.2 NullPointerException这是Java中最常见的运行时异常之一发生在尝试访问null对象的成员时String str null; System.out.println(str.length()); // 抛出NullPointerException防御性编程建议在调用方法前检查对象是否为null使用Optional类(Java 8)合理设计方法避免返回null5.3 内存泄漏问题虽然Java有垃圾回收机制但不当的对象引用仍可能导致内存泄漏public class Stack { private Object[] elements; private int size 0; public Stack(int capacity) { elements new Object[capacity]; } public void push(Object e) { elements[size] e; } public Object pop() { if(size 0) throw new EmptyStackException(); Object result elements[--size]; elements[size] null; // 消除过期引用 return result; } }5.4 对象创建的最佳实践考虑使用静态工厂方法替代构造方法public class Complex { private final double real; private final double imaginary; private Complex(double real, double imaginary) { this.real real; this.imaginary imaginary; } public static Complex fromCartesian(double real, double imaginary) { return new Complex(real, imaginary); } public static Complex fromPolar(double modulus, double angle) { return new Complex(modulus * Math.cos(angle), modulus * Math.sin(angle)); } }考虑使用Builder模式创建复杂对象public class Computer { private final String cpu; private final String ram; private final String storage; private Computer(Builder builder) { this.cpu builder.cpu; this.ram builder.ram; this.storage builder.storage; } public static class Builder { private String cpu; private String ram; private String storage; public Builder cpu(String cpu) { this.cpu cpu; return this; } public Builder ram(String ram) { this.ram ram; return this; } public Builder storage(String storage) { this.storage storage; return this; } public Computer build() { return new Computer(this); } } } // 使用示例 Computer myPC new Computer.Builder() .cpu(Intel i7) .ram(16GB) .storage(512GB SSD) .build();6. Java常用类库中的类与对象6.1 String类String是Java中最常用的类之一具有以下特点不可变性(Immutable)字符串常量池优化丰富的操作方法String s1 hello; // 使用字符串常量池 String s2 new String(hello); // 创建新对象 // 常用方法 String str Hello, World!; System.out.println(str.length()); // 13 System.out.println(str.substring(7)); // World! System.out.println(str.toUpperCase()); // HELLO, WORLD! System.out.println(str.replace(World, Java)); // Hello, Java!6.2 集合框架中的类Java集合框架提供了多种数据结构的实现// List接口 ListString arrayList new ArrayList(); arrayList.add(Apple); arrayList.add(Banana); // Set接口 SetInteger hashSet new HashSet(); hashSet.add(1); hashSet.add(2); // Map接口 MapString, Integer hashMap new HashMap(); hashMap.put(John, 25); hashMap.put(Alice, 30);6.3 日期时间API(Java 8)Java 8引入了新的日期时间API解决了旧API的诸多问题// 当前日期 LocalDate today LocalDate.now(); // 特定日期 LocalDate birthday LocalDate.of(1990, Month.JANUARY, 1); // 日期运算 LocalDate nextWeek today.plusWeeks(1); // 日期比较 boolean isAfter today.isAfter(birthday); // 格式化 DateTimeFormatter formatter DateTimeFormatter.ofPattern(yyyy-MM-dd); String formattedDate today.format(formatter);7. 面向对象设计原则7.1 SOLID原则单一职责原则(SRP)一个类应该只有一个引起变化的原因每个类只负责一项职责开闭原则(OCP)软件实体应该对扩展开放对修改关闭通过抽象和继承实现里氏替换原则(LSP)子类必须能够替换它们的基类子类不应该破坏父类的行为接口隔离原则(ISP)客户端不应该被迫依赖它们不使用的接口将大接口拆分为更小、更具体的接口依赖倒置原则(DIP)高层模块不应该依赖低层模块两者都应该依赖抽象抽象不应该依赖细节细节应该依赖抽象7.2 组合优于继承继承虽然强大但过度使用会导致代码脆弱。组合提供了更灵活的替代方案// 使用继承 class Engine { void start() { /* ... */ } } class Car extends Engine { // 不好汽车是一个引擎 // ... } // 使用组合 class Car { private Engine engine; // 汽车有一个引擎 public Car(Engine engine) { this.engine engine; } void start() { engine.start(); } }8. Java类与对象的最佳实践8.1 不可变对象设计不可变对象具有线程安全、易于理解等优点public final class ImmutablePoint { private final int x; private final int y; public ImmutablePoint(int x, int y) { this.x x; this.y y; } public int getX() { return x; } public int getY() { return y; } public ImmutablePoint withX(int newX) { return new ImmutablePoint(newX, this.y); } public ImmutablePoint withY(int newY) { return new ImmutablePoint(this.x, newY); } }8.2 正确重写equals和hashCode当重写equals()方法时必须同时重写hashCode()方法public class Employee { private int id; private String name; Override public boolean equals(Object o) { if(this o) return true; if(o null || getClass() ! o.getClass()) return false; Employee employee (Employee) o; return id employee.id Objects.equals(name, employee.name); } Override public int hashCode() { return Objects.hash(id, name); } }8.3 有效使用toString方法良好的toString()实现可以大大简化调试public class Product { private String id; private String name; private double price; Override public String toString() { return Product{ id id \ , name name \ , price price }; } }8.4 使用枚举替代常量枚举类型比传统的常量更安全、更强大public enum Day { MONDAY(星期一), TUESDAY(星期二), // ... SUNDAY(星期日); private String chineseName; private Day(String chineseName) { this.chineseName chineseName; } public String getChineseName() { return chineseName; } }9. Java类加载与对象生命周期9.1 类的加载过程Java类加载分为以下几个阶段加载查找并加载类的二进制数据验证确保被加载的类的正确性准备为类的静态变量分配内存并设置默认初始值解析将符号引用转换为直接引用初始化执行类构造器 ()方法9.2 对象的生命周期创建阶段分配内存初始化实例变量执行构造方法使用阶段对象被引用方法被调用状态被修改不可达阶段不再被任何引用指向等待垃圾回收回收阶段被垃圾收集器回收内存被释放9.3 垃圾回收机制Java的垃圾回收器会自动管理内存主要关注以下几种引用类型强引用普通对象引用不会被回收软引用内存不足时可能被回收弱引用垃圾回收时会被回收虚引用用于跟踪对象被回收的状态// 弱引用示例 WeakReferenceObject weakRef new WeakReference(new Object()); Object obj weakRef.get(); // 可能返回null System.gc(); // 建议JVM进行垃圾回收 obj weakRef.get(); // 很可能返回null10. Java新版本中的类与对象特性10.1 Java 14的Record类Record是一种新的类声明方式用于简化不可变数据类的定义public record Point(int x, int y) { // 编译器自动生成 // - 私有final字段x和y // - 公共构造方法 // - 访问器方法x()和y() // - equals(), hashCode(), toString() } // 使用示例 Point p new Point(10, 20); System.out.println(p.x()); // 10 System.out.println(p); // Point[x10, y20]10.2 Java 16的Pattern Matching for instanceof简化了instanceof检查和类型转换Object obj hello; // 旧方式 if(obj instanceof String) { String s (String) obj; System.out.println(s.length()); } // 新方式 if(obj instanceof String s) { System.out.println(s.length()); }10.3 Java 17的密封类(Sealed Classes)密封类限制哪些其他类或接口可以继承或实现它们public sealed class Shape permits Circle, Rectangle, Triangle { // 父类定义 } public final class Circle extends Shape { private double radius; // 实现细节 } public final class Rectangle extends Shape { private double width, height; // 实现细节 } public final class Triangle extends Shape { private double base, height; // 实现细节 }在实际编码中我发现初学者最容易混淆类与对象的概念。一个简单的记忆方法是类就像饼干的模具而对象就是用这个模具压出来的饼干。每个饼干都是独立的但它们都有相同的形状和特征。理解这一点后面向对象编程的其他概念就会变得容易很多。