引用传递实际应用

引用传递可以说是Java的核心，也正是因为引用传递，所以可以更好的表现出现实世界的抽象。

例如，现在要求描述出这样的一种关系：一个人有一辆汽车或没有汽车。很明显，现在应该是有两个实体类，人（Member）和车（Car）。

范例： 现在可以得出如下的设计

class Member {
	private String name;
	private int age;
	private Car car; //一个人只能有一辆车
	public Member(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void setCar(Car car) {
		this.car = car;
	}
	public Car getCar() {
		return this.car;
	}
	public String getMemberInfo() {
		return "【Member】name = " + this.name + "， age = " + this.age;
	}
}
class Car {
	private String name;
	private double price;
	private Member member;
	public Car(String name, double price) {
		this.name = name;
		this.price = price;
	}
	public void setMember(Member member) {
		this.member = member;
	}
	public Member getMember() {
		return this.member;
	}
	public String getCarInfo() {
		return "【Car】name = " + this.name + "， price = " + this.price;
	}
}

public class StringDemo {
	public static void main(String args[]) {
		//第一步：根据关系设置相应的数据
		// 1、分别创建各自对象的实例
		Member mem = new Member("羽博", 30);  //人
		Car car = new Car("法拉利", 5000000.0);  //车
		// 2、根据关系取出数据
		mem.setCar(car);  //一个人有一辆车
		car.setMember(mem); //一辆车善于一个人
		//第二部：根据关系取出数据
		//3、通过人可以找到车
		System.out.println(mem.getMemberInfo());
		System.out.println(mem.getCar().getCarInfo());
		//4、通过车找到人
		System.out.println(car.getMember().getMemberInfo());
	}
}

那么如果说现在要进一步设计，羽博会有后代，后代还会有车，这时有两类做法：

• 建立一个孩子类，如果还有孙子，继续建立孙子类；
• 直接在Member类里面建立一个新的属性，属相描述的是孩子，而孩子的类型就是Member。

class Member {
	private String name;
	private int age;
	private Member child;
	private Car car; //一个人只能有一辆车
	public Member(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public void setChild(Member child) {
		this.child = child;
	}
	public Member getChild() {
		return this.child;
	}
	public void setCar(Car car) {
		this.car = car;
	}
	public Car getCar() {
		return this.car;
	}
	public String getMemberInfo() {
		return "【Member】name = " + this.name + "， age = " + this.age;
	}
}
class Car {
	private String name;
	private double price;
	private Member member;
	public Car(String name, double price) {
		this.name = name;
		this.price = price;
	}
	public void setMember(Member member) {
		this.member = member;
	}
	public Member getMember() {
		return this.member;
	}
	public String getCarInfo() {
		return "【Car】name = " + this.name + "， price = " + this.price;
	}
}
public class StringDemo {
	public static void main(String args[]) {
		//第一步：根据关系设置相应的数据
		// 1、分别创建各自对象的实例
		Member mem = new Member("羽博", 30);  //人
		Car car = new Car("法拉利", 5000000.0);  //车
		Member chd = new Member("羽三", 18); //儿子
		Car cc = new Car("玛莎拉蒂", 3.0); //儿子的车
		// 2、根据关系取出数据
		mem.setCar(car);  //一个人有一辆车
		mem.setChild(chd);//一个人有一个孩子
		chd.setCar(cc); //孩子的车
		car.setMember(mem); //一辆车善于一个人
		//第二部：根据关系取出数据
		//3、通过人可以找到车
		System.out.println(mem.getMemberInfo());
		System.out.println(mem.getCar().getCarInfo());
		//4、通过车找到人
		System.out.println(car.getMember().getMemberInfo());
		//5、通过人找到他的孩子
		System.out.println(mem.getChild().getMemberInfo());
		//6、通过人找到他孩子的车
		System.out.println(mem.getChild().getCar().getCarInfo());
	}
}

这些关系可以很好的反映现实生活。

如果现在还想进行扩展，实际上也可以更好的描述出实际的组成关系，例如：一台电脑由显示器、主机、键盘、鼠标、CPU、主板、内存所组成，那么这样的关系如何表示？

class 电脑 {
	private 显示器[] 对象;
	private 主机 对象;
	private 键盘[] 对象;
	private 鼠标[] 对象;
}
class 显示器 {}
class 主机 {
	private 主板 对象;
}
class 硬盘 {}
class 键盘 {}
class 鼠标 {}
class 主板 {
	private CPU[] 对象;
	private 内存[] 对象;
	private 硬盘[] 对象;
}

只有将这些细小的类合并到一起才能够描述出一个完整的概念，而且在实际的生活之中，这些细小的组成部分都可以进行替换。所以这样的设计就属于合成设计模式。