JAVA基础（this关键字）

this关键字：

1.this调用类中属性

package 类与对象;
class Person{
    private String name;
    private int age;
    //使用this，构造方法中参数名与属性名相同
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getInfo()
    {
       //此处返回姓名和年龄可以不加this
        return "姓名："+this.name+" 年龄："+this.age;
    }
}
public class ThisDemo {
    public static void main(String[] args) {
        Person p = new Person("aaa",10);
        System.out.println(p.getInfo());
    }
}

2.this调用类中方法
（1）调用普通方法

package 类与对象;
class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        this.name=name;
        this.age=age;
        this.Print();//this调用普通方法,可以放在任意位置，此处this可以省略
    }
    public String getInfo()
    {
        return "姓名："+name+" 年龄："+age;
    }
    public void Print()
    {
        System.out.println("this调用Print()普通方法");
    }
}
public class ThisDemo {
    public static void main(String[] args) {
        Person p = new Person("aaa",10);
        System.out.println(p.getInfo());
    }
}

（2）调用构造方法

package 类与对象;
class Person{
    private String name;
    private int age;
    //在使用this()进行构造方法之间互相调用时，要保留方法的出口--->即至少一个构造函数中没有this()调用其他构造方法出现
    //此处的无参构造就是“出口”!!!
    public Person()
    {
        System.out.println("构造方法初始化对象！");
    }
    public Person(String name)
    {
        this();//调用上述无参构造，且只能放在此构造函数的首行
        this.name=name;
    }
    public Person(String name,int age){
        this(name);//调用上述单参构造，且只能放在此构造函数的首行
        this.age=age;
    }
    public String getInfo()
    {
        return "姓名："+name+" 年龄："+age;
    }
}
public class ThisDemo {
    public static void main(String[] args) {
        Person p = new Person();
        Person p1 = new Person("bbb");
        Person p2 = new Person("aaa",10);
        System.out.println(p.getInfo());
        System.out.println(p1.getInfo());
        System.out.println(p2.getInfo());
    }
}

package 类与对象;
class Person{
    private String name;
    private int age;

    public Person()
    {
        this("无名氏",0);
    }
    public Person(String name)
    {
        this(name,10);
    }
    //此处构造方法为“出口”，不含有this()调用其他构造方法
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getInfo()
    {
        return "姓名："+name+" 年龄："+age;
    }
}
public class ThisDemo {
    public static void main(String[] args) {
        Person p = new Person();
        Person p1 = new Person("bbb");
        Person p2 = new Person("aaa",20);
        System.out.println(p.getInfo());
        System.out.println(p1.getInfo());
        System.out.println(p2.getInfo());
    }
}

3.this表示类的当前对象(实例化后并且正在使用（比如调用方法，调用属性）的对象)

package 类与对象;
class Person{
    private String name;
    private int age;

    public void Print()
    {
        //哪个对象调用了Print()方法，this就指向哪个对象
        System.out.println("this指向当前对象--->"+this);
    }
}

public class ThisDemo {
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println("p: "+p);
        p.Print();
        Person p1 = new Person();
        System.out.println("p1: "+p1);
       p1.Print();
    }
}

4.类的嵌套调用之深入理解this表示当前对象：

package 类与对象;
class A {
    private B b;
    //2.调用A类的构造，转到--->3
    public A() {
        this.b = new B(this);//3.实例化B类属性b，this就是当前的temp对象，转到--->4
        b.get();//5.调用B类的get()，转到--->6
    }
    //7.执行print()
    public void print() {
        System.out.println("hello world");
    }
}
class B {
    private A a;
    //4.调用B类构造，此处this就是this.b对象，此时this.a=temp,转到--->5
    public B(A a) {
        this.a = a;
    }
    public void get() {
        //6.调用A类的print(),转到--->7
        a.print();
    }
}
public class ThisDemo {
    public static void main(String[] args) {
        //1.实例化A类对象转到--->2
          A temp = new A();
    }
}

package 类与对象;
class Message {
    private String info = "ssss";
    public Message(String info) {
        this.info = info;
    }
    public String getInfo() {
        return info;
    }
    public void setInfo(String info) {
        this.info = info;
    }
}
    public class DEMO1 {
        public static void main(String[] args) {
            Message msg = new Message("Hello");
            fun(msg);
            System.out.println(msg.getInfo());
        }
        public static void fun(Message temp)
        {
            temp.setInfo("World");
        }
    }

------------------- （图一）

------------------（图二）
说明：由于String字段的内容不可改变，所以画内存图的时候，可以把String字段当做一般数据类型的字段画如图二所示
附：
基本数据类型是放在栈中还是放在堆中，这取决于基本类型声明的位置。
一：在方法中声明的变量，即该变量是局部变量，每当程序调用方法时，系统都会为该方法建立一个方法栈，其所在方法中声明的变量就放在方法栈中，当方法结束系统会释放方法栈，其对应在该方法中声明的变量随着栈的销毁而结束，这就局部变量只能在方法中有效的原因， 在方法中声明的变量可以是基本类型的变量，也可以是引用类型的变量。

     （1）当声明是基本类型的变量的时，其变量名及值（变量名及值是两个概念）是放在方法栈中

     （2）当声明的是引用变量时，所声明的变量（该变量实际上是在方法中存储的是内存地址值）是放在方法的栈中，该变量所指向的对象是放在堆类存中的。

二：在类中声明的变量是成员变量，也叫全局变量，放在堆中的（因为全局变量不会随着某个方法执行结束而销毁）。

   同样在类中声明的变量即可是基本类型的变量 也可是引用类型的变量

   （1）当声明的是基本类型的变量其变量名及其值放在堆内存中的

   （2）引用类型时，其声明的变量仍然会存储一个内存地址值，该内存地址值指向所引用的对象。引用变量名和对应的对象仍然存储在相应的堆中

（更多关于java栈区，堆区等有关内容见以下博客
https://blog.csdn.net/terstdfhuc/article/details/86526047）