回顾：
- 复习《阿里云【名师课堂】Java面向对象开发3 ~ 6：类与对象》中的引用传递初次分析部分，链接如下：https://www.cnblogs.com/playerone/p/13059971.html。
- 复习《阿里云【名师课堂】Java面向对象开发38：引用传递进阶分析》，链接如下：https://www.cnblogs.com/playerone/p/13083931.html。
正是因为有了引用传递，才可以更好的表现出现实世界的抽象。
例如，现在描述出这样一种关系：有一个人有一辆汽车或没有汽车。要表示出这个关系，有两个实体：人(Member)、车(Car)。
首先：定义两个简单Java类：Member、Car
class Member{
private String name ;
private int age ;
public Member() {};
public Member(String name,int age){
this.name = name ;
this.age = age ;
}
public String getMemberInfo(){
return "【Member】name = " + this.name + ",age = " + this.age;
}
}
class Car{
private String name ;
private double price ;
public Car() {};
public Car(String name,double price){
this.name = name ;
this.price = price ;
}
public String getCarInfo(){
return "【Car】name = " + this.name + ",price = " + this.price;
}
}
那么问题来了，既然是人(Member)拥有车(Car)，那么在人(Member)类里就应该可以描述车(Car)的概念，车(Car)类里也要可以描述人(Member)的概念。
改进：类中体现关系、对象间的引用
class Member{
private String name ;
private int age ;
private Car car ; // 如果car == null，表示没有车
public Member() {};
public Member(String name,int age){
this.name = name ;
this.age = age ;
}
public void setCar(Car car){ // 很明显，创建人之后才能创建车
this.car = car ;
}
public Car getCar(){ // 注意car的返回值类型是自定义的Car类型
return this.car ;
}
public String getMemberInfo(){ // 这样写（getMemberInfo()）方便理解
return "【Member】name = " + this.name + ",age = " + this.age;
}
}
class Car{
private String name ;
private double price ;
private Member member ;
public Car() {};
public Car(String name,double price){
this.name = name ;
this.price = price ;
}
public void setMember(Member member){ // 先创建人后才能创建车
this.member = member ;
}
public Member getMember(){ // 注意car的返回值类型是自定义的Car类型
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("Dexter",28) ;
Car car = new Car("aodi",750000.0) ; // Dexter的车
// 2、设置对象间的引用关系
mem.setCar(car) ; // 一个人有一辆车
car.setMember(mem) ; // 一辆车属于一个人
// 第二步：根据关系取出数据
// 3、通过人找到车
System.out.println(mem.getMemberInfo()) ; // 找到人的信息
System.out.println(mem.getCar().getCarInfo()) ; // 注意：getCar()的返回值是Car
// 4、通过车找到人
System.out.println(car.getCarInfo()) ; // 找到车的信息
System.out.println(car.getMember().getMemberInfo()) ; // 注意：getMember()的返回值是Member
}
}
继续改进：在类中新建属性
那么如果要继续设计，比如：人会有后代，后代也会有自己的车，这是有两种方法：
- 建立一个儿子类，孙子类，····。这样虽然可以实现，但是繁琐且无意义，因为这样会代表孩子和你不同，而实际上孩子和你都是
人(Member)类，是可以在同一类中定义，只是属性不同罢了。 - 因此正确的做法是：在Member()类中建立一个新的属性用来描述孩子，而孩子的类型还是Member。
class Member{
private String name ;
private int age ;
private Member child ;
private Car car ; // 如果car == null，表示没有车
public Member() {};
public Member(String name,int age){
this.name = name ;
this.age = age ;
}
public void setChild(Member child){ // 很明显，创建人之后他才有孩子
this.child = child ;
}
public Member getChild(){ // 通过人找到孩子，注意返回值类型Member
return this.child ;
}
public void setCar(Car car){ // 人和他的孩子的车都是最后创建
this.car = car ;
}
public Car getCar(){ // 注意car的返回值类型是自定义的Car类型
return this.car ;
}
public String getMemberInfo(){ // 这样写（getMemberInfo()）方便理解
return "【Member】name = " + this.name + ",age = " + this.age;
}
}
class Car{
private String name ;
private double price ;
private Member member ;
public Car() {};
public Car(String name,double price){
this.name = name ;
this.price = price ;
}
public void setMember(Member member){ // 先创建人后才能创建车
this.member = member ;
}
public Member getMember(){ // 注意car的返回值类型是自定义的Car类型
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("Dexter",28) ;
Car car = new Car("aodi",750000.0) ; // Dexter的车
Member chd = new Member("Tsukishima",4) ; // Dexter的孩子、
Car carc = new Car("toycar",200.0) ; // 孩子的车
// 2、设置对象间的引用关系
mem.setCar(car) ; // 一个人有一辆车
mem.setChild(chd) ; // 一个人有一个孩子
chd.setCar(carc) ; // 孩子有一辆车
car.setMember(mem) ; // 一辆车属于一个人
// 第二步：根据关系取出数据
// 3、通过人找到车
System.out.println(mem.getMemberInfo()) ; // 找到人的信息
System.out.println(mem.getCar().getCarInfo()) ; // 注意：getCar()的返回值是Car
// 4、通过车找到人
System.out.println(car.getCarInfo()) ; // 找到车的信息
System.out.println(car.getMember().getMemberInfo()) ; // 注意：getMember()的返回值是Member
// 5、通过人找到孩子
System.out.println(mem.getChild().getMemberInfo()) ; // 找到孩子的信息
//6、通过人找到他的孩子的车 ，代码链的形式
System.out.println(mem.getChild().getCar().getCarInfo()) ; // 注意：getCar()的返回值是Car
}
}
还可以扩展
实际上，这个程序还可以进行扩展，例如：一台电脑由显示器、主机、硬盘、键盘、鼠标、CPU、主板、内存所组成，那么这样的关系如何表示？
class Computer{
private Monitor 对象 ;
private Host 对象 ;
private HardDisk 对象 ;
private Mouse 对象 ;
private MotherBoard 对象 ;
private CPU 对象 ;
private RAM 对象 ;
}
class Monitor{
}
class Host{
private MotherBoard [] 对象 ;
}
class HardDisk{
}
class KeyBoard{
}
class Mouse{
}
class MotherBoard{ // 零件很多，通过对象数组的方法
private CPU [] 对象 ;
private RAM [] 对象 ;
private HardDisk [] 对象 ;
}
class CPU{
}
class RAM{
}
只有将这些细小的类合并在一起，才能描述出一个完整的概念。而且在实际生活中吧，这些细小的组成部分都可以进行替代、更换。这个模式称为合成设计模式。
以后的开发过程中，使用到的类一般都是开发者自己定义的，这个过程充满了引用传递操作。