编程马·菜鸟教程

Appearance

10.3 对象的创建与使用 ​

对象的创建 ​

对象是类的实例，创建对象的过程称为实例化。在 Java 中，使用 new 关键字来创建对象。

创建对象的语法 ​

语法：

java
类名 对象名 = new 构造方法([参数]);

示例：

java
// 创建 Person 类的对象
Person person = new Person();

// 创建带参数的 Person 类对象
Person person2 = new Person("John", 25);

对象的使用 ​

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

访问对象的属性 ​

语法：

java
对象名.属性名;

示例：

java
// 访问对象的属性
person.name = "John";
String name = person.name;

调用对象的方法 ​

语法：

java
对象名.方法名([参数]);

示例：

java
// 调用对象的方法
person.eat();
person.sleep();

示例：对象的创建与使用 ​

示例 1：基本使用 ​

java
public class Person {
    // 属性
    private String name;
    private int age;
    
    // 构造方法
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 方法
    public void eat() {
        System.out.println(name + " is eating.");
    }
    
    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
    
    // getter 和 setter 方法
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
}

public class PersonExample {
    public static void main(String[] args) {
        // 创建对象
        Person person1 = new Person();
        Person person2 = new Person("John", 25);
        
        // 使用对象
        System.out.println("Person 1:");
        System.out.println("Name: " + person1.getName());
        System.out.println("Age: " + person1.getAge());
        person1.setName("Jane");
        person1.setAge(30);
        System.out.println("Updated Person 1:");
        System.out.println("Name: " + person1.getName());
        System.out.println("Age: " + person1.getAge());
        person1.eat();
        person1.sleep();
        
        System.out.println("\nPerson 2:");
        System.out.println("Name: " + person2.getName());
        System.out.println("Age: " + person2.getAge());
        person2.eat();
        person2.sleep();
    }
}

示例 2：多个对象的使用 ​

java
public class Car {
    // 属性
    private String brand;
    private String model;
    private int year;
    
    // 构造方法
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
    }
    
    // 方法
    public void start() {
        System.out.println(brand + " " + model + " is starting.");
    }
    
    public void stop() {
        System.out.println(brand + " " + model + " is stopping.");
    }
    
    // getter 方法
    public String getBrand() {
        return brand;
    }
    
    public String getModel() {
        return model;
    }
    
    public int getYear() {
        return year;
    }
}

public class CarExample {
    public static void main(String[] args) {
        // 创建多个汽车对象
        Car car1 = new Car("Toyota", "Camry", 2020);
        Car car2 = new Car("Honda", "Civic", 2021);
        Car car3 = new Car("Ford", "Mustang", 2022);
        
        // 使用对象
        System.out.println("Car 1: " + car1.getBrand() + " " + car1.getModel() + " " + car1.getYear());
        car1.start();
        car1.stop();
        
        System.out.println("\nCar 2: " + car2.getBrand() + " " + car2.getModel() + " " + car2.getYear());
        car2.start();
        car2.stop();
        
        System.out.println("\nCar 3: " + car3.getBrand() + " " + car3.getModel() + " " + car3.getYear());
        car3.start();
        car3.stop();
    }
}

示例 3：对象数组 ​

java
public class Student {
    // 属性
    private String name;
    private int studentId;
    private double grade;
    
    // 构造方法
    public Student(String name, int studentId, double grade) {
        this.name = name;
        this.studentId = studentId;
        this.grade = grade;
    }
    
    // 方法
    public boolean isPass() {
        return grade >= 60;
    }
    
    // getter 方法
    public String getName() {
        return name;
    }
    
    public int getStudentId() {
        return studentId;
    }
    
    public double getGrade() {
        return grade;
    }
}

public class StudentArrayExample {
    public static void main(String[] args) {
        // 创建学生对象数组
        Student[] students = new Student[3];
        students[0] = new Student("John", 1001, 85.5);
        students[1] = new Student("Jane", 1002, 92.0);
        students[2] = new Student("Bob", 1003, 58.5);
        
        // 使用对象数组
        for (int i = 0; i < students.length; i++) {
            Student student = students[i];
            System.out.println("Student " + (i + 1) + ":");
            System.out.println("Name: " + student.getName());
            System.out.println("Student ID: " + student.getStudentId());
            System.out.println("Grade: " + student.getGrade());
            System.out.println("Pass: " + student.isPass());
            System.out.println();
        }
    }
}

对象的生命周期 ​

