Java-面向对象（基础篇）--引用传递与基本应用

引用传递与基本应用
一． 引用传递
所谓的引用传递就是指将堆内存的使用权交给多个栈内存空间。
1. 引用实例一
【对象引用传递】

class Demo
{
    int temp=30;
}
public class RefDemo01
{
    public static void main(String[] args){
        Demo d1=new Demo();
        d1.temp=50;
        System.out.println("fun()方法调用之前："+d1.temp);
        fun(d1);
        System.out.println("fun()方法调用之后："+d1.temp);
    }
    public static void fun(Demo d2){
        d2.temp=1000;
    }
}

运行结果为：

fun()方法调用之前：50
fun()方法调用之后：1000

从运行结果可知，在fun方法中接收了Demo类对象d1，并将temp属性的内容进行修改，因为是引用传递，所以最终temp的值是1000，此程序可以通过下图表示：


2. 引用实例二

public class RefDemo02
{
    public static void main(String[] args){
        String str1="hello";
        System.out.println("fun方法调用之前"+str1);
        fun(str1);
        System.out.println("fun方法");
    }
    public static void fun(String str2){
        str2="ZZU";
    }
}

程序运行结果为：

fun方法调用之前：hello
fun方法调用之后：hello

从程序的运行结果发现，虽然此时传递的是一个string类型的对象，但是结果并没有和之前一样发生变化，因为字符串的内容一旦声明是不可改变的，改变的只是其内存的地址的指向。
3. 引用实例三

class Demo{
    String temp="hello";

}
public class RefDemo03
{
    public static void main(String[] args){
        Demo d1=new Demo();
        d1.temp="world";
        System.out.println("fun()方法调用之前："+d1.temp);
        fun(d1);
        System.out.println("fun()方法调用之后："+d1.temp);
    }
    public static void fun(Demo d2){
        d2.temp="ZZU";
    }
}

程序运行结果：

fun()方法调用之前：world
fun()方法调用之后：ZZU

本程序运行之后，发现fun()方法中将属性的内容修改了，本程序与第一个范例相同，因为String是作为Demo类的属性存在的，而在操作时更改的只是Demo类中的属性内容。
二． 接受本类的引用
以上为引用传递的基本形式，实际上在对象引用传递上也存在一个类中接收自己本类对象的实例，而且接收完之后，可以方便地通过此对象直接进行本类中封装属性的访问。
【接收自己的本类】

class Demo
{
    private int temp=30;
    public void fun(Demo d2){
        d2.temp=50;
    }
    public int getTemp(){
        return temp;
    }
    public void setTemp(int t){
        temp=t;
    }
}
public class RefDemo04
{
    public static void main(String[] args){
        Demo d1=new Demo();
        d1.setTemp(50);
        d1.fun(d1);
        System.out.println("temp="+d1.getTemp());
    }
}

运行结果：

temp=50

此种方式的传递在关于对象比较操作时才会使用，其他时候基本上很少使用。
三． 范例-——一对一的关系
一个人有一本书，一本书有一本书。人应该是一个具体的类，书也应该是一个具体的类，在人类中应该存在一个属性表示书，在书的类中应该也有一个属性表示人。

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

以上代码完成了一个基本关系，但是当人有一个孩子，每个孩子有一本书，怎么办？这时不许要新建一个孩子类，因为孩子也是一个人，所以此时，只需修改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.println("从书找到人 --> 书名：" + 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