深⼊理解java中this关键字的使⽤
⼀，表⽰类中属性1，没有使⽤this的情况
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(\"张三\调⽤构造实例化对象 System.out.println(per1.getInfo()) ; // 取得信息 }};
运⾏结果：
姓名：null,年龄：0；
可以得出结论：此时并没有正确将内容赋给属性；
假设⾝边有⼀只笔，远处也有⼀只笔，肯定会就近拿⾝边的笔。这在构造⽅法中⼀样。所以此时操作的name,age都是构造⽅法中定义的name,age.跟类中属性完全不沾边。此时，为了明确哪个是类中的属性，需要加上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(\"张三\调⽤构造实例化对象 System.out.println(per1.getInfo()) ; // 取得信息 }};
运⾏结果：
姓名：张三，年龄：33⼆，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(\"张三\调⽤构造实例化对象 System.out.println(per1.getInfo()) ; // 取得信息 }};
因为以上红⾊部分重复了，现在只是⼀⾏，感觉不出来，但是如果现在代码很多⾏的话，缺陷⽴刻显现出来了。此时，最好让构造⽅法间进⾏互相调⽤。使⽤：this(若⼲参数)的形式完成。
package methoud;
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 ThisDemo06{
public static void main(String args[]){
Person per1 = new Person(\"张三\调⽤构造实例化对象 System.out.println(per1.getInfo()) ; // 取得信息 }};
运⾏结果：
新对象实例化
姓名：张三，年龄：33注意点：
在使⽤this关键字调⽤其他关键字的时候，有以下：
1）this()调⽤其他构造⽅法的语句只能放在构造⽅法（在其他普通⽅法⾥是不⾏的）的⾸⾏；
2）在使⽤this调⽤其他构造⽅法的时候，⾄少有⼀个构造⽅法是不⽤this调⽤的。（必须要有结尾，不能⽆限期的调⽤下去，循环递归调⽤）；如下就会出错：
package methoud;
class Person{ // 定义Person类 private String name ; // 姓名 private int age ; // 年龄 public Person(){ // ⽆参构造
System.out.println(\"新对象实例化\") ; }
public Person(String name){
this.name = name ;
this() ;// 调⽤this()⽅法只能放在构造⽅法⾸⾏ }
public Person(String name,int age){ // 通过构造⽅法赋值 this(name) ;// 调⽤有⼀个参数的构造⽅法 this.age = age ;// 为类中的age属性赋值 }
public String getInfo(){ // 取得信息的⽅法 this() ;// 其他普通⽅法不能调⽤this()⽅法 return \"姓名：\" + name + \"，年龄：\" + age ; }};
public class ThisDemo04{
public static void main(String args[]){
Person per1 = new Person(\"张三\调⽤构造实例化对象 System.out.println(per1.getInfo()) ; // 取得信息 }};
三，使⽤this关键字调⽤当前对象。当前对象：当前正在调⽤⽅法的对象。如下，分别⽤两种⽅法打印对象per1和per2
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 }};
运⾏结果：
MAIN⽅法 --> methoud.Person@2a139a55Person类 --> methoud.Person@2a139a55MAIN⽅法 --> methoud.Person@15db9742Person类 --> methoud.Person@15db9742可见，⽤this调⽤的是当前对象，与直接per1,per2是⼀样的效果。四，对象的⽐较
以下这个例⼦中，⽣成两个对象，当对象中年龄和姓名完全相等的时候，则认为两个对象是相等的，此时有两个问题1）如何进⾏对象⽐较：2）在那块对象⽐较：
String本⾝是⼀个类，如果要进⾏相等⽐较，需要使⽤equls()，⽽，age是Int,直接使⽤==判断。
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(\"张三\声明两个对象，内容完全相等 Person per2 = new Person(\"张三\声明两个对象，内容完全相等 // 直接在主⽅法中依次取得各个属性进⾏⽐较
if(per1.getName().equals(per2.getName())&&per1.getAge()==per2.getAge()){ System.out.println(\"两个对象相等！\") ; }else{
System.out.println(\"两个对象不相等！\") ; } }};
运⾏结果：两个对象相等！
以上代码，功能确实实现了，但是由于代码暴露在外⾯，不安全，容易出错。应该由⾃⼰进⾏⽐较最合适，所以应该在Person类中增加⼀个⽐较的⽅法。当前对象调⽤传⼈的对象，当前对象即调⽤⽅法的对象，⽤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(\"张三\声明两个对象，内容完全相等 Person per2 = new Person(\"张三\声明两个对象，内容完全相等 // 直接在主⽅法中依次取得各个属性进⾏⽐较 if(per1.compare(per2)){
System.out.println(\"两个对象相等！\") ; }else{
System.out.println(\"两个对象不相等！\") ; } }};
运⾏结果：两个对象相等！
以上就是⼩编整理的全部内容啦，希望⼤家继续⽀持~
