wuqiance
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.   
  5.     public Demo(String nameint 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;
  4. public Demo(){
  5. this("微学苑"3);
  6. }
  7. public Demo(String nameint 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);
        }
    }
}
复制代码

分类:

技术点:

相关文章: