Java对象如何获取属性值？普通对象与实体类取值方法详解

在Java编程中,对象是程序的核心载体，而取值操作则是日常开发中最频繁的操作之一，无论是简单的数据展示，还是复杂的业务逻辑处理，都离不开对对象属性的访问，掌握Java对象的取值方法，不仅能提升代码的可读性和可维护性，还能避免潜在的错误，本文将从基础到进阶，系统介绍Java对象取值的多种方式及其适用场景。

直接访问对象字段（非封装场景）

最直观的取值方式是通过直接访问对象的公共字段（public field），这种方式无需额外的方法调用，代码简洁，适用于工具类、内部类或临时数据存储等对封装性要求不高的场景，定义一个Student类，包含公共字段name和age：

public class Student {
    public String name;
    public int age;
}
// 取值示例
Student student = new Student();
student.name = "张三";
student.age = 18;
String studentName = student.name; // 直接访问
int studentAge = student.age;

优点：代码简单直观，性能开销小（无需方法调用栈）。
缺点：破坏了对象的封装性，若字段类型或逻辑变更（如age需要校验范围），所有直接访问的代码均需修改，不利于维护，实际开发中应谨慎使用直接访问，除非场景非常简单且字段不会频繁变更。

通过Getter/Setter方法（封装场景）

面向对象设计强调封装性,即隐藏对象的内部实现，仅通过公共方法（如getter和setter）暴露属性，这是Java中最推荐的对象取值方式，尤其适用于业务逻辑层、实体类等场景。

以Student类为例，将字段设为私有（private），并提供公共的getter和setter方法：

public class Student {
    private String name;
    private int age;
    // Getter方法
    public String getName() {
        return name;
    }
    // Setter方法（可添加校验逻辑）
    public void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("年龄不能为负数");
        }
        this.age = age;
    }
}
// 取值示例
Student student = new Student();
student.setName("李四");
student.setAge(20);
String studentName = student.getName(); // 通过getter取值
int studentAge = student.getAge();

优点：

1. 封装保护：字段对外不可见，避免非法修改（如setAge中的校验逻辑）；
2. 灵活性高：若需修改字段逻辑（如name需要自动添加前后缀），只需修改getter/setter，调用方代码无需变更；
3. 支持扩展：可在方法中添加日志、缓存等逻辑，如getName时记录访问日志。

注意：若使用Lombok等工具，可通过@Getter和@Setter注解自动生成方法，减少样板代码。

反射机制（动态取值场景）

反射（Reflection）是Java动态特性的核心，允许程序在运行时动态获取类的信息（如字段、方法）并操作对象，适用于框架开发、动态代理、通用工具类等需要“未知对象取值”的场景。

反射取值的核心步骤：

1. 获取对象的Class对象；
2. 通过Class对象获取目标字段（Field）；
3. 设置字段可访问性（若为私有字段）；
4. 调用Field.get()方法取值。

示例：通过反射获取Student对象的name字段：

import java.lang.reflect.Field;
public class ReflectionExample {
    public static void main(String[] args) throws Exception {
        Student student = new Student();
        student.setName("王五");
        student.setAge(22);
        // 1. 获取Class对象
        Class<?> studentClass = student.getClass();
        // 2. 获取目标字段（注意：字段名需与类中定义一致）
        Field nameField = studentClass.getDeclaredField("name");
        // 3. 设置可访问性（突破private限制）
        nameField.setAccessible(true);
        // 4. 取值
        Object nameValue = nameField.get(student);
        System.out.println("反射取值结果：" + nameValue); // 输出：王五
    }
}

优点：

• 动态性强：无需提前知道对象类型，适用于通用代码（如ORM框架将ResultSet映射为对象）；
• 可访问私有字段：突破封装限制（但会破坏封装性，需谨慎使用）。

缺点：

• 性能开销：反射比直接访问慢10-100倍，不适合高频调用场景；
• 安全风险：可随意访问私有字段，可能导致代码混乱；
• 异常处理：需处理NoSuchFieldException、IllegalAccessException等异常，代码冗长。

适用场景：Spring框架的依赖注入、MyBatis的结果集映射、动态工具类（如对象属性拷贝）等。

JSON序列化/反序列化（数据交互场景）

