Java 面向对象编程 (OOP)：之对象-优快云博客

本文链接：https://blog.youkuaiyun.com/nmsoftklb/article/details/145647574

一、对象的定义 (Object Definition)

在 Java 中，对象是类的具体实例。如果将类比作蓝图或模板，那么对象就是根据这个蓝图创建出来的实体。每个对象都拥有：

状态 (State):
- 对象的状态由其属性 (Attributes) 或字段 (Fields) 的值决定。
- 这些属性是类中定义的成员变量。
- 每个对象都有自己独立的属性值，这些值存储在对象的内存空间中。
行为 (Behavior):
- 对象的行为由其方法 (Methods) 定义。
- 方法是类中定义的函数，用于操作对象的状态或执行与对象相关的操作。
- 方法可以访问和修改对象的属性。
标识 (Identity):
- 每个对象都有一个唯一的标识，用于区分不同的对象。
- 在 Java 中，对象的标识通常由其内存地址决定（开发者通常不需要直接操作内存地址）。
- 可以使用 == 运算符比较两个对象的引用是否指向同一个对象（即标识是否相同）。

二、对象的创建 (Object Creation)

在 Java 中，使用 new 关键字和类的构造方法来创建对象。

new 关键字：
- new 关键字在堆内存中为对象分配空间。
- new 关键字会调用类的构造方法来初始化对象。
构造方法 (Constructor)：
- 构造方法是类中一种特殊的方法，用于创建和初始化对象。
- 构造方法与类同名，没有返回类型（甚至没有 void）。
- 构造方法可以有参数，也可以没有参数（无参构造方法）。
- 如果一个类没有显式定义构造方法，Java 编译器会自动提供一个默认的无参构造方法。
- 如果一个类显式定义了构造方法（无论是否有参），Java 编译器不会再提供默认的无参构造方法。
创建对象的步骤：
1. 分配内存： new 关键字在堆内存中为对象分配空间。
2. 初始化成员变量： 对象的成员变量会被初始化为默认值（例如，int 类型为 0，boolean 类型为 false，引用类型为 null）。
3. 调用构造方法： 调用类的构造方法，执行构造方法中的代码，进一步初始化对象（例如，为成员变量赋初始值）。
4. 返回对象引用： new 表达式返回新创建对象的引用（内存地址）。

代码示例：

// 定义一个 Person 类
class Person {
    String name;
    int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class ObjectCreationExample {
    public static void main(String[] args) {
        // 创建 Person 对象
        Person person1 = new Person("Alice", 30); // 使用 new 关键字和构造方法

        // person1 是一个引用变量，它存储了新创建的 Person 对象的内存地址
        System.out.println(person1.name); // 输出 "Alice"
        System.out.println(person1.age);  // 输出 "30"
    }
}

三、对象的使用 (Object Usage)

创建对象后，可以通过对象的引用来访问对象的属性和调用对象的方法。

访问属性：
- 使用点号 (.) 运算符访问对象的属性（如果属性是 public 的，或者在同一个包内且属性是 protected 或默认访问权限，或者在子类中且属性是 protected 的，或者有 getter 方法）。
- 通常，会将属性声明为 private，并通过 getter 和 setter 方法提供对属性的受控访问（封装）。
调用方法：
- 使用点号 (.) 运算符调用对象的方法。
- 方法的调用会执行方法体中的代码，可能会修改对象的状态或返回一个值。
对象作为参数：
- 对象可以作为参数传递给方法。
- 在 Java 中，对象是通过引用传递的。这意味着，在方法内部修改对象的属性，会影响到方法外部的对象。
对象作为返回值：
- 方法可以返回一个对象。
对象数组：

可以创建对象数组, 存储和管理一组相关的对象。

代码示例

//接上一个代码示例
   public class ObjectUsageExample {
    public static void main(String[] args) {
        Person person1 = new Person("Alice", 30);

        // 访问属性 (假设 name 和 age 是 public 的，或者有 getter 方法)
        System.out.println(person1.name);
        System.out.println(person1.age);

        // 调用方法
        person1.eat("pizza"); // 假设 Person 类有 eat() 方法

        // 对象作为参数
        printPersonInfo(person1);

        // 对象作为返回值
        Person person2 = createPerson("Bob", 25);
        
          //对象数组
         Person[] people = new Person[2];
         people[0] = person1;
         people[1] = person2;
    }

