Java对象设置全指南 从创建实例到属性赋值的详细教程助你轻松掌握面向对象编程核心技能

威震华夏关云长

引言

Java作为一门面向对象的编程语言，其核心思想就是通过对象来构建程序。理解和掌握Java对象的创建与属性赋值是学习Java编程的基础，也是成为优秀Java开发者的必经之路。本文将全面介绍Java对象的创建方式、属性赋值方法以及相关最佳实践，帮助读者深入理解面向对象编程的核心概念。

Java类和对象的基础概念

在深入探讨对象创建和属性赋值之前，我们先来回顾一下Java中类和对象的基本概念。

类与对象的关系

类是对象的模板或蓝图，它定义了对象的属性和行为。对象则是类的具体实例，拥有类定义的属性和行为的实际值。

2. // 定义一个简单的Person类
3. public class Person {
4.     // 属性
5.     private String name;
6.     private int age;
7.    
8.     // 行为
9.     public void introduce() {
10.         System.out.println("我叫" + name + "，今年" + age + "岁。");
11.     }
12. }

复制代码

在上面的代码中，Person是一个类，它定义了name和age两个属性，以及一个introduce()方法。当我们创建Person类的实例时，就得到了一个Person对象。

创建Java对象的多种方式

Java提供了多种创建对象的方式，每种方式都有其适用的场景和特点。

1. 使用new关键字

最常见和直接的创建对象方式是使用new关键字，它会调用类的构造函数来初始化对象。

2. // 使用new关键字创建Person对象
3. Person person = new Person();

复制代码

当使用new关键字时，JVM会执行以下步骤：

1. 在堆内存中分配对象空间
2. 调用构造函数初始化对象的属性
3. 返回对象的引用

我们可以定义带参数的构造函数，在创建对象时直接给属性赋值：

2. public class Person {
3.     private String name;
4.     private int age;
5.    
6.     // 无参构造函数
7.     public Person() {
8.         this.name = "未知";
9.         this.age = 0;
10.     }
11.    
12.     // 带参数的构造函数
13.     public Person(String name, int age) {
14.         this.name = name;
15.         this.age = age;
16.     }
17.    
18.     public void introduce() {
19.         System.out.println("我叫" + name + "，今年" + age + "岁。");
20.     }
21. }
23. // 使用带参数的构造函数创建对象
24. Person person1 = new Person(); // 使用无参构造函数
25. Person person2 = new Person("张三", 25); // 使用带参数的构造函数
27. person1.introduce(); // 输出：我叫未知，今年0岁。
28. person2.introduce(); // 输出：我叫张三，今年25岁。

复制代码

2. 使用反射机制

反射是Java中一种强大的机制，它允许程序在运行时检查和修改类、方法、属性等信息。通过反射，我们可以在运行时创建对象。

2. import java.lang.reflect.Constructor;
4. public class ReflectionExample {
5.     public static void main(String[] args) {
6.         try {
7.             // 获取Person类的Class对象
8.             Class<?> personClass = Class.forName("Person");
9.             
10.             // 获取无参构造函数并创建对象
11.             Constructor<?> constructor1 = personClass.getDeclaredConstructor();
12.             Person person1 = (Person) constructor1.newInstance();
13.             person1.introduce(); // 输出：我叫未知，今年0岁。
14.             
15.             // 获取带参数的构造函数并创建对象
16.             Constructor<?> constructor2 = personClass.getDeclaredConstructor(String.class, int.class);
17.             Person person2 = (Person) constructor2.newInstance("李四", 30);
18.             person2.introduce(); // 输出：我叫李四，今年30岁。
19.         } catch (Exception e) {
20.             e.printStackTrace();
21.         }
22.     }
23. }

复制代码

反射机制在框架开发、动态代理等场景中非常有用，但它会破坏封装性，降低程序性能，因此在日常开发中应谨慎使用。

3. 使用clone方法

如果需要创建一个与现有对象属性完全相同的对象，可以使用clone()方法。需要注意的是，要使用clone()方法，类必须实现Cloneable接口。

