本章目标
- 掌握三种引用传递的操作范例
- 掌握引用传递的作用
1、具体内容
1.1、三道引用传递范例
范例一：
class Demo{
int temp = 30 ; // 此处为了方便，属性暂时不封装
};
public class RefDemo01{
public static void main(String args[]){
Demo d1 = new Demo() ; // 实例化Demo对象，实例化之后里面的temp=30
d1.temp = 50 ; // 修改temp属性的内容
System.out.println("fun()方法调用之前：" + d1.temp) ;
fun(d1) ;
System.out.println("fun()方法调用之后：" + d1.temp) ;
}
public static void fun(Demo d2){ // 此处的方法由主方法直接调用
d2.temp = 1000; // 修改temp值
}
};
输出结果：
fun()方法调用之前：50
fun()方法调用之后：1000
范例二：
public class RefDemo02{
public static void main(String args[]){
String str1 = "hello" ; // 实例化字符串对象
System.out.println("fun()方法调用之前：" + str1) ;
fun(str1) ; // 调用fun()方法
System.out.println("fun()方法调用之后：" + str1) ;
}
public static void fun(String str2){ // 此处的方法由主方法直接调用
str2 = "MLDN" ; // 修改字符串内容
}
};
输出结果：
fun()方法调用之前：hello
fun()方法调用之后：hello
范例三：
class Demo{
String temp = "hello" ; // 此处为了方便，属性暂时不封装
};
public class RefDemo03{
public static void main(String args[]){
Demo d1 = new Demo() ; // 实例化Demo对象，实例化之后里面的temp=30
d1.temp = "world" ; // 修改temp属性的内容
System.out.println("fun()方法调用之前：" + d1.temp) ;
fun(d1) ;
System.out.println("fun()方法调用之后：" + d1.temp) ;
}
public static void fun(Demo d2){ // 此处的方法由主方法直接调用
d2.temp = "MLDN"; // 修改temp值
}
};
输出结果：
fun()方法调用之前：world
fun()方法调用之后：MLDN
1.2、接收本类引用
例如，现在有以下一道程序：
class Demo{ // 定义Demo类
private int temp = 30 ; // 声明temp属性并封装
public void fun(Demo d2){ // 接收本类的引用
d2.temp = 50 ; // 直接通过对象调用本类的私有属性
}
public int getTemp(){ // getter
return temp ;
}
public void setTemp(int t){ // setter
temp = t ;
}
};
public class RefDemo04{
public static void main(String args[]){
Demo d1 = new Demo() ; // 实例化Demo对象
d1.setTemp(50) ; // 只能通过setter方法修改内容
d1.fun(d1) ; // 此处把Demo的对象传回到自己的类中
System.out.println("temp = " + d1.getTemp()) ;
}
};
现在按照引用传递的方式将其传入到其内部，就相当于自己接受自己本类的引用对象。
输出结果：
temp =50
只要是符合了引用传递的语法，则可以向任意的地方传递。
1.3、范例讲解：一对一关系
实际上使用引用传递，可以表述出生活中以下一种场景。例如：一个人有一本书，一本书属于一个人。从这样一句话中可以得出这样的结论：人应该是一个具体的类、书也应该是一个具体的类，在人的类中应该存在一个属性表示书的，在书的类中也应该存在一个属性表示人。
class Person{ // 定义Person类
private String name ; // 姓名
private int age ; // 年龄
private Book book ; // 一个人有一本书
public Person(String name,int age){
this.setName(name) ;
this.setAge(age) ;
}
public void setName(String n){
name = n ;
}
public void setAge(int a){
age = a ;
}
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
public void setBook(Book b){
book = b ;
}
public Book getBook(){
return book ;
}
};
class Book{ // 定义Book类
private String title ; // 标题
private float price ; // 价格
private Person person ; // 一本书属于一个人
public Book(String title,float price){
this.setTitle(title) ;
this.setPrice(price) ;
}
public void setTitle(String t){
title = t ;
}
public void setPrice(float p){
price = p ;
}
public String getTitle(){
return title ;
}
public float getPrice(){
return price ;
}
public void setPerson(Person p){
person = p ;
}
public Person getPerson(){
return person ;
}
};
public class RefDemo05{
public static void main(String arg[]){
Person per = new Person("张三",30) ;
Book bk = new Book("JAVA SE核心开发",90.0f) ;
per.setBook(bk) ; // 设置两个对象间的关系，一个人有一本书
bk.setPerson(per) ; // 设置两个对象间的关系，一本书属于一个人
System.out.println("从人找到书 --> 姓名：" + per.getName()+"；年龄："
+ per.getAge() +"；书名：" + per.getBook().getTitle() + "；价格："
+ per.getBook().getPrice()) ; // 可以通过人找到书
System.out.println("从书找到人 --> 书名：" + bk.getTitle() + "；价格："
+ bk.getPrice() + "；姓名：" + bk.getPerson().getName() + "；年龄："
+ bk.getPerson().getAge()) ; // 也可以通过书找到其所有人
}
};
输出结果：
从人找到书 --> 姓名：张三；年龄：30；书名：JAVA SE核心开发；价格：90.0
从书找到人 --> 书名：JAVA SE核心开发；价格：90.0；姓名：张三；年龄：30
1.3、范例讲解：进一步深入一对一关系
以上已经玩曾了一个基本的关系，但是现在有了一个新的要求：一个人有一个孩子，每个孩子还会有一本书，那么该如何分析呢？难道再单独建立一个孩子类吗？很明显这样做是很不可取的，因为一个孩子也是一个人，所以此时，只需要简单的修改Person类即可，在类中增加一个自己的引用。
class Person{ // 定义Person类
private String name ; // 姓名
private int age ; // 年龄
private Book book ; // 一个人有一本书
private Person child ; // 一个人有一个孩子
public Person(String name,int age){
this.setName(name) ;
this.setAge(age) ;
}
public void setName(String n){
name = n ;
}
public void setAge(int a){
age = a ;
}
public String getName(){
return name ;
}
public int getAge(){
return age ;
}
public void setBook(Book b){
book = b ;
}
public Book getBook(){
return book ;
}
public void setChild(Person c){
child = c ;
}
public Person getChild(){
return child ;
}
};
class Book{ // 定义Book类
private String title ; // 标题
private float price ; // 价格
private Person person ; // 一本书属于一个人
public Book(String title,float price){
this.setTitle(title) ;
this.setPrice(price) ;
}
public void setTitle(String t){
title = t ;
}
public void setPrice(float p){
price = p ;
}
public String getTitle(){
return title ;
}
public float getPrice(){
return price ;
}
public void setPerson(Person p){
person = p ;
}
public Person getPerson(){
return person ;
}
};
public class RefDemo06{
public static void main(String arg[]){
Person per = new Person("张三",30) ;
Person cld = new Person("张四",10) ; // 定义一个孩子
Book bk = new Book("JAVA SE核心开发",90.0f) ;
Book b = new Book("一千零一夜",30.3f) ;
per.setBook(bk) ; // 设置两个对象间的关系，一个人有一本书
bk.setPerson(per) ; // 设置两个对象间的关系，一本书属于一个人
cld.setBook(b) ; // 设置对象间的关系，一个孩子有一本书
b.setPerson(cld) ; // 设置对象间的关系，一本书属于一个孩子
per.setChild(cld) ; // 设置对象间的关系，一个人有一个孩子
System.out.println("从人找到书 --> 姓名：" + per.getName()+"；年龄："
+ per.getAge() +"；书名：" + per.getBook().getTitle() + "；价格："
+ per.getBook().getPrice()) ; // 可以通过人找到书
System.out.printl("从书找到人 --> 书名：" + bk.getTitle() + "；价格："
+ bk.getPrice() + "；姓名：" + bk.getPerson().getName() + "；年龄："
+ bk.getPerson().getAge()) ; // 也可以通过书找到其所有人
// 通过人找到孩子，并找到孩子所拥有的书
System.out.println(per.getName() + "的孩子 --> 姓名："
+ per.getChild().getName() + "；年龄：" + per.getChild().getAge()
+ "；书名：" + per.getChild().getBook().getTitle() + "；价格："
+ per.getChild().getBook().getPrice()) ;
}
};
输出结果：
从人找到书 -->姓名：张三；年龄：30；书名：JAVA SE核心开发；价格：90.0
从书找到人 -->书名：JAVA SE核心开发；价格：90.0；姓名：张三；年龄：30
张三的孩子 -->姓名：张四；年龄：10；书名：一千零一夜；价格：30.3
2、总结
以上所用应用范例，到现在为止，只是在完成一些细小的模型，但是这些模型都将成为日后Java EE开发中最重要的部分。希望可以反复理解引用传递的关系，并可以利用引用传递完成一些小的关系模型。
