java对象链

Java对象链

Java对象链是指在Java程序中，对象之间通过引用连接起来形成的一种关系链。通过对象链，可以实现对象之间的数据传递和方法调用。

对象引用

在Java中，对象之间的连接是通过引用来实现的。每个对象都有一个引用变量，通过这个变量可以访问到对象的属性和方法。

public class Person {
    private String name;
    
    public Person(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("Alice");
        Person p2 = p1;
        
        System.out.println(p1.getName()); // 输出 "Alice"
        System.out.println(p2.getName()); // 输出 "Alice"
        
        p1 = new Person("Bob");
        
        System.out.println(p1.getName()); // 输出 "Bob"
        System.out.println(p2.getName()); // 输出 "Alice"
    }
}

在上面的代码中，p1和p2都是Person类型的对象引用，它们指向同一个Person对象。当p1重新指向一个新的Person对象时，p2仍然指向之前的对象。

对象链的创建

对象链的创建是通过对象之间的关联关系来实现的。一个Java对象可以包含其他对象作为它的属性，这样就形成了对象链。

public class Address {
    private String city;
    
    public Address(String city) {
        this.city = city;
    }
    
    public String getCity() {
        return city;
    }
}

public class Person {
    private String name;
    private Address address;
    
    public Person(String name, Address address) {
        this.name = name;
        this.address = address;
    }
    
    public String getName() {
        return name;
    }
    
    public Address getAddress() {
        return address;
    }
}

public class Main {
    public static void main(String[] args) {
        Address address = new Address("Beijing");
        Person person = new Person("Alice", address);
        
        System.out.println(person.getName()); // 输出 "Alice"
        System.out.println(person.getAddress().getCity()); // 输出 "Beijing"
    }
}

在上面的代码中，Person对象包含一个Address对象作为它的属性，通过person.getAddress()可以获取到Address对象的引用，从而访问到Address对象的属性。

对象链的应用

对象链在实际的Java程序中广泛应用，它可以用于构建复杂的数据结构和实现多层次的方法调用。

数据结构

对象链可以用于构建复杂的数据结构，比如链表、树和图等。通过对象链，可以快速访问和操作数据。

public class ListNode {
    private int val;
    private ListNode next;
    
    public ListNode(int val) {
        this.val = val;
        this.next = null;
    }
    
    public int getVal() {
        return val;
    }
    
    public ListNode getNext() {
        return next;
    }
    
    public void setNext(ListNode next) {
        this.next = next;
    }
}

public class LinkedList {
    private ListNode head;
    
    public LinkedList() {
        head = null;
    }
    
    public void add(int val) {
        ListNode newNode = new ListNode(val);
        
        if (head == null) {
            head = newNode;
        } else {
            ListNode current = head;
            
            while (current.getNext() != null) {
                current = current.getNext();
            }
            
            current.setNext(newNode);
        }
    }
    
    public void print() {
        ListNode current = head;
        
        while (current != null) {
            System.out.print(current.getVal() + " ");
            current = current.getNext();
        }
        
        System.out.println();
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        
        list.add(1);
        list.add(2);
        list.add(3);
        
        list.print(); // 输出 "1 2 3"
    }
}

在上面的代码中，通过对象链的方式实现了一个简单的链表结构。LinkedList类包含一个头节点head，每个节点通过next引用连接起来。通过add方法可以向链表中添加元素，通过print方法可以打印链表的内容。

方法调用

对象链可以用于实现多层次的方法调用，通过对象链可以在不同的对象之间传递数据和调用方法。

public class Calculator {
    private int result;
    
    public Calculator() {
        result = 0;
    }
    
    public void add