2. public class Person implements Cloneable {
3.     private String name;
4.     private int age;
5.    
6.     public Person(String name, int age) {
7.         this.name = name;
8.         this.age = age;
9.     }
10.    
11.     public void introduce() {
12.         System.out.println("我叫" + name + "，今年" + age + "岁。");
13.     }
14.    
15.     // 重写clone方法
16.     @Override
17.     protected Object clone() throws CloneNotSupportedException {
18.         return super.clone();
19.     }
20.    
21.     public static void main(String[] args) {
22.         try {
23.             Person person1 = new Person("王五", 28);
24.             person1.introduce(); // 输出：我叫王五，今年28岁。
25.             
26.             // 使用clone方法创建对象
27.             Person person2 = (Person) person1.clone();
28.             person2.introduce(); // 输出：我叫王五，今年28岁。
29.             
30.             // 验证是否为不同对象
31.             System.out.println(person1 == person2); // 输出：false
32.         } catch (CloneNotSupportedException e) {
33.             e.printStackTrace();
34.         }
35.     }
36. }

复制代码

需要注意的是，clone()方法实现的是浅拷贝，如果对象中包含引用类型的属性，拷贝后的对象和原对象会共享这些引用类型的属性。

4. 使用反序列化

如果对象实现了Serializable接口，我们可以通过反序列化的方式从字节流中重建对象。

2. import java.io.*;
4. public class Person implements Serializable {
5.     private String name;
6.     private int age;
7.    
8.     public Person(String name, int age) {
9.         this.name = name;
10.         this.age = age;
11.     }
12.    
13.     public void introduce() {
14.         System.out.println("我叫" + name + "，今年" + age + "岁。");
15.     }
16.    
17.     public static void main(String[] args) {
18.         // 序列化对象
19.         try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
20.             Person person1 = new Person("赵六", 35);
21.             oos.writeObject(person1);
22.             System.out.println("对象已序列化");
23.         } catch (IOException e) {
24.             e.printStackTrace();
25.         }
26.         
27.         // 反序列化对象
28.         try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
29.             Person person2 = (Person) ois.readObject();
30.             person2.introduce(); // 输出：我叫赵六，今年35岁。
31.             System.out.println("对象已反序列化");
32.         } catch (IOException | ClassNotFoundException e) {
33.             e.printStackTrace();
34.         }
35.     }
36. }

复制代码

对象属性赋值的方法

创建对象后，我们通常需要给对象的属性赋值。Java提供了多种属性赋值的方法。

1. 直接访问公共属性

如果属性被声明为public，我们可以直接通过对象访问并修改它。

2. public class Person {
3.     public String name;
4.     public int age;
5.    
6.     public void introduce() {
7.         System.out.println("我叫" + name + "，今年" + age + "岁。");
8.     }
9.    
10.     public static void main(String[] args) {
11.         Person person = new Person();
12.         
13.         // 直接访问公共属性
14.         person.name = "钱七";
15.         person.age = 40;
16.         
17.         person.introduce(); // 输出：我叫钱七，今年40岁。
18.     }
19. }

复制代码

然而，这种做法破坏了封装性，通常不推荐使用。更好的做法是将属性声明为private，然后通过公共方法来访问和修改它们。

2. 使用setter方法

setter方法是设置对象属性的标准方式，它提供了对属性赋值的控制。

2. public class Person {
3.     private String name;
4.     private int age;
5.    
6.     // setter方法
7.     public void setName(String name) {
8.         this.name = name;
9.     }
10.    
11.     public void setAge(int age) {
12.         if (age >= 0) { // 添加参数验证
13.             this.age = age;
14.         } else {
15.             System.out.println("年龄不能为负数");
16.         }
17.     }
18.    
19.     public void introduce() {
20.         System.out.println("我叫" + name + "，今年" + age + "岁。");
21.     }
22.    
23.     public static void main(String[] args) {
24.         Person person = new Person();
25.         
26.         // 使用setter方法设置属性
27.         person.setName("孙八");
28.         person.setAge(42);
29.         person.setAge(-5); // 输出：年龄不能为负数
30.         
31.         person.introduce(); // 输出：我叫孙八，今年42岁。
32.     }
33. }

