在Java的面向对象编程体系中，对象不是孤立存在的，多个对象通过特定的方式相互通信、配合工作，才能共同实现完整的业务功能。对象之间的交互本质是一个对象向另一个对象发送消息、获取反馈的过程。
1. 通过方法调用实现交互
方法调用是Java对象之间最基础、最常用的交互方式。一个对象可以直接调用另一个对象提供的公开方法，传递必要的参数并获取返回结果，完成信息的传递和功能的协作。
比如我们定义两个对象，一个是UserService用户服务类，另一个是UserRepository用户数据操作类，UserService需要调用UserRepository的方法完成用户数据的查询操作。
// 用户实体类
class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
// 用户数据操作类
class UserRepository {
// 根据用户名查询用户
public User findUserByName(String name) {
// 模拟数据库查询逻辑
if ("张三".equals(name)) {
return new User("张三", 25);
}
return null;
}
}
// 用户服务类
class UserService {
private UserRepository userRepository;
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
// 处理用户查询业务
public void handleUserQuery(String name) {
User user = userRepository.findUserByName(name);
if (user != null) {
System.out.println("查询到用户：" + user.getName() + "，年龄：" + user.getAge());
} else {
System.out.println("未查询到用户：" + name);
}
}
}
// 测试类
public class Main {
public static void main(String[] args) {
UserRepository repository = new UserRepository();
UserService service = new UserService(repository);
// UserService对象调用自身方法，内部间接调用UserRepository对象的方法，实现对象交互
service.handleUserQuery("张三");
}
}
2. 通过参数传递共享数据
对象之间交互时，常常需要传递数据，Java通过参数传递的方式让对象之间共享需要的信息。参数传递分为值传递和引用传递，对于基本数据类型传递的是值的副本，对于引用数据类型传递的是引用的副本，修改引用指向的对象内容会影响所有持有该引用的对象。
下面的示例中，Order订单对象作为参数传递给OrderService的processOrder方法，OrderService修改订单的状态，最终订单对象的状态会被更新。
class Order {
private String orderId;
private String status;
public Order(String orderId) {
this.orderId = orderId;
this.status = "待处理";
}
public void setStatus(String status) {
this.status = status;
}
public String getStatus() {
return status;
}
public String getOrderId() {
return orderId;
}
}
class OrderService {
// 处理订单，接收Order对象作为参数
public void processOrder(Order order) {
System.out.println("开始处理订单：" + order.getOrderId());
// 修改订单状态
order.setStatus("已处理");
}
}
public class ParamDemo {
public static void main(String[] args) {
Order order = new Order("ORDER_001");
OrderService orderService = new OrderService();
System.out.println("处理前订单状态：" + order.getStatus());
// 将order对象传递给OrderService对象，完成交互
orderService.processOrder(order);
System.out.println("处理后订单状态：" + order.getStatus());
}
}
3. 通过接口实现解耦交互
如果对象之间直接依赖具体的实现类，会导致代码的耦合度较高，后期维护困难。通过接口定义交互规范，对象依赖接口而不是具体实现，可以让对象之间的交互更加灵活，也方便后续的扩展和替换。
比如我们定义一个MessageSender接口，不同的消息发送实现类实现这个接口，业务类只需要依赖接口就可以完成消息发送的交互，不需要关心具体的发送方式。
// 消息发送接口
interface MessageSender {
void sendMessage(String content);
}
// 邮件发送实现类
class EmailSender implements MessageSender {
@Override
public void sendMessage(String content) {
System.out.println("发送邮件消息：" + content);
}
}
// 短信发送实现类
class SmsSender implements MessageSender {
@Override
public void sendMessage(String content) {
System.out.println("发送短信消息：" + content);
}
}
// 通知服务类，依赖MessageSender接口
class NotificationService {
private MessageSender messageSender;
public NotificationService(MessageSender messageSender) {
this.messageSender = messageSender;
}
public void sendNotification(String content) {
messageSender.sendMessage(content);
}
}
public class InterfaceDemo {
public static void main(String[] args) {
// 使用邮件发送方式
MessageSender emailSender = new EmailSender();
NotificationService emailNotification = new NotificationService(emailSender);
emailNotification.sendNotification("您的订单已发货");
// 切换到短信发送方式，不需要修改NotificationService的代码
MessageSender smsSender = new SmsSender();
NotificationService smsNotification = new NotificationService(smsSender);
smsNotification.sendNotification("您的验证码是123456");
}
}
4. 通过事件监听机制交互
事件监听机制是一种发布订阅模式的交互方式，一个对象作为事件源发布事件，其他对象作为监听器订阅事件，当事件发生时事件源通知所有监听器，监听器执行对应的处理逻辑。这种方式可以让事件源和监听器完全解耦，不需要互相持有引用。
Java本身的EventListener体系就是事件监听的典型实现，我们也可以自定义简单的事件监听逻辑。
import java.util.ArrayList;
import java.util.List;
// 自定义事件类
class CustomEvent {
private String eventName;
public CustomEvent(String eventName) {
this.eventName = eventName;
}
public String getEventName() {
return eventName;
}
}
// 事件监听器接口
interface CustomEventListener {
void onEvent(CustomEvent event);
}
// 事件源类
class EventSource {
private List<CustomEventListener> listeners = new ArrayList<>();
// 注册监听器
public void addListener(CustomEventListener listener) {
listeners.add(listener);
}
// 触发事件
public void fireEvent(String eventName) {
CustomEvent event = new CustomEvent(eventName);
for (CustomEventListener listener : listeners) {
listener.onEvent(event);
}
}
}
// 具体监听器实现
class LogEventListener implements CustomEventListener {
@Override
public void onEvent(CustomEvent event) {
System.out.println("日志记录事件：" + event.getEventName());
}
}
class NotifyEventListener implements CustomEventListener {
@Override
public void onEvent(CustomEvent event) {
System.out.println("触发通知事件：" + event.getEventName());
}
}
public class EventDemo {
public static void main(String[] args) {
EventSource eventSource = new EventSource();
// 注册监听器
eventSource.addListener(new LogEventListener());
eventSource.addListener(new NotifyEventListener());
// 触发事件，所有监听器都会收到通知
eventSource.fireEvent("用户注册成功");
}
}
不同交互方式的适用场景
不同的对象交互方式适用于不同的开发场景，我们可以根据实际需求选择合适的方式：
| 交互方式 | 适用场景 | 优势 |
|---|---|---|
| 直接方法调用 | 对象之间关系紧密，交互逻辑简单直接 | 实现简单，逻辑清晰，性能较高 |
| 参数传递 | 需要共享数据，传递交互所需的信息 | 灵活传递不同数据，支持复杂交互逻辑 |
| 接口实现 | 需要解耦对象依赖，支持扩展替换 | 降低耦合度，符合开闭原则，便于维护 |
| 事件监听 | 一对多的交互场景，事件源不需要知道监听者存在 | 完全解耦，支持动态添加删除监听者 |
在实际的Java开发中，对象交互往往是多种方式的结合使用，合理选择交互方式可以让代码结构更清晰，可维护性和可扩展性更强。