在前后端分离或跨系统交互中,数据通常以JSON格式传输，此时需将Java对象序列化为JSON字符串，或将JSON字符串反序列化为Java对象，再从中取值，常用库包括Jackson、Gson、Fastjson等。

以Gson为例,演示对象与JSON的转换及取值：

import com.google.gson.Gson;
public class JsonExample {
    public static void main(String[] args) {
        // 1. 创建对象并设置属性
        Student student = new Student();
        student.setName("赵六");
        student.setAge(25);
        // 2. 序列化为JSON字符串
        Gson gson = new Gson();
        String jsonString = gson.toJson(student);
        System.out.println("序列化结果：" + jsonString); // 输出：{"name":"赵六","age":25}
        // 3. 反序列化为Java对象
        Student deserializedStudent = gson.fromJson(jsonString, Student.class);
        String studentName = deserializedStudent.getName(); // 从反序列化对象中取值
        System.out.println("反序列化后取值：" + studentName); // 输出：赵六
    }
}

优点：

• 跨语言兼容：JSON是通用数据格式，支持与前端、其他语言系统交互；
• 灵活映射：可通过注解（如@SerializedName）处理字段名差异（如Java的userName与JSON的user_name）。

注意：反序列化时需确保JSON字段与Java对象属性名一致（或通过注解映射），否则可能取值为null。

集合与嵌套对象的取值

实际开发中,对象常包含集合（如List、Map）或嵌套对象（如Student包含Address对象），取值时需逐层访问，或结合循环/Stream API处理集合数据。

集合取值

若对象包含List或Map，需先获取集合，再遍历取值：

import java.util.ArrayList;
import java.util.List;
public class Student {
    private String name;
    private List<String> courses; // 课程列表
    // getter/setter省略
}
// 取值示例
Student student = new Student();
student.setName("钱七");
List<String> courses = new ArrayList<>();
courses.add("数学");
courses.add("英语");
student.setCourses(courses);
// 遍历取值
for (String course : student.getCourses()) {
    System.out.println("课程：" + course);
}
// 使用Stream API
student.getCourses().stream()
    .filter(course -> course.length() > 2)
    .forEach(System.out::println);

嵌套对象取值

若对象包含另一个对象（如Student包含Address），需通过链式调用逐层访问：

public class Address {
    private String city;
    private String street;
    // getter/setter省略
}
public class Student {
    private String name;
    private Address address; // 嵌套地址对象
    // getter/setter省略
}
// 取值示例
Student student = new Student();
student.setName("孙八");
Address address = new Address();
address.setCity("北京");
address.setStreet("中关村");
student.setAddress(address);
// 链式取值
String city = student.getAddress().getCity();
System.out.println("城市：" + city); // 输出：北京

注意事项：需检查中间对象是否为null，避免NullPointerException，可通过Optional优化：

String city = Optional.ofNullable(student)
    .map(Student::getAddress)
    .map(Address::getCity)
    .orElse("未知城市");

特殊情况处理

空值处理

对象或字段可能为null，直接取值会抛出NullPointerException，可通过以下方式处理：

• 条件判断：if (student != null && student.getName() != null)；
• Optional：Optional.ofNullable(student).map(Student::getName).orElse("默认值")。

字段不存在

反射或JSON取值时,若字段名错误或对象无该字段，会抛出异常，需提前校验：

• 反射：if (studentClass.getDeclaredField("name") != null)；
• JSON：检查JSON字符串是否包含目标字段（如jsonObject.has("name")）。

不可变对象

若对象为不可变类（字段为final且无setter），取值时只能直接访问或通过getter，无法修改，例如String类，取值直接使用charAt()等方法即可。

Java对象的取值方式多种多样,需根据场景选择合适的方法：

• 简单场景：直接访问公共字段（但需谨慎使用）；
• 业务场景：优先使用getter/setter，保证封装性；
• 动态场景：反射适用于框架和工具类，但需注意性能；
• 数据交互：JSON序列化/反序列化用于跨系统传输；
• 复杂结构：结合循环、Stream API处理集合与嵌套对象，并通过Optional避免空值异常。

无论哪种方式,核心原则是：在保证代码健壮性的前提下，选择可读性高、易维护的方式，合理封装、正确处理异常，才能写出高质量的Java代码。