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("张三",33) ;    // 调用构造实例化对象
        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("张三",33) ;    // 调用构造实例化对象
        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("张三",33) ;    // 调用构造实例化对象
        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("张三",33) ;    // 调用构造实例化对象
        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("张三",33) ;    // 调用构造实例化对象
        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@2a139a55
Person类 --> methoud.Person@2a139a55
MAIN方法 --> methoud.Person@15db9742
Person类 --> 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("张三",30) ;    // 声明两个对象，内容完全相等
        Person per2 = new Person("张三",30) ;    // 声明两个对象，内容完全相等
        // 直接在主方法中依次取得各个属性进行比较
        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("张三",30) ;    // 声明两个对象，内容完全相等
        Person per2 = new Person("张三",30) ;    // 声明两个对象，内容完全相等
        // 直接在主方法中依次取得各个属性进行比较
        if(per1.compare(per2)){
            System.out.println("两个对象相等！") ;
        }else{
            System.out.println("两个对象不相等！") ;
        }
    }
};
运行结果：
两个对象相等！

更多往期视频可以到我哔哩哔哩上观看：码邦主2020年最新的Java视频教程

赞 (0)

相关推荐

  • java json格式化的两种方式

    Gson 创建演示所用类 class Person{ private String name; private int age; public Person() {} //java fhadmin.c ...

  • Java基础教程：Java的对象和类

    Java是一种面向对象的编程语言,那什么是对象,什么是类,又怎么使用呢? 什么是对象 客观存在的事物皆为对象,所以我们也常常说万物皆对象.换作Java语言,对象是一种类的实例.相当于现实生活中加一个量 ...

  • 18 this关键字

    18 this关键字 本质 谁调用,代表谁 常用操作 1.调用本类的属性 ​ this.属性名 //例如类中的Set方法 public void setAge(int age){ this.age=a ...

  • 有参构造方法的作用和无参构造方法的作用

    Java无参构造方法的作用 class Person{ private String name ; // 表示人的姓名 private int age ; // 表示人的年龄 public void ...

  • this关键字

    一.this关键字的意义 1.代表当前对象 2.this就是所在函数所属对象的引用,简单来说,哪个对象调用了this所在的函数,this就代表哪个对象 3.如下图,this代表的就是对象p,如右边内存 ...

  • 为什么重写equals方法，还必须要重写hashcode方法

    原因: 1.为了提高效率. 采取重写hashcode方法,先进行hashcode比较,如果不同,那么就没必要在进行equals的比较了,这样就大大减少了equals比较的次数,这对比需要比较的数量很大 ...

  • Java 中的关键字

    Java 中有多少个关键字,有大小写之分吗? Java 中有 48 个关键字在使用 + 两个保留关键字未使用,共 50 个关键字. Java 关键字全部都由是小写组成. Java 中保留关键字分别是哪 ...

  • java中static关键字

    static关键字: 特点: 1.static是一个修饰符,用于修饰成员.(成员变量,成员函数)static修饰的成员变量称之为静态变量或类变量. 2.static修饰的成员被所有的对象共享. 3.s ...

  • 从零开始学Java（十三）Java中this关键字的使用

    ✔上一篇Java零基础系列文章我们说到了Java封装,今天这篇文章的主要目标是带大家

  • java中final关键字的作用

    final关键字可以用于三个地方.用于修饰类.类属性和类方法. 被final关键字修饰的类不能被继承,被final关键字修饰的类属性和类方法不能被覆盖(重写): 对于被final关键字修饰的类属性而言 ...

  • 关于Java中static关键字的用法以及从内存角度解析

    在Java中,static可以用来修饰成员变量和成员方法. 修饰成员变量,称为静态成员方法 修饰静态方法,称为静态成员方法 搞清楚用法和区别之前,先搞清static声明的变量和普通非静态变量在内存的分 ...

  • java中的关键字

    static 静态的 定义在类里面的带有static的变量叫做类变量 ​他不属于类里面的任何一个对象,他属于这个类,可以用: 类名字.该变量 任何一个对象名.该变量 ​来调用改变它,这个变量只有一份, ...

  • Java中this关键字的详解

    在java的学习中,当接触到类这一章的时候,就会避免不了的接触到this关键字. 首先,this关键字指向的是当前对象的引用 作用: this.属性名称 指的是访问类中的成员变量,用来区分成员变量和局 ...

  • Java中static关键字的使用

    static关键字 static表示"静态"的意思,可以用来修饰成员变量和成员方法,static的主要作用在于创建独立于具体对象的域变量或者方法. 简单理解: 被static关键字 ...

  • Java中的关键字——final

    final是Java中的一个关键字,主要表示"最终态,最终的,不可修改"的意思:它可以修饰Java中的类,方法,属性等. 一. final类: 当final修饰Java中的类的时候 ...