this

this：

    1 this是一个关键字，是一个引用，保存内存地址指向本身。

    2 this可以使用在实例方法中，也可以使用在构造方法中。

    3 this出现在实例方法中其实代表的是当前对象。

    4 this不能使用在静态方法中。

    5 this. 大部分情况下可以省略，但是用来区分局部变量和实例变量的时候不能省略。

    6 this() 这种语法只能出现在构造方法第一行，表示当前构造方法调用本类其他的构造方法，目的是代码复用。

 

 

 

java中的三大变量

 

案例1：

/*
    this:
        1 this是一个关键字，全部小写。
        2 this是什么，在内存方面是怎样的。
            一个对象一个this。
            this是一个变量，是一个引用。this保存当前对象的内存地址，执行自身。
            this存储在堆内存当中对象的内部。
        3 this只能使用在市里方法中。谁调用这个实例方法，this就是谁。
            所以this代表的是：当前对象。
            
        4 this. 大部分情况下是可以省略的
        
        5 为什么this. 不能使用在静态方法中?
            this代表当前对象，静态方法中不存在当前对象。
*/
public class ThisTest01{
    public static void main(String[] args){
        Customer c1 = new Customer("zhangsan");
        c1.shopping();
        Customer c2 = new Customer("lisi");
        c2.shopping();
        
        // Customer.doSome();
    }
}

// 顾客类
class Customer{
    // 属性
    // 实例变量
    String name;
    
    // 构造方法
    public Customer(){
    
    }
    
    public Customer(String s){
        name = s;
    }
    
    // 顾客购物的方法
    // 实例方法
    public void shopping(){
        // 这里的this是谁?this是当前对象。
        // c1调用shopping(),this是c1
        // c2调用shopping(),this是c2
        // this. 是可以省略的
        // this. 省略的话，还是默认访问“当前对象”的name
        System.out.println(this.name + "正在购物");
    }
    
    // 静态对象
    public static void doSome(){
        // this 代表的是当前对象,而静态方法的调用不需要对象。矛盾了。
        //System.out.println(this);// java:55: 错误: 无法从静态上下文中引用非静态 变量 this
    }
}

class Student{
    // 实例变量，怎么访问？ 必须先new对象，通过"引用." 来访问。
    String name = "zhangsan";
    
    // 静态方法
    public static void m1(){
        // this代表的是当前对象。
        //System.out.println(name);    
        
        // this.代表的是当前对象。
        //System.out.println(thsi.name);
        
        // name是当前对象的名字。
        //System.out.println(name);
        
        // 除非你这样
        Student s = new Student();
        System.out.println(s.name);
    }
    
    // 为什么set和get方法是实例方法？
    public void setName(String s){
        name = s;
    }
    
    public String getName(){
        return name;
    }
    
    // 又回到上午的问题了？什么时候定义为实例方法，什么时候定义为静态方法？
    // 如果方法中直接访问了实例变量，该方法必须是实例方法。
}

 

习题1：

public class DateTest01{
    private String nian;
    
    private String yue;
    
    private String ri;
    
    // 无参构造方法
    public DateTest01(){
    
    }
    
    // 有参构造方法
    public DateTest01(String year,String mouth,String day){
        nian = year;
        yue = mouth;
        ri = day;
    }
    
    //实例方法
    public void setNian(String i){
        nian = i;
    }
    
    public String getNian(){
        return nian;
    }
    
    public void setYue(String i){
        yue = i;
    }
    
    public String getYue(){
        return yue;
    }
    
    public void setRi(String i){
        ri = i;
    }
    
    public String getRi(){
        return ri;
    }
    
    // 实例方法
    public void getYearMonthDay(){
        System.out.println("当前年是：" + this.nian);
        System.out.println("当前月是：" + this.yue);
        System.out.println("当前日是：" + this.ri);
    }
    
    //静态方法
    public static void main(String[] args){
        
        // 创建实例对象
        DateTest01 dt = new DateTest01();
        dt.setNian("2020");
        dt.setYue("06");
        dt.setRi("02");
        // 调用实例方法
        dt.getYearMonthDay();
        
        DateTest01 dt2 = new DateTest01();
        dt2.setNian("2020");
        dt2.getYearMonthDay();
    }
}

 

案例2：

/*
    1 this可以使用在实例方法中，不能使用在静态方法中。
    2 this关键字大部分情况下可以省略，什么时候不能省略呢？
        在实例方法中，或者构造方法中，为了区分局部变量和实例变量，这种情况下：this. 是不能省略的。
*/
public class ThisTest03{
    public static void main(String[] args){
        Student s = new Student();
        s.setNo(1111);
        s.setName("张三");
        
        System.out.println(s.getNo());
        System.out.println(s.getName());
        
        Student s2 = new Student(2222,"李四");
        
        System.out.println(s2.getNo());
        System.out.println(s2.getName());
        
    }
}

class Student{
    //学号
    private int no;
    //姓名
    private String name;
    
    // 实例方法 get set方法
    public int getNo(){
        return no;
        // return this.no;
    }
    
    /*public void setNo(int i){
        no = i;
    }*/
    
    /*public void setNo(int no){// java就近原则  他只会找最近的那一个进行赋值，所以他把自己给了自己
        no = no;// 这两个变量都是局部变量no，和实例变量no没关系
    }*/
    
    public void setNo(int no){
        this.no = no;
    }
    
    /*public String getName(){
        return name;
    }*/
    
    // 原来的样子
    public String getName(){//getName实际上获取的是“当前对象”的名字
        return this.name;
    }
    
    public void setName(String name){
        this.name = name;
    }
    
    //无参构造方法
    public Student(){
    
    }
    
    // 有参构造方法
    public Student(int no,String name){
        this.no = no;
        this.name = name;
    }
}