复制代码

使用setter方法的好处是可以在赋值前进行参数验证，确保数据的有效性。

3. 通过构造函数赋值

我们已经在前面介绍过，可以在创建对象时通过构造函数给属性赋值。

2. public class Person {
3.     private String name;
4.     private int age;
5.    
6.     public Person(String name, int age) {
7.         this.name = name;
8.         this.age = age;
9.     }
10.    
11.     public void introduce() {
12.         System.out.println("我叫" + name + "，今年" + age + "岁。");
13.     }
14.    
15.     public static void main(String[] args) {
16.         // 通过构造函数给属性赋值
17.         Person person = new Person("周九", 38);
18.         person.introduce(); // 输出：我叫周九，今年38岁。
19.     }
20. }

复制代码

通过构造函数赋值可以确保对象在创建时就具有有效的初始状态，避免了创建对象后忘记初始化属性的问题。

4. 使用反射机制赋值

除了创建对象，反射还可以用来在运行时设置对象的属性值。

2. import java.lang.reflect.Field;
4. public class Person {
5.     private String name;
6.     private int age;
7.    
8.     public void introduce() {
9.         System.out.println("我叫" + name + "，今年" + age + "岁。");
10.     }
11.    
12.     public static void main(String[] args) {
13.         try {
14.             Person person = new Person();
15.             
16.             // 获取Class对象
17.             Class<?> personClass = person.getClass();
18.             
19.             // 获取name字段并设置值
20.             Field nameField = personClass.getDeclaredField("name");
21.             nameField.setAccessible(true); // 设置为可访问，即使是private字段
22.             nameField.set(person, "吴十");
23.             
24.             // 获取age字段并设置值
25.             Field ageField = personClass.getDeclaredField("age");
26.             ageField.setAccessible(true);
27.             ageField.set(person, 45);
28.             
29.             person.introduce(); // 输出：我叫吴十，今年45岁。
30.         } catch (Exception e) {
31.             e.printStackTrace();
32.         }
33.     }
34. }

复制代码

反射赋值虽然灵活，但会破坏封装性，可能导致程序难以维护，应谨慎使用。

对象初始化的完整生命周期

了解Java对象的初始化过程对于深入理解面向对象编程非常重要。一个Java对象的完整初始化过程包括以下几个步骤：

1. 类加载：当第一次使用类时，JVM会加载类的字节码文件。
2. 类初始化：执行静态变量赋值和静态代码块。
3. 分配内存：为对象在堆内存中分配空间。
4. 属性初始化：按照声明顺序初始化非静态属性。
5. 执行构造函数：调用构造函数完成对象的初始化。

让我们通过一个例子来详细了解这个过程：

2. public class ObjectLifecycle {
3.     // 静态属性
4.     private static String staticField = initStaticField();
5.    
6.     // 非静态属性
7.     private String field = initField();
8.    
9.     // 静态代码块
10.     static {
11.         System.out.println("静态代码块执行");
12.     }
13.    
14.     // 非静态代码块
15.     {
16.         System.out.println("非静态代码块执行");
17.     }
18.    
19.     // 构造函数
20.     public ObjectLifecycle() {
21.         System.out.println("构造函数执行");
22.     }
23.    
24.     // 初始化静态属性的方法
25.     private static String initStaticField() {
26.         System.out.println("静态属性初始化");
27.         return "Static Field";
28.     }
29.    
30.     // 初始化非静态属性的方法
31.     private String initField() {
32.         System.out.println("非静态属性初始化");
33.         return "Field";
34.     }
35.    
36.     public static void main(String[] args) {
37.         System.out.println("===== 第一次创建对象 =====");
38.         ObjectLifecycle obj1 = new ObjectLifecycle();
39.         
40.         System.out.println("\n===== 第二次创建对象 =====");
41.         ObjectLifecycle obj2 = new ObjectLifecycle();
42.     }
43. }

