java-this关键字详解

Posted 2022-12-06 wuqiance

Java this关键字详解

 

this 关键字用来表示当前对象本身，或当前类的一个实例，通过 this 可以调用本对象的所有方法和属性。例如：

1. public class Demo
2. public int x = 10;
3. public int y = 15;
5. public void sum()
6. // 通过 this 点取成员变量
7. int z = this.x + this.y;
8. System.out.println("x + y = " + z);
11. public static void main(String[] args) 
12. Demo obj = new Demo();
13. obj.sum();

运行结果：
x + y = 25

上面的程序中，obj 是 Demo 类的一个实例，this 与 obj 等价，执行 int z = this.x + this.y;，就相当于执行 int z = obj.x + obj.y;。

注意：this 只有在类实例化后才有意义。

使用this区分同名变量

成员变量与方法内部的变量重名时，希望在方法内部调用成员变量，怎么办呢？这时候只能使用this，例如：

1. public class Demo
2.     public String name;
3.     public int age;
4.   
5.     public Demo(String name, int age)
6.         this.name = name;
7.         this.age = age;
8.     
9.   
10.     public void say()
11.         System.out.println("网站的名字是" + name + "，已经成立了" + age + "年");
12.     
13.   
14.     public static void main(String[] args) 
15.         Demo obj = new Demo("微学苑", 3);
16.         obj.say();
17.     

形参的作用域是整个方法体，是局部变量。在Demo()中，形参和成员变量重名，如果不使用this，访问到的就是局部变量name和age，而不是成员变量。在 say() 中，我们没有使用 this，因为成员变量的作用域是整个实例，当然也可以加上 this：

1. public void say()
2. System.out.println("网站的名字是" + this.name + "，已经成立了" + this.age + "年");

Java 默认将所有成员变量和成员方法与 this 关联在一起，因此使用 this 在某些情况下是多余的。

作为方法名来初始化对象

也就是相当于调用本类的其它构造方法，它必须作为构造方法的第一句。示例如下：

1. public class Demo
2. public String name;
3. public int age;
5. public Demo()
6. this("微学苑", 3);
9. public Demo(String name, int age)
10. this.name = name;
11. this.age = age;
14. public void say()
15. System.out.println("网站的名字是" + name + "，已经成立了" + age + "年");
18. public static void main(String[] args) 
19. Demo obj = new Demo();
20. obj.say();

运行结果：
网站的名字是微学苑，已经成立了3年

值得注意的是：

• 在构造方法中调用另一个构造方法，调用动作必须置于最起始的位置。
• 不能在构造方法以外的任何方法内调用构造方法。
• 在一个构造方法内只能调用一个构造方法。

上述代码涉及到方法重载，即Java允许出现多个同名方法，只要参数不同就可以。后续章节会讲解。

作为参数传递

需要在某些完全分离的类中调用一个方法，并将当前对象的一个引用作为参数传递时。例如：

1. public class Demo
2. public static void main(String[] args)
3. B b = new B(new A());
7. class A
8. public A()
9. new B(this).print(); // 匿名对象
11. public void print()
12. System.out.println("Hello from A!");
16. class B
17. A a;
18. public B(A a)
19. this.a = a;
21. public void print() 
22. a.print();
23. System.out.println("Hello from B!");

1. Java中this关键字代表对象本身。用this关键字可以在类的内部调用属性和方法，这样代码的可读性比较高，因为它明确的指出了这个属性或方法的来源。

2. 同时在构造函数中也可以使用this关键字调用本类中的其它构造函数，但有几点需要注意：

• 构造函数调用其它构造函数，需要将this写在构造函数的第一行。
• 构造函数不可递归，防止死循环。

3. 一个类的构造函数分为无参和有参构造函数。通常做法是指定写好一个包含所有字段的构造函数，然后其它构造函数可以直接调用该函数，实现代码重用。

package org.lyk.entities;

public class Emp implements Comparable<Emp>

    private long empno;
    private String ename;
    private String job; 
    private float sal;
    
    
    public long getEmpno()
    
        return empno;
    
    public void setEmpno(long empno)
    
        this.empno = empno;
    
    public String getEname()
    
        return ename;
    
    public void setEname(String ename)
    
        this.ename = ename;
    
    public String getJob()
    
        return job;
    
    public void setJob(String job)
    
        this.job = job;
    
    public float getSal()
    
        return sal;
    
    public void setSal(float sal)
    
        this.sal = sal;
    
    
    
    @Override
    public String toString()
    
        return "Emp [empno=" + empno + ", ename=" + ename + ", job=" + job + ", sal=" + sal + "]";
    
    public Emp()
    
        this(-1, "无名氏", "未指定", 0);
    
    public Emp(long empno)
    
        this(empno,"无名氏","未指定",0);
    
    public Emp(long empno, String name)
    
        this(empno, name, "未指定", 0);
    
    
    public Emp(long empno, String ename, String job, float sal)
    
        super();
        this.empno = empno;
        this.ename = ename;
        this.job = job;
        this.sal = sal;
    
    @Override
    public int compareTo(Emp o)
    
        if(this.sal < o.sal)
            return -1;
        else if(this.sal > o.sal)
            return 1;
        
        if(this.empno < o.empno)
            return -1;
        else if(this.empno > o.empno)
            return 1; 
        
        return 0;
    
    
    
    

 

package org.lyk.main;

import org.lyk.entities.Emp;

public class Main
 
    public static void main(String[] args)
    
        Emp[] emp = new Emp[4];
        
        emp[0] = new Emp();
        emp[1] = new Emp(9989);
        emp[2] = new Emp(9987,"Jerry");
        emp[3] = new Emp(7786,"Larry","programer",889);
        
        
        java.util.Arrays.sort(emp);
        for(Emp item : emp)
        
            System.out.println(item);