引用传递实际应用

引用传递可以说是整个java的核心，也正是因为有了引用传递，所以可以更好地表现出现实世界的抽象

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

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

class Member{
	private String name;
	private int age;
	//如果car==null,表示这个人没有车
	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 TestDemo{
	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());//mem调用getCar方法 ,
		//★方法返回Car的类对象,我们使用getCarInfo()
		 //4、通过车找到人
		System.out.println(car.getMember().getMemberInfo());
		//原理同上
	}
}//结果【Member】name=  小强  age= 30
【Car】name=  法拉利 price=  5000000.0
【Member】name=  小强  age= 30

那么如果说现在要进一步设计，我会有后代，后代还会有车。 

这个时候，建议一个孩子类，如果还有孙子，继续建立孙子类

直接在Member类里建议一个新的属性，这个属性描述的是孩子，而孩子的类型就是Member.

观察代码并比较 下面是有孩子的

class Member{
	private String name;
	private int age;
	private Member child;
	//如果car==null,表示这个人没有车
	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 TestDemo{
	public static void main(String args[]) {
		//第一步：根据关系设置相应的数据
		//1、分别创建各自对象的实例
		Member mem=new Member("小强",30);
		Car car=new Car("法拉利",5000000.0);
		Member chd=new Member("张三",8);//你的儿子
		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());//mem调用getCar方法 ,
		//★方法返回Car的类对象,我们使用getCarInfo()
		 //4、通过车找到人
		System.out.println(car.getMember().getMemberInfo());
		//原理同上
		//5、通过人找到他的孩子
		System.out.println(mem.getChild().getMemberInfo());
		//6、通过人找到他的孩子的车，代码链
		System.out.println(mem.getChild().getCar().getCarInfo());
	}
}

//5.6的结果

【Member】name=  张三  age= 8
【Car】name=  马萨拉蒂 price=  3.0

这些关系的配置可以很好的反应现实生活

如果这个程序还想再扩展，实际上也可以更好的描述出实际的组成关系，例如：一台电脑由显示器、主机、键盘、键盘 、内存条、鼠标、cpu、主板、显卡。  

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

只有将这些细小的类合并到一起才能够描述出完整的概念，而在实际生活之中，这些细小的部分都可以进行替换。
所以这样的设计就属于合成设计模式。
以后的项目开发之中，所有用到的类基本上都要求由开发者自行定义。这些里面使用的都是引用传递的概念