对象的生命周期包括创建、使用和销毁三个阶段：

  1. 创建阶段：使用 new 关键字创建对象，分配内存空间
  2. 使用阶段：访问对象的属性和调用对象的方法
  3. 销毁阶段：当对象不再被引用时，由垃圾回收器回收

垃圾回收 ​

Java 有自动垃圾回收机制，当对象不再被引用时，垃圾回收器会自动回收对象占用的内存空间。

示例：

java
Person person = new Person("John", 25);
// 使用对象
person.eat();
// 不再引用对象，对象变为垃圾
person = null;
// 垃圾回收器会回收对象占用的内存

对象的引用 ​

在 Java 中，对象变量实际上是对象的引用，它存储的是对象在内存中的地址。

引用的传递 ​

当将一个对象变量赋值给另一个对象变量时，传递的是对象的引用，而不是对象本身。

示例：

java
Person person1 = new Person("John", 25);
Person person2 = person1; // person2 引用同一个对象

// 修改 person2 的属性，person1 的属性也会改变
person2.setName("Jane");
System.out.println(person1.getName()); // 输出 "Jane"

引用的比较 ​

使用 == 运算符比较的是对象的引用，即两个变量是否指向同一个对象；使用 equals() 方法比较的是对象的内容。

示例：

java
Person person1 = new Person("John", 25);
Person person2 = new Person("John", 25);
Person person3 = person1;

// 比较引用
System.out.println(person1 == person2); // 输出 false，不同的对象
System.out.println(person1 == person3); // 输出 true，相同的对象

// 比较内容
System.out.println(person1.equals(person2)); // 输出 false，需要重写 equals 方法

示例：对象作为方法参数 ​

java
public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
}

public class PersonExample {
    public static void main(String[] args) {
        Person person = new Person("John", 25);
        System.out.println("Before change: " + person.getName());
        changeName(person, "Jane");
        System.out.println("After change: " + person.getName());
    }
    
    public static void changeName(Person p, String newName) {
        p.setName(newName);
    }
}

示例：对象作为方法返回值 ​

java
public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
}

public class PersonFactory {
    public static Person createPerson(String name, int age) {
        return new Person(name, age);
    }
    
    public static void main(String[] args) {
        Person person = createPerson("John", 25);
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

常见问题 ​

1. 空指针异常 ​

症状：运行时错误：NullPointerException

解决方案：确保对象已经初始化，避免使用 null 引用

示例：

java
Person person = null;
// 会导致 NullPointerException
person.getName();

2. 对象引用错误 ​

症状：修改一个对象的属性，另一个对象的属性也发生变化

解决方案：了解对象引用的传递机制，避免意外修改

示例：

java
Person person1 = new Person("John", 25);
Person person2 = person1; // 引用同一个对象
person2.setName("Jane");
// person1 的名称也会变为 "Jane"

3. 构造方法调用错误 ​

症状：编译错误：The constructor Person() is undefined

解决方案：确保调用了正确的构造方法，或者定义了相应的构造方法

示例：

java
public class Person {
    public Person(String name, int age) {
        // 构造方法
    }
}

// 会导致编译错误，因为没有无参构造方法
Person person = new Person();

4. 内存泄漏 ​

症状：程序运行一段时间后内存占用增加

解决方案：及时释放不再使用的对象引用

示例：

java
// 正确做法：使用完对象后设置为 null
Person person = new Person("John", 25);
// 使用 person
person = null; // 释放引用

最佳实践 ​

  1. 合理使用构造方法：根据需要定义构造方法，确保对象初始化正确
  2. 使用封装：将属性设为 private，通过 getter 和 setter 方法访问
  3. 及时释放引用：不再使用的对象应设置为 null，以便垃圾回收
  4. 避免空指针：使用对象前检查是否为 null
  5. 理解引用传递：了解对象引用的传递机制，避免意外修改

总结 ​

对象的创建与使用是面向对象编程的核心。通过 new 关键字创建对象，然后通过对象名访问属性和调用方法。

在使用对象时，需要注意：

  • 对象变量是对象的引用，存储的是对象在内存中的地址
  • 当将一个对象变量赋值给另一个对象变量时，传递的是引用
  • 使用 == 运算符比较的是引用，使用 equals() 方法比较的是内容
  • 及时释放不再使用的对象引用，避免内存泄漏
  • 避免空指针异常

通过合理创建和使用对象，可以实现面向对象编程的优势，使代码更加清晰、可维护。

© 2026 编程马·菜鸟教程 版权所有

基于 VitePress 构建