Java学习笔记_零基础系列（十三）Java中的this关键字
原创
✔上一篇Java零基础系列文章我们说到了Java封装，今天这篇文章的主要目标是带大家：
- 理解this是什么？
- this能用在哪里，不能用在哪里？
- this什么时候可以省略，什么时候不能省略？
- 怎么通过构造方法调用当前类中其它的构造方法。
1、this关键字
- this是什么？
this是java语言中的一个关键字，它存储在内存的什么地方呢，一起来看一段程序：
public class Customer {
private String name;
public Customer(){
}
public Customer(String _name){
name = _name;
}
public void setName(String _name){
name = _name;
}
public String getName(){
return name;
}
}public class CustomerTest {
public static void main(String[] args) {
Customer jack = new Customer("jack");
Customer rose = new Customer("rose");
}
}以上程序的内存结构图如下所示：
this可以看做一个变量，它是一个引用，存储在Java虚拟机堆内存的对象内部，this这个引用保存了当前对象的内存地址指向自身，任何一个堆内存的java对象都有一个this，也就是说创建100个java对象则分别对应100个this。
通过以上的内存图，可以看出“jack引用”保存的内存地址是0x1111，对应的“this引用”保存的内存地址也是0x1111，所以“jack引用”和“this引用”是可以划等号的。也就是说访问对象的时候jack.name和this.name是一样的，都是访问该引用所指向对象的name属性。\
this指向“当前对象”，也可以说this代表“当前对象”，this可以使用在实例方法中以及构造方法中，语法格式分别为“this.”和“this(..)”。this不能出现在带有static的方法当中。
2、Java this关键字的使用（在实例方法中）
我们来看看this是否可以出现在static的方法当中，请看以下代码以及编译结果：
public class ThisInStaticMethod {
public static void main(String[] args) {
ThisInStaticMethod.method();
}
public static void method(){
System.out.println(this);
}
}
复制代码编译报错，如下图所示：\
通过以上的测试得知this不能出现在static的方法当中，这是为什么呢？
首先static的方法，在调用的时候是不需要创建对象的，直接采用“类名”的方式调用，也就是说static方法执行的过程中是不需要“当前对象”参与的，所以static的方法中不能使用this，因为this代表的就是“当前对象”。\
大家是否还记得在之前的“封装”过程中，曾编写属性相关的set和get方法，set和get方法在声明的时候不允许带static关键字，我们把这样的方法叫做实例方法，说到实例方法，大家肯定想到了实例变量，没错，实例变量和实例方法都是对象相关，必须有对象的存在，然后通过“引用”去访问。\
为什么set和get方法设计为实例方法呢？
那是因为set和get方法操作的是实例变量，“不同的对象”调用get方法最终得到的数据是不同的，例如zhangsan调用getName()方法得到的名字是zhangsan，lisi调用getName()方法得到的名字是lisi，显然get方法是一个对象级别的方法，不能直接采用“类名”调用，必须先创建对象，再通过“引用”去访问。\
this可以出现在实例方法当中，因为实例方法在执行的时候一定是对象去触发的，实例方法一定是对象才能去调用的，而this恰巧又代表“当前对象”，所以“谁”去调用这个实例方法this就是“谁”。测试一下，请看以下代码：
public class Customer {
private String name;
public Customer(){
}
public Customer(String _name){
name = _name;
}
public void setName(String _name){
name = _name;
}
public String getName(){
return name;
}
public void shopping(){
System.out.println("shopping() --> " + this);
}
}public class CustomerTest {
public static void main(String[] args) {
Customer jack = new Customer("jack");
System.out.println("main() ---> " + jack);
jack.shopping();
System.out.println("====================");
Customer rose = new Customer("rose");
System.out.println("main() ---> " + rose);
rose.shopping();
}
}运行结果如下图所示：
以上代码的输出结果具体是什么不重要，重要的是可以看出谁和谁是相等的。运行结果和代码结合起来分析一下this：
通过以上内容的学习得知，this可以使用在实例方法当中，它指向当前正在执行这个动作的对象。\
大家是否还记得实例变量怎么访问？正规的访问方式是采用“引用.”去访问。请看下面的代码：
public class Customer {
private String name;
public Customer(){
}
public Customer(String _name){
name = _name;
}
public void setName(String _name){
name = _name;
}
public String getName(){
return name;
}
public void shopping(){
System.out.println(name + " is shopping!");
}
}public class CustomerTest {
public static void main(String[] args) {
Customer jack = new Customer("jack");
jack.shopping();
Customer rose = new Customer("rose");
rose.shopping();
}
}运行结果如下图所示：
将以上部分代码片段取出来进行分析：
public class Customer {
private String name; //实例变量
...
public void shopping(){
//jack调用shopping，当前对象是jack
//rose调用shopping，当前对象是rose
//name是实例变量，不用“引用”可以访问？（以上结果表示可以）
System.out.println(name + " is shopping!");
//正规的访问方式应该是“引用.name”，比如
//System.out.println(jack.name + " is shopping!");
//或者
//System.out.println(rose.name + " is shopping!");
//对不起，jack和rose在main方法当中，在这里不可见，不能用
//难道是这样？？？
System.out.println(this.name + " is shopping!");
}
}public class CustomerTest {
public static void main(String[] args) {
Customer jack = new Customer("jack");
jack.shopping();
Customer rose = new Customer("rose");
rose.shopping();
}
}把完整的代码拿过来：
public class Customer {
private String name;
public Customer(){
}
public Customer(String _name){
name = _name;
}
public void setName(String _name){
name = _name;
}
public String getName(){
return name;
}
public void shopping(){
System.out.println(name + " is shopping!");
System.out.println(this.name + " is shopping!");
}
}public class CustomerTest {
public static void main(String[] args) {
Customer jack = new Customer("jack");
jack.shopping();
System.out.println("=======================");
Customer rose = new Customer("rose");
rose.shopping();
}
}运行结果如下图所示：
通过以上的测试我们得知：System.out.println(name + " is shopping!")和System.out.println(this.name + " is shopping!")是等效的。
也就是说在shopping()这个“实例方法”当中直接访问“实例变量”name就表示访问当前对象的name。
换句话说在实例方法中可以直接访问当前对象的实例变量，而“this.”是可以省略的。
“this.”什么时候不能省略呢？
请看以下代码：
public class Customer {
private String name;
public Customer(){
}
public Customer(String _name){
name = _name;
}
public void setName(String _name){
name = _name;
}
public String getName(){
return name;
}
public void shopping(){
System.out.println(name + " is shopping!");
}
}你有没有看到name=_name这样的代码很丑陋，怎样可以优雅一些呢？请看：
public class Customer {
private String name;
public Customer(){
}
public Customer(String name){
this.name = name;//这里的“this.”不能省略
}
public void setName(String name){
this.name = name;//这里的“this.”不能省略
}
public String getName(){
return name; //这里的“this.”可以省略
}
public void shopping(){
//这里的“this.”可以省略
System.out.println(name + " is shopping!");
}
}以上代码当中this.name = name，其中this.name表示实例变量name，等号右边的name是局部变量name，此时如果省略“this.”，则变成name = name，这两个name都是局部变量（java遵守就近原则），和实例变量name无关了，显然是不可以省略“this.”的。\
最终的结论是，this不能出现在static的方法中，可以出现在实例方法中，代表当前对象，大部分情况下this都是可以省略的，只有当在实例方法中区分局部变量和实例变量的时候不能省略。\
接下来我们再来扩展一下this的使用，请看代码：
public class Customer {
private String name;
public Customer(){
}
public Customer(String name){
this.name = name;
}
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
//实例方法
public void shopping(){
System.out.println(name + " is shopping!");
System.out.println(name + " 选好商品了！");
//pay()支付方法是实例方法，实例方法需要使用“引用”调用
//那么这个“引用”是谁呢？
//当前对象在购物，肯定是当前对象在支付，所以引用是this
this.pay();
//同样“this.”可以省略
pay();
}
//实例方法
public void pay(){
System.out.println(name + "支付成功！");
}
}public class CustomerTest {
public static void main(String[] args) {
Customer jack = new Customer("jack");
jack.shopping();
System.out.println("=======================");
Customer rose = new Customer("rose");
rose.shopping();
}
}运行结果如下图所示：
通过以上的测试，可以看出在一个实例方法当中可以直接去访问其它的实例方法，方法是对象的一种行为描述，实例方法中直接调用其它的实例方法，就表示“当前对象”完成了一系列行为动作。例如在实例方法shopping()中调用另一个实例方法pay()，这个过程就表示jack在选购商品，选好商品之后，完成支付环节，其中选购商品是一个动作，完成支付是另一个动作。
接下来继续扩展，请看以下代码：
public class ThisTest {
int i = 10;
public static void main(String[] args) {
System.out.println(i);
}
}以上代码编译报错了，请看：\
为什么会编译报错，在main方法中为什么无法直接访问变量i？
我们来分析一下，首先i变量是实例变量，实例变量要想访问必须先创建对象，然后通过“引用”去访问，main方法是static的方法，也就是说main方法是通过“类名”去调用的，在main方法中没有“当前对象”的概念，也就是说main方法中不能使用this，所以编译报错了。
那应该怎么修改呢？请看：
public class ThisTest {
int i = 10;
public static void main(String[] args) {
//这肯定是不行的，因为main方法带有static，不能用this
//System.out.println(this.i);
//可以自己创建一个对象
ThisTest tt = new ThisTest();
//通过引用访问
System.out.println(tt.i);
}
}运行结果如下图所示：
通过以上的测试得知，在static的方法中不能直接访问实例变量，要访问实例变量必须先自己创建一个对象，通过“引用”可以去访问，不能通过this访问，因为在static方法中是不能存在this的。
其实这种设计也是有道理的，因为static的方法在执行的时候是采用“类名”去调用，没有对象的参与，自然也不会存在当前对象，所以static的方法执行过程中不存在this。
那么在static方法中能够直接访问实例方法吗？
请看以下代码：
public class ThisTest {
public static void main(String[] args) {
doSome();
}
public void doSome(){
System.out.println("do some...");
}
}编译报错了，请看下图：
为什么在main方法中无法直接调用实例方法doSome()呢？很简单，因为实例方法必须先创建对象，通过引用去调用，在以上的main方法中并没有创建对象，更没有this。所以在main方法中无法直接访问实例方法。结论就是：在static的方法中不能直接访问实例方法。
怎么修改呢？同样需要先创建对象，请看：
public class ThisTest {
public static void main(String[] args) {
ThisTest tt = new ThisTest();
tt.doSome();
}
public void doSome(){
System.out.println("do some...");
}
}运行结果如下图所示：
综上所述，我们需要记住这样的一个结论：
this不能使用在static的方法中，可以使用在实例方法中，代表当前对象，多数情况下this是可以省略不写的，但是在区分局部变量和实例变量的时候不能省略，在实例方法中可以直接访问当前对象实例变量以及实例方法，在static方法中无法直接访问实例变量和实例方法。
3、Java this关键字的使用（在构造方法中）
this还有另外一种用法，使用在构造方法第一行（只能出现在第一行，这是规定，记住就行），通过当前构造方法调用本类当中其它的构造方法，其目的是为了代码复用。
调用时的语法格式是：this(实际参数列表)，请看以下代码：
public class Date {
private int year;
private int month;
private int day;
//业务要求，默认创建的日期为1970年1月1日
public Date(){
this.year = 1970;
this.month = 1;
this.day = 1;
}
public Date(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
}public class DateTest {
public static void main(String[] args) {
Date d1 = new Date();
System.out.println(d1.getYear() + "年" + d1.getMonth() + "月" + d1.getDay() + "日");
Date d2 = new Date(2008 , 8, 8);
System.out.println(d2.getYear() + "年" + d2.getMonth() + "月" + d2.getDay() + "日");
}
}运行结果如下图所示：
我们来看看以上程序的无参数构造方法和有参数构造方法：
通过上图可以看到无参数构造方法中的代码和有参数构造方法中的代码是一样的，按照以上方式编写，代码没有得到重复使用，这个时候就可以在无参数构造方法中使用“this(实际参数列表);”来调用有参数的构造方法，这样就可以让代码得到复用了，请看：
public class Date {
private int year;
private int month;
private int day;
//业务要求，默认创建的日期为1970年1月1日
public Date(){
this(1970 , 1, 1);
}
public Date(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
}还是使用以上的main方法进行测试，运行结果如下：
在this()上一行尝试添加代码，请看代码以及编译结果：
public class Date {
private int year;
private int month;
private int day;
//业务要求，默认创建的日期为1970年1月1日
public Date(){
System.out.println("...");
this(1970 , 1, 1);
}
public Date(int year,int month,int day){
this.year = year;
this.month = month;
this.day = day;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
}
通过以上测试得出：this()语法只能出现在构造方法第一行，这个大家记住就行了。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
腾讯云开发者
