面向对象基础——引用传递及其应用以及this关键字的使用

小灰灰 2022-07-28 00:22 51阅读 0赞

## 三种引用范例 ##

## `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值 } };`  ![Center][] ##

## ![Center 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" ; // 修改字符串内容 } };`     ![Center 2][] ##

## ![Center 3][] ##

## `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值 } };`     ![Center 4][] ##

## ![Center 5][] ##

## String类比较特殊。 ##

# this关键字的使用 #

this的使用之处：

可以调用本类中的方法。

可以调用本类中的构造方法。

可以使用this表示当前对象。

class Person{		// 定义Person类
    	private String name ;		// 姓名
    	private int age ;			// 年龄
    	public Person(String n,int a){	// 通过构造方法赋值
    		name = n ;
    		age = a ;
    	}
    	public String getInfo(){	// 取得信息的方法
    		return "姓名：" + name + "，年龄：" + age ;
    	}
    };
    public class ThisDemo01{
    	public static void main(String args[]){
    		Person per1 = new Person("张三",33) ;	// 调用构造实例化对象
    		System.out.println(per1.getInfo()) ;	// 取得信息
    	}
    };

![Center 6][]

但是n和a没有任何意义，如果换为name和age呢？

class Person{		// 定义Person类
    	private String name ;		// 姓名
    	private int age ;			// 年龄
    	public Person(String name,int age){	// 通过构造方法赋值
    		name = name ;
    		age = age ;
    	}
    	public String getInfo(){	// 取得信息的方法
    		return "姓名：" + name + "，年龄：" + age ;
    	}
    };
    public class ThisDemo01{
    	public static void main(String args[]){
    		Person per1 = new Person("张三",33) ;	// 调用构造实例化对象
    		System.out.println(per1.getInfo()) ;	// 取得信息
    	}
    };

![Center 7][]

这是由于就近原则，n和a 都是参数中的变量，并不是类中的属性。为了能调用类中的属性，就需要使用this关键字。即 this.属性名称。

class Person{		// 定义Person类
    	private String name ;		// 姓名
    	private int age ;			// 年龄
    	public Person(String name,int age){	// 通过构造方法赋值
    		this.name = name ; // 为类中的name属性赋值
    		this.age = age ;// 为类中的age属性赋值
    	}
    	public String getInfo(){	// 取得信息的方法
    		return "姓名：" + name + "，年龄：" + age ;
    	}
    };
    public class ThisDemo02{
    	public static void main(String args[]){
    		Person per1 = new Person("张三",33) ;	// 调用构造实例化对象
    		System.out.println(per1.getInfo()) ;	// 取得信息
    	}
    };

![Center 8][]

## this调用构造方法 ##

如果一个类中有多个构造方法的话，也可以利用this关键字相互调用。

假设：现在有一个类中存在多个构造方法，但是不管有多少构造方法，最终结果都要打印一句 “新对象实例化”。此时就有以下两种做法：

按照最原始的办法：

class Person{		// 定义Person类
    	private String name ;		// 姓名
    	private int age ;			// 年龄
    	public Person(){	// 无参构造
    		System.out.println("新对象实例化") ;
    	}
    	public Person(String name){
    		System.out.println("新对象实例化") ;
    		this.name = name ;
    	}
    	public Person(String name,int age){	// 通过构造方法赋值
    		System.out.println("新对象实例化") ;
    		this.name = name ; // 为类中的name属性赋值
    		this.age = age ;// 为类中的age属性赋值
    	}
    	public String getInfo(){	// 取得信息的方法
    		return "姓名：" + name + "，年龄：" + age ;
    	}
    };
    public class ThisDemo03{
    	public static void main(String args[]){
    		Person per1 = new Person("张三",33) ;	// 调用构造实例化对象
    		System.out.println(per1.getInfo()) ;	// 取得信息
    	}
    };

![Center 9][]

但是以上代码重复了，现在只是一行，所以感觉不出来，如果现在代码有很多行的话，以上代码的缺陷就体现出来了。此时最好的办法是让构造方法间相互调用，使用this(若干参数)的形式完成。

使用this修改以上代码如下：

class Person{		// 定义Person类
    	private String name ;		// 姓名
    	private int age ;			// 年龄
    	public Person(){	// 无参构造
    		System.out.println("新对象实例化") ;
    	}
    	public Person(String name){
    		this() ;// 调用本类中的无参构造方法
    		this.name = name ;	
    	}
    	public Person(String name,int age){	// 通过构造方法赋值
    		this(name) ;// 调用有一个参数的构造方法
    		this.age = age ;// 为类中的age属性赋值
    	}
    	public String getInfo(){	// 取得信息的方法\
    		return "姓名：" + name + "，年龄：" + age ;
    	}
    };
    public class ThisDemo04{
    	public static void main(String args[]){
    		Person per1 = new Person("张三",33) ;	// 调用构造实例化对象
    		System.out.println(per1.getInfo()) ;	// 取得信息
    	}
    };

![Center 10][]

注意点：在使用this调用其他构造方法的时候，有以下几点限制

this()调用构造方法的语句只能放在构造方法的首行。

不能出现两个构造方法相互调用。

不能在方法里调用构造方法。