复制代码

输出结果：

2. 静态属性初始化
3. 静态代码块执行
4. ===== 第一次创建对象 =====
5. 非静态属性初始化
6. 非静态代码块执行
7. 构造函数执行
9. ===== 第二次创建对象 =====
10. 非静态属性初始化
11. 非静态代码块执行
12. 构造函数执行

复制代码

从输出结果可以看出：

1. 静态属性初始化和静态代码块只在类第一次被使用时执行一次。
2. 每次创建对象时，都会执行非静态属性初始化、非静态代码块和构造函数。
3. 执行顺序为：静态属性初始化 → 静态代码块 → 非静态属性初始化 → 非静态代码块 → 构造函数。

最佳实践和常见陷阱

最佳实践

尽量将类的属性声明为private，通过公共的getter和setter方法来访问和修改它们。

2. public class Person {
3.     private String name;
4.     private int age;
5.    
6.     // getter方法
7.     public String getName() {
8.         return name;
9.     }
10.    
11.     public int getAge() {
12.         return age;
13.     }
14.    
15.     // setter方法
16.     public void setName(String name) {
17.         this.name = name;
18.     }
19.    
20.     public void setAge(int age) {
21.         if (age >= 0) {
22.             this.age = age;
23.         } else {
24.             throw new IllegalArgumentException("年龄不能为负数");
25.         }
26.     }
27. }

复制代码

如果可能，尽量创建不可变对象。不可变对象一旦创建，其状态就不能被修改，这使得程序更加安全和易于理解。

2. public final class ImmutablePerson {
3.     private final String name;
4.     private final int age;
5.    
6.     public ImmutablePerson(String name, int age) {
7.         this.name = name;
8.         this.age = age;
9.     }
10.    
11.     public String getName() {
12.         return name;
13.     }
14.    
15.     public int getAge() {
16.         return age;
17.     }
18.    
19.     // 不提供setter方法，确保对象不可变
20. }

复制代码

当一个类有多个可选属性时，使用构造器模式（Builder Pattern）可以创建更灵活、更易读的对象。

2. public class Person {
3.     private final String name;  // 必需属性
4.     private final int age;     // 可选属性
5.     private final String address; // 可选属性
6.     private final String phone;   // 可选属性
7.    
8.     private Person(Builder builder) {
9.         this.name = builder.name;
10.         this.age = builder.age;
11.         this.address = builder.address;
12.         this.phone = builder.phone;
13.     }
14.    
15.     // getter方法
16.     public String getName() {
17.         return name;
18.     }
19.    
20.     public int getAge() {
21.         return age;
22.     }
23.    
24.     public String getAddress() {
25.         return address;
26.     }
27.    
28.     public String getPhone() {
29.         return phone;
30.     }
31.    
32.     // Builder类
33.     public static class Builder {
34.         private final String name;  // 必需属性
35.         private int age = 0;        // 可选属性，设置默认值
36.         private String address = ""; // 可选属性，设置默认值
37.         private String phone = "";   // 可选属性，设置默认值
38.         
39.         public Builder(String name) {
40.             this.name = name;
41.         }
42.         
43.         public Builder age(int age) {
44.             this.age = age;
45.             return this;
46.         }
47.         
48.         public Builder address(String address) {
49.             this.address = address;
50.             return this;
51.         }
52.         
53.         public Builder phone(String phone) {
54.             this.phone = phone;
55.             return this;
56.         }
57.         
58.         public Person build() {
59.             return new Person(this);
60.         }
61.     }
62.    
63.     public static void main(String[] args) {
64.         // 使用Builder创建Person对象
65.         Person person1 = new Person.Builder("郑十一")
66.             .age(50)
67.             .address("北京市海淀区")
68.             .phone("13800138000")
69.             .build();
70.         
71.         Person person2 = new Person.Builder("王十二")
72.             .age(25)
73.             .build();
74.             
75.         System.out.println(person1.getName() + ", " + person1.getAge() + ", " + person1.getAddress() + ", " + person1.getPhone());
76.         System.out.println(person2.getName() + ", " + person2.getAge() + ", " + person2.getAddress() + ", " + person2.getPhone());
77.     }
78. }

