Java学习笔记----this关键字

在java中this关键字可以完成三件事情：调用本类属性，调用本类方法，表示当前对象

1.调用本类属性

        在一个类的定义的方法中可以直接访问类中的属性，但很多时候会出现方法参数名称和属性名称重复的情况，此时需要使用this.属性的形式指明要调用类中的属性而不是方法的参数

例.观察程序问题

class Book{    private String title;    private double price;    public Book(String title,double price){        title = title;         //原本的目的是希望将构造方法中的title变量内容设置给title属性        price = price;    }    //setter、getter属性略    public String getInfo(){        return "书名：" + title + "; 价格:" + price;    }}public class TestDemo{    public static void main(String args[]){        Book book = new Book("Java开发",89.2);        System.out.println(book.getInfo());    }}

书名：null; 价格：0.0

上述程序在Book类中直接定义一个构造方法，目的是通过构造方法为title和price两个属性进行赋值，但最终没有成功赋值，这是由于java中的变量使用具备“就近取用”的原则

在这种情况下为了可以明确的找到要访问的变量属于类中的属性，需要在变量前加上this

例.使用this关键字明确表示访问类中的属性

class Book{    private String title;    private double price;    public Book(String title,double price){        this.title = title;         //原本的目的是希望将构造方法中的title变量内容设置给title属性        this.price = price;    }    //setter、getter属性略    public String getInfo(){        return "书名：" + title + "; 价格:" + price;    }}public class TestDemo{    public static void main(String args[]){        Book book = new Book("Java开发",89.2);        System.out.println(book.getInfo());    }}

书名：Java开发;价格：89.2

本程序由于构造方法中访问属性时增加了this关键字，所以可以在变量名称相同的情况下，明确的区分属性或参数

2.调用本类方法

class Book{    private String title;    private double price;    public Book(String title,double price){        this.title = title;         //原本的目的是希望将构造方法中的title变量内容设置给title属性        this.price = price;    }    public void print(){        System.out.println("www.yootk.com");    }    //setter、getter属性略    public String getInfo(){        this.print();      //调用本类方法        return "书名：" + title + "; 价格:" + price;    }}public class TestDemo{    public static void main(String args[]){        Book book = new Book("Java开发",89.2);        System.out.println(book.getInfo());    }}

www.yootk.com书名：Java开发; 价格:89.2

注：虽然可以直接访问本类方法，但是this.方法()是非常标准的，习惯上都会使用this调用本类属性或本类方法

例.观察程序问题

class Book{    private String title;    private double price;    public Book(){        System.out.println("一个新的Book类对象产生");   //假设这句话代表50行代码    }    public Book(String title){        System.out.println("一个新的Book类对象产生");   //假设这句话代表50行代码        this.title = title;    }    public Book(String title,double price){        System.out.println("一个新的Book类对象产生");   //假设这句话代表50行代码        this.title = title;        this.price = price;    }    //setter、getterl略    public String getInfo(){        return "书名：" + title + "；价格：" + price;    }}public class TestDemo{    public static void main(String args[]){        Book book = new Book("Java开发",89.2);        System.out.println(book.getInfo());    }}

一个新的Book类对象产生书名：Java开发；价格：89.2

对本程序的三个方法，每一个构造方法都会出现相应的信息提示，此时调用任何一个构造方法，都可以完成指定的信息输出，同时，可能会造成程序中出现大量的重复代码，此时可以用this（）来完成

例.消除构造方法中的重复代码

class Book{    private String title;    private double price;    public Book(){        System.out.println("一个新的Book类对象产生");   //假设这句话代表50行代码    }    public Book(String title){        this();                                       //调用本类无参构造方法        this.title = title;    }    public Book(String title,double price){        this(title);                                  //调用本类有一个参数的构造方法        this.price = price;    }    //setter、getterl略    public String getInfo(){        return "书名：" + title + "；价格：" + price;    }}public class TestDemo{    public static void main(String args[]){        Book book = new Book("Java开发",89.2);        System.out.println(book.getInfo());    }}

一个新的Book类对象产生书名：Java开发；价格：89.2

注：关于this调用构造的限制

• 使用this（）调用构造方法形式的代码只能放在构造方法的首行
• 进行构造方法互相调用时，一定要保留调用的出口

对于第二个限制，观察以下代码：

class Book{    private String title;    private double price;    public Book(){        this("Hello",1.1);                             //调用双参构造        System.out.println("一个新的Book类对象产生");   //假设这句话代表50行代码    }    public Book(String title){        this();                                       //调用本类无参构造方法        this.title = title;    }    public Book(String title,double price){        this(title);                                  //调用本类有一个参数的构造方法        this.price = price;    }    //setter、getterl略    public String getInfo(){        return "书名：" + title + "；价格：" + price;    }}public class TestDemo{    public static void main(String args[]){        Book book = new Book("Java开发",89.2);        System.out.println(book.getInfo());    }}

此时的调用语句满足第一个限制，但是此时会形成一个构造方法的死循环状态，编译时会出现“构造方法递归调用”，因此，this（）调用构造方法时，必须要留有出口

例.定义一个雇员类（编号、姓名、工资、部门），提供四个构造方法

• 无参构造：编号为0，姓名为无名氏，工资为0.0，部门设置为未定；
• 单参构造（传递编号）：姓名为临时工，工资为800.0，部门为后勤；
• 双参构造（传递编号、姓名）：工资为2000.0，部门为技术部门；
• 四参构造

方法一：按照传统的风格实现

class Emp{    private int empno;    private String ename;    private double sal;    private String dept;    public Emp(){           //无参构造        this.empno = 0;        this.ename = "无名氏";        this.sal = 0.0;        this.dept = "未定";    }    public Emp(int empno){  //单参构造        this.empno = empno;        this.ename = "临时工";        this.sal = 800.0;        this.dept = "后勤部";    }    public Emp(int empno,String ename){  //双参构造        this.empno = empno;        this.ename = ename;        this.sal = 2000.0;        this.dept = "技术部";    }    public Emp(int empno,String ename,double sal,String dept){  //四参构造        this.empno = empno;        this.ename = ename;        this.sal = sal;        this.dept = dept;    }    public String getInfo(){        return "雇员编号：" + this.empno + ". 姓名：" + this.ename + ". 工资：" + this.sal +         ". 部门：" + this.dept;    }    //setter、getter略}public class TestDemo{    public static void main(String args[]){        Emp ea = new Emp();        Emp eb = new Emp(7396);        Emp ec = new Emp(7566,"ALLEN");        Emp ed = new Emp(7839,"KING",5000.0,"财务部");        System.out.println(ea.getInfo());        System.out.println(eb.getInfo());        System.out.println(ec.getInfo());        System.out.println(ed.getInfo());    }}

雇员编号：0. 姓名：无名氏. 工资：0.0. 部门：未定雇员编号：7396. 姓名：临时工. 工资：800.0. 部门：后勤部雇员编号：7566. 姓名：ALLEN. 工资：2000.0. 部门：技术部雇员编号：7839. 姓名：KING. 工资：5000.0. 部门：财务部

本程序可以满足开发的要求，但是可以发现程序中存在重复的代码

方法二：利用构造方法互相调用简化代码

class Emp{    private int empno;    private String ename;    private double sal;    private String dept;    public Emp(){                   this(0,"无名氏",0.0,"未定");           //调用四参构造    }    public Emp(int empno){  //单参构造        this(empno,"临时工",800.0,"后勤");     //调用四参构造    }    public Emp(int empno,String ename){          this(empno,ename,2000.0,"技术部");    //调用四参构造    }    public Emp(int empno,String ename,double sal,String dept){  //四参构造        this.empno = empno;        this.ename = ename;        this.sal = sal;        this.dept = dept;    }    public String getInfo(){        return "雇员编号：" + this.empno + ". 姓名：" + this.ename + ". 工资：" + this.sal +         ". 部门：" + this.dept;    }    //setter、getter略}public class TestDemo{    public static void main(String args[]){        Emp ea = new Emp();        Emp eb = new Emp(7396);        Emp ec = new Emp(7566,"ALLEN");        Emp ed = new Emp(7839,"KING",5000.0,"财务部");        System.out.println(ea.getInfo());        System.out.println(eb.getInfo());        System.out.println(ec.getInfo());        System.out.println(ed.getInfo());    }}

利用this（）语法的形式，很好的解决了构造方法中代码重复的问题

3.表示当前对象

注：this关键字在应用的过程中最重要的概念：当前对象，而所谓的当前对象指的就是当前正在调用类中方法的实例化对象

例.直接输出对象

class Book{    public void print(){  //调用print()方法的对象就是当前对象，this则自动与此对象指向同一块内存地址        System.out.println("this = " + this);  //this就是当前调用方法的对象    }}public class TestDemo{    public static void main(String args[]){        Book booka = new Book();                 //实例化新的Book类对象        booka.print();                           //调用Book类的print()方法输出，此时booka为当前对象        System.out.println("-------------------------");        Book bookb = new Book();                 //实例化新的Book类对象        System.out.println("bookb = " + bookb);  //主方法中输出Book类对象        bookb.print();                           //调用Book类的print()方法输出，此时bookb为当前对象    }}

this = Book@762efe5d-------------------------bookb = Book@71dac704this = Book@71dac704

本例首先实例化了两个Book类对象，然后在主方法中直接进行对象信息的输出。结果可见，每个对象都有一个独立的对象编码，在使用不同的额对象调用print（）方法时，this的引用同样会发生变化，即this为当前对象