第五章:面向对象基础——String类的常用方法。

本章目标

  • 掌握三种引用传递的操作范例
  • 掌握引用传递的作用

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
第五章:面向对象基础——String类的常用方法。_第1张图片

范例二:

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
第五章:面向对象基础——String类的常用方法。_第2张图片

范例三:

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
第五章:面向对象基础——String类的常用方法。_第3张图片

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开发中最重要的部分。希望可以反复理解引用传递的关系,并可以利用引用传递完成一些小的关系模型。

你可能感兴趣的:(第五章:面向对象基础——String类的常用方法。)