关于java语言当中的 this 关键字：
-
1 this是一个关键字，翻译为：这个
-
2 this是一个引用，this是一个变量，this变量中报错了内存地址指向自身
this存储在JVM堆内存java对象内部，当前在哪个对象中，this就是代表当前对象 -
3 创建100个java对象，每一个对象都有this，也就是说有100个不同的this
-
4 this可以出现在“实例方法”当中，指向当前正在执行这个动作的对象。
-
5 this在多数情况下都是可以省略不写的
-
6 this不能使用在带有static的方法当中
-
7 当形参名和实例变量名一样的时候，this就启到了区分的作用。
废话不多说，上代码，看注释才是理解关键
这是一个顾客类 (Customer.class) ，顾客类里有 名字属性、无参数构造方法、购物方法、dosome方法、doOther方法。
public class Customer {
// 姓名【在堆内存的对象内部存储着，所以访问该数据的时候，必须先创建对象，通过引用方式访问】
String name; // 实例变量，必须采用“引用.”的方式访问
// 无参数构造方法
public Customer() {
}
// 因为这是一个不带static关键字的一个方法
// 由于每一个对象执行购物这个动作的时候最终结果不同，所以购物这个动作必须有“对象”的参与
// 重点：没有static关键字的方法被 陈为“实例方法”，实例方法怎么访问？“引用.”
// 重点：没有static关键字的变量称为“实例变量”
// 注意：当一个行为/动作(方法)执行的过程当中是需要对象参与的，那么这个方法一定要定义为“实例方法”，不要带static关键字
// 以下方法定义为实例方法，因为每一个顾客在真正购物的时候，最终的结果是不同的，所以这个动作在完成的时候必须有对象的参与。
public void shopping() {
// 当张三在购物的时候，输出，张三在购物
// 当李四在购物的时候，输出，李四在购物
// 由于name 是一个实例变量，所以这个name访问的时候一定访问的是当前的name
// 所以多数情况下“this.”是可以省略的。
// System.out.println(name+"在购物"); // 这个name就是调用该方法的name
// 完整写法, 因为name是实例变量，所以要用"引用.属性"的方式访问
System.out.println(this.name + "在购物"); // 当使用c1去访问改对象的话，整个过程中出现的this就是c1
// this代表当前正在执行这个行为/动作(方法)的对象，this.name的意思是：这个对象的名字
}
// 带有static的方法
public static void dosSome(){
// 这个执行过程中没有“当前对象”，因为带有static的方法是通过类名的方式访问的
// 或者说这个“上下文”当前没有“当前对象”，自然也不存在this(this代表的是当前正在执行这个动作的对象)
// 以下程序为什么编译错误呢？
// System.out.println(name);
// doSome方法调用不是对象去调用，是一个类名去调用，执行过程中没有“当前对象”
// name是一个实例变量，以下代码的含义是：访问当前对象的name，没有当前对象，自然也不能访问当前对象的name
// static的方法调用不需要对象，直接使用类名，所以执行过程中没有当前对象，所以不能使用this
// System.out.println(this);
}
public static void doOther(){
// 假设想访问name这个实例变量的话应该怎么做？
// 可以采用以下方案，但是以下方案，绝对不是访问的当前对象的name
// 创建对象
Customer c = new Customer();
System.out.println(c.name); // 这里访问的name是c引用指向的对象name
}
}
这是一个顾客测试的类 (CustomerTest.class)
public class CustomerTest {
public static void main(String[] args) {
// 创建This001对象
Customer c1 = new Customer();
// 给c2对象属性赋值
c1.name = "zhangsna";
// c1购物
c1.shopping(); // // 运行结果：zhangsna在购物
// 再创建This001对象
Customer c2 = new Customer();
// 给c2对象属性赋值
c2.name = "lisi";
// c2购物
c2.shopping(); // 运行结果：lisi在购物
// 调用dosome方法(修饰符列表上有static)
// 采用“类名.”的方式访问，显然不需要对象的参加。
Customer.dosSome();
// 调用doOther
Customer.doOther(); // 运行结果：null
// 因为调用doOther的时候，有进行创建对象(实例化)，
// 但是创建对象后没有给对象的name属性赋值，所以系统默认赋值为:null
}
}
顾客测试类的运行结果：
zhangsna在购物
lisi在购物
null
再来一个例子，加深一下印象
public class ThisTest {
// 实例变量(通过"引用.属性"的方式访问)
int num = 10;
// 带有static的方法
// JVM负责调用main方法，JVM是怎么调用的？
// ThisTest.main(String[]);
public static void main(String[] args) {
// 以下代码什么意思？
// 访问“当前对象”的num属性
// System.out.println(num); // 编译报错
// System.out.println(this.num); // 编译报错
// 为什么报错？因为当前没有对象this不存在
// 想访问num怎么办？创建对象，通过"引用.属性"进行访问
ThisTest tt = new ThisTest();
System.out.println(tt.num);
}
}
最终结论
/**
* 最终结论：
* 在带有static的方法当中不能“直接”访问实例变量和实例方法。
* 因为实例变量和实例方法都需要对象的存在。
* 而static的方法当中是没有this的。也就是说当前对象是不存在的。
* 自然也是访问当前对象的实例变量和实例方法
*/
public class ThisTest02 {
public static void main(String[] args) {
// 帶static的方法，而且在本类中调用，可省略“类名.”
// 调用doSome方法，
ThisTest.doSome();
// 调用doSome方法
doSome();
// 调用doOther对象
// 【编译报错】
// ThisTest02.doOthor(); // 实例方法必须先创建对象，通过引用.的方式访问
// doOther是实例方法
// 实例方法调用必须有对象的存在
// 以下代码表示的含义：调用当前对象的doOther方法
// 但是由于main方法中没有this,所以以下方法不能调用.
// doOther(); // 编译报错
// this.doOther(); // 编译报错
ThisTest02 tt = new ThisTest02();
tt.doOther();
tt.run();
}
// 带有static的方法
public static void doSome(){
System.out.println("do some!");
}
// 实例方法
public void doOther(){
// this表示当前对象
System.out.println("do Other!");
}
public void run(){
// 在大客户中的代码执行当中一定是存在“当前对象”的。
// 也就是说这里一定有“this”的。
System.out.println("run execute!");
doOther();
}
}
接下来然我们看看，this关键字什么时候不能省略呢？
用户类 (User.class)
/**
* "this." 什么时候不能省略？
* 用来区分局部变量和实例变量的时候。"this"不能省略.
*/
// 用户类
public class User {
// 属性
private int id; // 实例变量
private String name;
// 构造函数(方法)
// 无参数构造函数
public User(){
}
// 有参数构造函数
public User(int id,String name){
this.id = id;
this.name = name;
}
// 以下程序的id和实例变量id无关，不能采用这种方式
/*
public void setId(int id){
id = id;
}
*/
// getter和setter方法
/*
public void setId(int id){
this.id = id;
}
// 等号前边的this.id 是实例变量id
// 等号后面的id是局部变量id
*/
public int getId() {
return id;
}
public void setName(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
用户测试类 (UserTest.class)
public class UserTest {
public static void main(String[] args) {
// 创建对象，传参数，调用有参构造方法
User u1 = new User(100,"zhangsan"); // this启到了作用
System.out.println(u1.getId()); // this启到了作用
System.out.println(u1.getName()); // this启到了作用
// 想修改名字
u1.setName("lisi");
System.out.println(u1.getName()); // this启到了作用
}
}
运行结果：
100
zhangsan
lisi
this还能用在哪些地方？
日期类(Date.class)
/**
* this还能用在什么地方？
* 1. 可以使用在实例方法当中，代表当前对象【语法格式：this.】
* 2. 可以使用在构造方法当中，通过当前的构造方法调用其他的构造方法【语法格式：this(实参);】
*
* 重点【记忆】：this()这种语法只能出现在构造函数第一行。
*/
public class Date {
// 属性
private int year;
private int month;
private int day;
// 构造函数
// 需求：当程序员调用以下无参数的构造方法的时候，
// 默认创建的日期是：“2000-1-1”
public Date() {
// 代码重复
// this.year = 2000;
// this.month = 1;
// this.day = 1;
// 以上代码可以通过调用另一个构造方法来完成
// 但前提不能创建新的对象，以下代码表示创建一个全新的对象
// new Date();
// 需要采用以下的语法来完成构造方法的调用
// 这种方式不会创建新的java对象，但同时又可以达到调用其他的构造方法
this(2000,1,1);
// this表示当前对象, ()就是调用方法，具体调用哪个方法，根据该对象所属类具有的方法和调用传递的参数有关。
}
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
// getter 和 setter 方法
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 void print(){
System.out.println(this.year+"年"+this.month+"月"+this.day+"日");
}
}
用户测试类(DateTest)
public class DateTest {
public static void main(String[] args) {
// 创建日期对象1
Date time1 = new Date();
time1.print();
// 创建日期对象2
Date time2 = new Date(2000,8,8);
time2.print();
}
}
运行结果：
2000年1月1日
2000年8月8日
综合案例，看懂你就会了~
public class Test{
// 没有static的变量
int i = 10;
// 带static的方法
public static void main(String[] args) {
// 要求在这里编写程序调用method1
// 完成方式调用
Test.method1();
// 省略方式调用
method1();
// 要求在这里编写程序调用method2
// 完成方式调用
Test t1 = new Test();
t1.method2();
// 省略方式调用
}
// 带static的方法
public static void method1(){
// 调用doSome
// 完整方式调用
Test.doSome();
// 省略方式调用
doSome();
// 调用doOther
// 完整方式调用
Test t2 = new Test();
t2.doOther();
// 省略方式调用
// 访问i
// 完整方式访问
System.out.println(t2.i);
// 省略方式访问
}
// 没有static的方法
public void method2(){
// 调用doSome
// 完整方式调用
Test.doSome();
// 省略方式调用
doSome();
// 调用doOther
// 完整方式调用
this.doOther();
// 省略方式调用
doOther();
// 访问i
// 完整方式访问
System.out.println(this.i);
// 省略方式访问
System.out.println(i);
}
// 带有static的方法
public static void doSome(){
System.out.println("do some!");
}
// 没有static的方法
public void doOther(){
System.out.println("do other");
}
}
既然你看了我的博客，还看到了最后。那就给你们来一个一般人不知道的知识点吧，这也许对你以后遇到的问题有所帮助，来吧，ヽ(✿ﾟ▽ﾟ)ノ上菜 ლ(╹◡╹ლ)
/**
* 什么时候程序在运行时会出现空指针异常？
* 空引用访问实例相关的数据，因为实例相关的数据就是对象相关的数据。
* 这些数据在访问的时候，必须有对象的参与，当空引用的时候，对象不存在，
* 访问这些实例数据一定会出现空指针异常。
*
* 实例相关的数据包括：
* 实例变量【对象需要存在】
* 实例方法【对象需要存在】
*/
public class Test1 {
public static void main(String[] args) {
Test.doSome();
doSome();
Test t = new Test();
t.doSome();
// 把引用设为空
t = null;
// 这里不会出现空指针异常！！！
// 带有static的方法，其实可以采用类名的方式访问，也可以采用引用的方式访问
// 但是即使采用引用的方式去访问，实际上指向的生活和引用指向的对象无关。
// 在IDEA中开发的时候，使用引用的方式访问带有static的方法，程序会出现警告。
// 所以带有static的方法还是建议使用“类名.”方式访问
t.doSome();
}
public static void doSome(){
System.out.println("do some!");
}
}