class Person{		// 定义Person类
    	private String name ;		// 姓名
    	private int age ;			// 年龄
    	public Person(){	// 无参构造
    		System.out.println("新对象实例化") ;
    	}
    	public Person(String name){
    		this.name = name ;
    		this() ;// 调用本类中的无参构造方法  错误：应该放在首行
    	}
    	public Person(String name,int age){	// 通过构造方法赋值
    		this(name) ;// 调用有一个参数的构造方法
    		this.age = age ;// 为类中的age属性赋值
    	}
    	public String getInfo(){	// 取得信息的方法\
    		this() ;// 调用本类中的无参构造方法   错误：只能在构造方法的首行调用，不能在方法内调用
    		return "姓名：" + name + "，年龄：" + age ;
    	}
    };
    public class ThisDemo04{
    	public static void main(String args[]){
    		Person per1 = new Person("张三",33) ;	// 调用构造实例化对象
    		System.out.println(per1.getInfo()) ;	// 取得信息
    	}
    };

## 使用this表示当前对象 ##

当前对象：当前正在调用方法的对象。

class Person{		// 定义Person类
    	public String getInfo(){	// 取得信息的方法
    		System.out.println("Person类 --> " + this) ; // 直接打印this
    		return null ; // 为了保证语法正确，返回null
    	}
    };
    public class ThisDemo06{
    	public static void main(String args[]){
    		Person per1 = new Person() ;	// 调用构造实例化对象
    		Person per2 = new Person() ;	// 调用构造实例化对象
    		System.out.println("MAIN方法 --> " + per1) ;	// 直接打印对象
    		per1.getInfo() ;	// 当前调用getInfo()方法的对象是per1
    		System.out.println("MAIN方法 --> " + per2) ;	// 直接打印对象
    		per2.getInfo() ;	// 当前调用getInfo()方法的对象是per2
    	}
    };

![Center 11][]

## 对象比较：可以使用this和引用传递比较两个对象是否相等 ##

class Person{		// 定义Person类
    	private String name ;	// 姓名
    	private int age ;		// 年龄
    	public Person(String name,int age){
    		this.setName(name) ;
    		this.setAge(age) ;
    	}
    	public void setName(String name){	// 设置姓名
    		this.name = name ;
    	}
    	public void setAge(int age){		// 设置年龄
    		this.age = age ;
    	}
    	public String getName(){
    		return this.name ;
    	}
    	public int getAge(){
    		return this.age ;
    	}
    };
    public class ThisDemo07{
    	public static void main(String args[]){
    		Person per1 = new Person("张三",30) ;	// 声明两个对象，内容完全相等
    		Person per2 = new Person("张三",30) ;	// 声明两个对象，内容完全相等
    		// 直接在主方法中依次取得各个属性进行比较
    		if(per1.getName().equals(per2.getName())&&per1.getAge()==per2.getAge()){
    			System.out.println("两个对象相等！") ;
    		}else{
    			System.out.println("两个对象不相等！") ;
    		}
    	}
    };

![Center 12][]

## 使用this比较 ##

## `class Person{ // 定义Person类 private String name ; // 姓名 private int age ; // 年龄 public Person(String name,int age){ this.setName(name) ; this.setAge(age) ; } public boolean compare(Person per){ // 调用此方法时里面存在两个对象：当前对象、传入的对象 Person p1 = this ; // 当前的对象，就表示per1 Person p2 = per ; // 传递进来的对象，就表示per2 if(p1==p2){ // 判断是不是同一个对象，用地址比较 return true ; } // 之后分别判断每一个属性是否相等 if(p1.name.equals(p2.name)&&p1.age==p2.age){ return true ; // 两个对象相等 }else{ return false ; // 两个对象不相等 } } public void setName(String name){ // 设置姓名 this.name = name ; } public void setAge(int age){ // 设置年龄 this.age = age ; } public String getName(){ return this.name ; } public int getAge(){ return this.age ; } }; public class ThisDemo08{ public static void main(String args[]){ Person per1 = new Person("张三",30) ; // 声明两个对象，内容完全相等 Person per2 = new Person("张三",30) ; // 声明两个对象，内容完全相等 // 直接在主方法中依次取得各个属性进行比较 if(per1.compare(per2)){ System.out.println("两个对象相等！") ; }else{ System.out.println("两个对象不相等！") ; } } };`  总结： ##

## this.属性、this.方法()，实际上都表示当前的对象的属性或者调用当前对象中的方法。 ##

## this的核心：表示当前对象，当前正在操作本方法的对象称为当前对象。 ##

## 使用this可以调用其他构造方法，但是此时语句必须放在构造方法的首行。          ##

[Center]: /images/20220727/f173905772bb409e88863d9aca4425d2.png
[Center 1]: /images/20220727/cb42a9edbc9d47a1b078de6909088d38.png
[Center 2]: /images/20220727/9fa8b2e515f247c59c89909e6eac06bd.png
[Center 3]: /images/20220727/1978a297f2a04c079d81a747d2dc51a7.png
[Center 4]: /images/20220727/6a4742338b2f4cf38a8dd178d516ebc6.png
[Center 5]: /images/20220727/8f81f27d823d4b56a015de18b877b4e1.png
[Center 6]: /images/20220727/00f320e3701e4541a7d257ecfb34bc84.png
[Center 7]: /images/20220727/5e5e5a7c6a8b4073a8c87485dc53000b.png
[Center 8]: /images/20220727/6514f08563ae422299ab620751713e8b.png
[Center 9]: /images/20220727/06a067e1baa04eeea501b5bf33cc85d3.png
[Center 10]: /images/20220727/51e2b83c6c9a44d4bce0c77a1480c79d.png
[Center 11]: /images/20220727/98f6e71205cd4403afa1d7492844b40e.png
[Center 12]: /images/20220727/464ef1d36f714c68b746155a55f271e5.png