Java this关键字详解

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

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

运行结果：
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. public Demo(String name, int age){
5. this.name = name;
6. this.age = age;
7. }
8. public void say(){
9. System.out.println("网站的名字是" + name + "，已经成立了" + age + "年");
10. }
11. public static void main(String[] args) {
12. Demo obj = new Demo("微学苑", 3);
13. obj.say();
14. }
15. }

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

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

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

作为方法名来初始化对象

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

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

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

值得注意的是：

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

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

作为参数传递

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

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

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);
        }
    }
}

原文地址：https://www.cnblogs.com/wuqiance/p/11594004.html