    // 对象作为参数
    public static void printPersonInfo(Person person) {
        System.out.println("Name: " + person.name + ", Age: " + person.age);
    }

    // 对象作为返回值
    public static Person createPerson(String name, int age) {
        return new Person(name, age);
    }
}

四、对象的生命周期 (Object Lifecycle)

对象的生命周期包括以下几个阶段：

创建 (Creation): 使用 new 关键字和构造方法创建对象。
使用 (Use): 通过对象的引用访问对象的属性和调用对象的方法。
不可达 (Unreachable): 当没有任何引用变量指向对象时，对象变为不可达。
垃圾回收 (Garbage Collection): Java 虚拟机 (JVM) 的垃圾回收器会自动回收不可达对象的内存空间。
销毁 (Destruction): 对象占用的内存被释放。 (注意, Java中没有析构函数)

五、对象的内存管理 (Memory Management)

堆内存 (Heap): 对象存储在堆内存中。
垃圾回收 (Garbage Collection): Java 虚拟机 (JVM) 自动管理内存，通过垃圾回收器 (Garbage Collector, GC) 自动回收不再使用的对象。
引用类型：
- 强引用 (Strong Reference): 最常见的引用类型。只要存在强引用，对象就不会被垃圾回收。
- 软引用 (SoftReference): 用于描述一些还有用但非必需的对象。在内存不足时，垃圾回收器可能会回收软引用指向的对象。
- 弱引用 (WeakReference): 比软引用更弱，只要发生垃圾回收，弱引用指向的对象就会被回收。
- 虚引用 (PhantomReference): 最弱的引用类型，无法通过虚引用获取对象。虚引用主要用于跟踪对象被垃圾回收的状态。

六、对象的使用场景

对象是面向对象编程的核心，几乎所有的 Java 程序都会使用对象。以下是一些典型的使用场景：

表示现实世界的实体： 如前所述，对象可以用来表示现实世界中的各种事物，例如人、动物、汽车、订单、商品、账户等。
封装数据和行为： 对象将数据（属性）和操作数据的方法（行为）封装在一起，形成一个独立的单元。这有助于提高代码的可维护性、可重用性和安全性。
实现业务逻辑： 通过创建和操作对象，可以实现复杂的业务逻辑。
构建数据结构： 对象可以用来构建各种数据结构，例如链表、树、图等。
作为方法的参数和返回值： 对象可以作为方法的参数传递，也可以作为方法的返回值。
集合框架中的元素： Java 集合框架（例如 List, Set, Map）中存储的元素都是对象。
GUI 编程中的组件： 在 GUI 编程中，各种 UI 组件（例如按钮、文本框、标签等）都是对象。
Web 开发中的请求和响应： 在 Web 开发中，HTTP 请求和响应通常被封装成对象（例如 HttpServletRequest, HttpServletResponse）。
数据库操作中的实体： 在使用 ORM 框架（例如 Hibernate, JPA）时，数据库表中的记录通常被映射为 Java 对象。
事件处理： 事件源、事件监听器和事件对象通常都是对象。

七、最佳实践

面向对象设计原则： 在创建和使用对象时，遵循 SOLID 原则（单一职责、开闭、里氏替换、接口隔离、依赖倒置）。
封装： 将对象的属性声明为 private，并通过 getter 和 setter 方法提供对属性的受控访问。
不可变对象 (Immutable Objects)： 如果对象的状态不需要改变，可以将对象设计为不可变对象。不可变对象是线程安全的，可以简化并发编程。
对象比较： 使用 equals() 方法比较对象的内容是否相等，而不是使用 == 运算符比较对象的引用是否相等。重写equals方法时，通常也需要重写hashCode方法。
对象克隆： 如果需要创建对象的副本，可以使用 clone() 方法（需要实现 Cloneable 接口）或复制构造函数。
避免内存泄漏： 及时释放不再使用的对象引用，避免内存泄漏。特别注意集合类中的对象引用, 以及ThreadLocal中的对象引用。
合理使用对象池： 对于创建和销毁开销较大的对象 (例如数据库连接)，可以使用对象池来重用对象，提高性能。