复制代码

当对象需要依赖其他对象时，使用依赖注入（Dependency Injection）而不是在对象内部创建依赖项，可以提高代码的可测试性和灵活性。

2. // 服务接口
3. public interface MessageService {
4.     void sendMessage(String message, String recipient);
5. }
7. // 服务实现
8. public class EmailMessageService implements MessageService {
9.     @Override
10.     public void sendMessage(String message, String recipient) {
11.         System.out.println("发送邮件给 " + recipient + "： " + message);
12.     }
13. }
15. // 依赖MessageService的类
16. public class Notification {
17.     private final MessageService messageService;
18.    
19.     // 通过构造函数注入依赖
20.     public Notification(MessageService messageService) {
21.         this.messageService = messageService;
22.     }
23.    
24.     public void sendNotification(String message, String recipient) {
25.         messageService.sendMessage(message, recipient);
26.     }
27.    
28.     public static void main(String[] args) {
29.         // 创建依赖项
30.         MessageService emailService = new EmailMessageService();
31.         
32.         // 通过构造函数注入依赖
33.         Notification notification = new Notification(emailService);
34.         
35.         // 使用对象
36.         notification.sendNotification("您好，这是一条通知消息", "user@example.com");
37.     }
38. }

复制代码

常见陷阱

当方法返回对象内部的可变状态时，外部代码可能会修改对象的内部状态，破坏封装性。

2. import java.util.Date;
4. public class Period {
5.     private final Date start;
6.     private final Date end;
7.    
8.     public Period(Date start, Date end) {
9.         this.start = new Date(start.getTime());  // 防御性拷贝
10.         this.end = new Date(end.getTime());      // 防御性拷贝
11.         
12.         if (start.compareTo(end) > 0) {
13.             throw new IllegalArgumentException(start + " 在 " + end + " 之后");
14.         }
15.     }
16.    
17.     // 错误的做法：返回内部可变状态的引用
18.     public Date getStart() {
19.         return start;  // 逃逸引用
20.     }
21.    
22.     public Date getEnd() {
23.         return end;    // 逃逸引用
24.     }
25.    
26.     public static void main(String[] args) {
27.         Date start = new Date();
28.         Date end = new Date(start.getTime() + 1000 * 60 * 60 * 24); // 一天后
29.         
30.         Period period = new Period(start, end);
31.         System.out.println("原始结束时间: " + period.getEnd());
32.         
33.         // 通过逃逸引用修改内部状态
34.         Date endDate = period.getEnd();
35.         endDate.setTime(endDate.getTime() + 1000 * 60 * 60 * 24); // 再增加一天
36.         
37.         System.out.println("修改后的结束时间: " + period.getEnd()); // 内部状态被修改
38.     }
39. }

复制代码

正确的做法是返回防御性拷贝：

2. public Date getStart() {
3.     return new Date(start.getTime());  // 返回防御性拷贝
4. }
6. public Date getEnd() {
7.     return new Date(end.getTime());    // 返回防御性拷贝
8. }

复制代码

在构造函数中调用可被重写的方法可能导致问题，因为此时对象的初始化可能尚未完成。

2. public class SuperClass {
3.     public SuperClass() {
4.         System.out.println("SuperClass 构造函数开始");
5.         overrideMe();  // 调用可被重写的方法
6.         System.out.println("SuperClass 构造函数结束");
7.     }
8.    
9.     public void overrideMe() {
10.         System.out.println("SuperClass.overrideMe()");
11.     }
12. }
14. public class SubClass extends SuperClass {
15.     private final String value;
16.    
17.     public SubClass(String value) {
18.         super();
19.         System.out.println("SubClass 构造函数");
20.         this.value = value;
21.     }
22.    
23.     @Override
24.     public void overrideMe() {
25.         System.out.println("SubClass.overrideMe(), value = " + value);  // 此时value还未初始化
26.     }
27.    
28.     public static void main(String[] args) {
29.         SubClass sub = new SubClass("Hello");
30.     }
31. }

