Java中this关键字在构造方法中的使用

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);
9. }
11. public static void main(String[] args) {
12. Demo obj = new Demo();
13. obj.sum();
14. }
15. }

运行结果：
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.     }
18. }

形参的作用域是整个方法体，是局部变量。在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;
5. public Demo(){
6. this("微学苑", 3);
7. }
9. public Demo(String name, int age){
10. this.name = name;
11. this.age = age;
12. }
14. public void say(){
15. System.out.println("网站的名字是" + name + "，已经成立了" + age + "年");
16. }
18. public static void main(String[] args) {
19. Demo obj = new Demo();
20. obj.say();
21. }
22. }

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

值得注意的是：

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

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

作为参数传递

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

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

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