Java中this关键字用法

梦里梦外; 2022-06-12 00:49 273阅读 0赞

一，表示类中属性

1，没有使用this的情况

![复制代码][copycode.gif]

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()) ;    // 取得信息
        }
    };
    运行结果：
    姓名：null,年龄：0；

![复制代码][copycode.gif]

可以得出结论：此时并没有正确将内容赋给属性；

假设身边有一只笔，远处也有一只笔，肯定会就近拿身边的笔。这在构造方法中一样。

所以此时操作的name,age都是构造方法中定义的name,age.跟类中属性完全不沾边。

此时，为了明确哪个是类中的属性，需要加上this.类中属性。

![复制代码][copycode.gif]

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()) ;    // 取得信息
        }
    };
    运行结果：
    姓名：张三，年龄：33

![复制代码][copycode.gif]

## 二，this调用构造方法 ##

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

假设一个类中存在多个构造方法，但无论多少构造方法，都要打造一个“新对象实例化”，此时就有两种做法。

按照最原始方法：

![复制代码][copycode.gif]

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()) ;    // 取得信息
        }
    };

![复制代码][copycode.gif]

因为以上红色部分重复了，现在只是一行，感觉不出来，但是如果现在代码很多行的话，缺陷立刻显现出来了。

此时，最好让构造方法间进行互相调用。

使用：this(若干参数)的形式完成。

![复制代码][copycode.gif]

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("张三",33) ;    // 调用构造实例化对象
            System.out.println(per1.getInfo()) ;    // 取得信息
        }
    };
    运行结果：
    新对象实例化
    姓名：张三，年龄：33

![复制代码][copycode.gif]

注意点：

在使用this关键字调用其他关键字的时候，有以下限制：

1）this()调用其他构造方法的语句只能放在**构造方法（在其他普通方法里是不行的）**的**首行**；

2）在使用this调用其他构造方法的时候，至少有一个构造方法是不用this调用的。（必须要有结尾，不能无限期的调用下去，循环递归调用）；

如下就会出错：

![复制代码][copycode.gif]

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("张三",33) ;    // 调用构造实例化对象
            System.out.println(per1.getInfo()) ;    // 取得信息
        }
    };

![复制代码][copycode.gif]

## 三，使用this关键字调用当前对象。 ##

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

如下，分别用两种方法打印对象per1和per2

![复制代码][copycode.gif]

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@2a139a55  
Person类 --> methoud.Person@2a139a55  
MAIN方法 --> methoud.Person@15db9742  
Person类 --> methoud.Person@15db9742

![复制代码][copycode.gif]

可见，用this调用的是当前对象，与直接per1,per2是一样的效果。

## 四，对象的比较 ##

以下这个例子中，生成两个对象，当对象中年龄和姓名完全相等的时候，则认为两个对象是相等的，此时有两个问题

1）如何进行对象比较：

2）在那块对象比较：

String本身是一个类，如果要进行相等比较，需要使用equls()，而，age是Int,直接使用==判断。

![复制代码][copycode.gif]

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("两个对象不相等！") ;
            }
        }
    };
    运行结果：
    两个对象相等！

![复制代码][copycode.gif]

以上代码，功能确实实现了，但是由于代码暴露在外面，不安全，容易出错。

应该由自己进行比较最合适，所以应该在Person类中增加一个比较的方法。

当前对象调用传人的对象，当前对象即调用方法的对象，用this表示，

这里表示在哪里比较。

如下：

![复制代码][copycode.gif]

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("两个对象不相等！") ;
            }
        }
    };

运行结果：
    两个对象相等！

![复制代码][copycode.gif]  
转载：http://www.cnblogs.com/alsf/p/5515996.html

[copycode.gif]: /images/20220612/e1f710639db64c8782bdcc517b78a1d7.png