复制代码

输出结果：

2. SuperClass 构造函数开始
3. SubClass.overrideMe(), value = null  // value还未初始化
4. SuperClass 构造函数结束
5. SubClass 构造函数

复制代码

为了避免这种问题，不要在构造函数中调用可被重写的方法。

虽然反射提供了强大的功能，但过度使用反射会导致代码难以理解和维护，并且可能带来性能问题。

2. // 不推荐：过度使用反射
3. public class ReflectionAbuse {
4.     public static void main(String[] args) {
5.         try {
6.             // 获取类
7.             Class<?> clazz = Class.forName("java.util.ArrayList");
8.             
9.             // 创建实例
10.             Object list = clazz.getDeclaredConstructor().newInstance();
11.             
12.             // 获取add方法
13.             Method addMethod = clazz.getMethod("add", Object.class);
14.             
15.             // 调用add方法
16.             addMethod.invoke(list, "Hello");
17.             addMethod.invoke(list, "World");
18.             
19.             // 获取size方法
20.             Method sizeMethod = clazz.getMethod("size");
21.             
22.             // 调用size方法
23.             int size = (Integer) sizeMethod.invoke(list);
24.             System.out.println("Size: " + size);
25.             
26.             // 获取get方法
27.             Method getMethod = clazz.getMethod("get", int.class);
28.             
29.             // 调用get方法
30.             for (int i = 0; i < size; i++) {
31.                 Object item = getMethod.invoke(list, i);
32.                 System.out.println("Item " + i + ": " + item);
33.             }
34.         } catch (Exception e) {
35.             e.printStackTrace();
36.         }
37.     }
38. }

复制代码

上面的代码可以用更简单、更高效的方式实现：

2. // 推荐：直接使用ArrayList
3. import java.util.ArrayList;
5. public class ProperUsage {
6.     public static void main(String[] args) {
7.         ArrayList<String> list = new ArrayList<>();
8.         list.add("Hello");
9.         list.add("World");
10.         
11.         System.out.println("Size: " + list.size());
12.         
13.         for (int i = 0; i < list.size(); i++) {
14.             System.out.println("Item " + i + ": " + list.get(i));
15.         }
16.     }
17. }

复制代码

实际应用示例

让我们通过一个完整的示例来综合运用本文介绍的知识点。假设我们要开发一个简单的图书管理系统，包含图书和作者两个类，以及它们之间的关系。

2. import java.util.ArrayList;
3. import java.util.List;
4. import java.util.Objects;
6. // 作者类
7. public class Author {
8.     private final String name;  // 作者姓名
9.     private final String email; // 作者邮箱
10.     private List<Book> books;   // 作者的图书列表
11.    
12.     public Author(String name, String email) {
13.         this.name = Objects.requireNonNull(name, "作者姓名不能为null");
14.         this.email = Objects.requireNonNull(email, "作者邮箱不能为null");
15.         this.books = new ArrayList<>();
16.     }
17.    
18.     // 添加图书
19.     public void addBook(Book book) {
20.         if (book != null && !books.contains(book)) {
21.             books.add(book);
22.             book.addAuthor(this);  // 维护双向关系
23.         }
24.     }
25.    
26.     // 移除图书
27.     public void removeBook(Book book) {
28.         if (books.remove(book)) {
29.             book.removeAuthor(this);  // 维护双向关系
30.         }
31.     }
32.    
33.     // getter方法
34.     public String getName() {
35.         return name;
36.     }
37.    
38.     public String getEmail() {
39.         return email;
40.     }
41.    
42.     // 返回图书列表的防御性拷贝
43.     public List<Book> getBooks() {
44.         return new ArrayList<>(books);
45.     }
46.    
47.     @Override
48.     public String toString() {
49.         return "Author{name='" + name + "', email='" + email + "'}";
50.     }
51.    
52.     @Override
53.     public boolean equals(Object o) {
54.         if (this == o) return true;
55.         if (o == null || getClass() != o.getClass()) return false;
56.         Author author = (Author) o;
57.         return name.equals(author.name) && email.equals(author.email);
58.     }
59.    
60.     @Override
61.     public int hashCode() {
62.         return Objects.hash(name, email);
63.     }
64. }
66. // 图书类
67. public class Book {
68.     private final String isbn;   // 国际标准书号
69.     private final String title;  // 书名
70.     private List<Author> authors; // 作者列表
71.    
72.     public Book(String isbn, String title) {
73.         this.isbn = Objects.requireNonNull(isbn, "ISBN不能为null");
74.         this.title = Objects.requireNonNull(title, "书名不能为null");
75.         this.authors = new ArrayList<>();
76.     }
77.    
78.     // 添加作者
79.     public void addAuthor(Author author) {
80.         if (author != null && !authors.contains(author)) {
81.             authors.add(author);
82.             author.addBook(this);  // 维护双向关系
83.         }
84.     }
85.    
86.     // 移除作者
87.     public void removeAuthor(Author author) {
88.         if (authors.remove(author)) {
89.             author.removeBook(this);  // 维护双向关系
90.         }
91.     }
92.    
93.     // getter方法
94.     public String getIsbn() {
95.         return isbn;
96.     }
97.    
98.     public String getTitle() {
99.         return title;
100.     }
101.    
102.     // 返回作者列表的防御性拷贝
103.     public List<Author> getAuthors() {
104.         return new ArrayList<>(authors);
105.     }
106.    
107.     @Override
108.     public String toString() {
109.         return "Book{isbn='" + isbn + "', title='" + title + "'}";
110.     }
111.    
112.     @Override
113.     public boolean equals(Object o) {
114.         if (this == o) return true;
115.         if (o == null || getClass() != o.getClass()) return false;
116.         Book book = (Book) o;
117.         return isbn.equals(book.isbn);
118.     }
119.    
120.     @Override
121.     public int hashCode() {
122.         return Objects.hash(isbn);
123.     }
124. }
126. // 图书管理系统
127. public class LibrarySystem {
128.     private List<Author> authors;
129.     private List<Book> books;
130.    
131.     public LibrarySystem() {
132.         this.authors = new ArrayList<>();
133.         this.books = new ArrayList<>();
134.     }
135.    
136.     // 添加作者
137.     public void addAuthor(Author author) {
138.         if (author != null && !authors.contains(author)) {
139.             authors.add(author);
140.         }
141.     }
142.    
143.     // 添加图书
144.     public void addBook(Book book) {
145.         if (book != null && !books.contains(book)) {
146.             books.add(book);
147.         }
148.     }
149.    
150.     // 查找作者的所有图书
151.     public List<Book> findBooksByAuthor(String authorName) {
152.         List<Book> result = new ArrayList<>();
153.         for (Author author : authors) {
154.             if (author.getName().equals(authorName)) {
155.                 result.addAll(author.getBooks());
156.             }
157.         }
158.         return result;
159.     }
160.    
161.     // 查找图书的所有作者
162.     public List<Author> findAuthorsByBook(String bookTitle) {
163.         List<Author> result = new ArrayList<>();
164.         for (Book book : books) {
165.             if (book.getTitle().equals(bookTitle)) {
166.                 result.addAll(book.getAuthors());
167.             }
168.         }
169.         return result;
170.     }
171.    
172.     // 显示系统中的所有图书和作者
173.     public void displayAll() {
174.         System.out.println("===== 图书列表 =====");
175.         for (Book book : books) {
176.             System.out.println(book);
177.             System.out.println("  作者:");
178.             for (Author author : book.getAuthors()) {
179.                 System.out.println("    - " + author);
180.             }
181.         }
182.         
183.         System.out.println("\n===== 作者列表 =====");
184.         for (Author author : authors) {
185.             System.out.println(author);
186.             System.out.println("  图书:");
187.             for (Book book : author.getBooks()) {
188.                 System.out.println("    - " + book);
189.             }
190.         }
191.     }
192.    
193.     public static void main(String[] args) {
194.         // 创建图书管理系统
195.         LibrarySystem library = new LibrarySystem();
196.         
197.         // 创建作者
198.         Author author1 = new Author("张三", "zhangsan@example.com");
199.         Author author2 = new Author("李四", "lisi@example.com");
200.         Author author3 = new Author("王五", "wangwu@example.com");
201.         
202.         // 创建图书
203.         Book book1 = new Book("978-7-111-12345-6", "Java编程思想");
204.         Book book2 = new Book("978-7-111-23456-7", "Effective Java");
205.         Book book3 = new Book("978-7-111-34567-8", "设计模式");
206.         
207.         // 添加作者和图书到系统
208.         library.addAuthor(author1);
209.         library.addAuthor(author2);
210.         library.addAuthor(author3);
211.         
212.         library.addBook(book1);
213.         library.addBook(book2);
214.         library.addBook(book3);
215.         
216.         // 建立作者和图书之间的关系
217.         book1.addAuthor(author1);
218.         book1.addAuthor(author2);
219.         
220.         book2.addAuthor(author1);
221.         
222.         book3.addAuthor(author2);
223.         book3.addAuthor(author3);
224.         
225.         // 显示系统中的所有图书和作者
226.         library.displayAll();
227.         
228.         // 查找特定作者的图书
229.         System.out.println("\n===== 查找张三的图书 =====");
230.         List<Book> zhangsanBooks = library.findBooksByAuthor("张三");
231.         for (Book book : zhangsanBooks) {
232.             System.out.println(book);
233.         }
234.         
235.         // 查找特定图书的作者
236.         System.out.println("\n===== 查找《设计模式》的作者 =====");
237.         List<Author> designPatternAuthors = library.findAuthorsByBook("设计模式");
238.         for (Author author : designPatternAuthors) {
239.             System.out.println(author);
240.         }
241.     }
242. }

复制代码

这个示例展示了：

1. 如何创建类和对象
2. 如何使用构造函数初始化对象
3. 如何封装属性并提供公共访问方法
4. 如何维护对象之间的关系
5. 如何返回防御性拷贝以保护内部状态
6. 如何正确实现equals()和hashCode()方法
7. 如何使用集合类管理多个对象

总结

本文详细介绍了Java对象的创建方式、属性赋值方法以及相关最佳实践。我们学习了：

1. 创建Java对象的四种方式：使用new关键字、反射机制、clone方法和反序列化。
2. 给对象属性赋值的四种方法：直接访问公共属性、使用setter方法、通过构造函数赋值和使用反射机制赋值。
3. 对象初始化的完整生命周期，包括类加载、类初始化、内存分配、属性初始化和构造函数执行。
4. 面向对象编程的最佳实践，如封装性原则、不可变对象、构造器模式和依赖注入。
5. 常见的陷阱和如何避免它们，如逃逸引用、初始化顺序问题和过度使用反射。
6. 通过一个完整的图书管理系统示例，综合运用了本文介绍的知识点。

掌握Java对象的创建和属性赋值是面向对象编程的基础，也是成为优秀Java开发者的关键一步。希望本文能够帮助读者深入理解这些概念，并在实际开发中灵活应用。

版权声明

1、转载或引用本网站内容(Java对象设置全指南 从创建实例到属性赋值的详细教程助你轻松掌握面向对象编程核心技能)须注明原网址及作者(威震华夏关云长)，并标明本网站网址(https://www.pixtech.cc/)。

2、对于不当转载或引用本网站内容而引起的民事纷争、行政处理或其他损失，本网站不承担责任。

3、对不遵守本声明或其他违法、恶意使用本网站内容者，本网站保留追究其法律责任的权利。

本文地址: https://www.pixtech.cc/thread-41077-1-1.html