this

package thisTest01.javase;

/**
 * 关于java语言当中的this关键字：
 *         1、this是一个关键字
 *         2、this是一个引用，this是一个变量，
 *            this变量中保存了内存地址指向自身，
 *            this存储在JVM堆内存java对象内部
 *         3、this可以出现在“实例变量”当中，
 *            this指向当前正执行这个动作的对象（this代表当前对象）
 *         4、this在多数情况下可以省略不写
 *         5、this不能使用在带有static的方法当中
 * 
 *
 */
public class Customer {

    //姓名
    String name;
    
    //构造方法
    public Customer(){
        
    }
    
    //不带有static关键字的一个方法
    //顾客购物的行为，每个顾客购物最终的结果是不一样的
    
    //所以购物这一行为属于对象级别的行为
    //重点：没有static关键字的方法被称为“实例方法”，
    //        实例方法如何访问？“引用.”
    //重点：没有static关键字的变量被称为“实例变量”
    //注意：当一个行为，对象执行的过程中是需要对象参与的，
    //        那这个方法一定要定义为“实例方法”，不带static关键字
    
    //以下方法定义为实例方法，因为在真实的购物，
    //每个人最终的结果是不同的，所以需要对象的参与
    public void shopping(){
        //当张三在购物时，输出张三
        
        //简写方法：System.out.println(name + "在购物");
        
        //完整写法：System.out.println(c1.name + "在购物"); 但不行
        
        //由于name是一个实例变量，
        //所以这个name访问的时候一定访问的是当前对象的name。
        //所以多数情况下“this.”是可以省略的
        System.out.println(this.name + "在购物");        
    }
    
    //带有static
    public static void main(){
        //这个执行过程中没有“当前对象”，自然不存在this
        //所以，System.out.println(this.name); 不行        
    }
}

package thisTest01.javase;

public class CustomerTest {

    public static void main(String[] args) {

        //创建Customer对象
        Customer c1 = new Customer();
        c1.name = "zhangsan";
        
        c1.shopping();
        
        //再创建Customer对象
        Customer c2 = new Customer();
        c2.name = "lisi";
        
        c2.shopping();
    }
}

package ThisTest02.javase;

public class ThisTest {

    //实例变量（引用.的方式访问）
    int num = 10;
    
    //带有static的方法，JVM负责调用main方法
    //ThisTest.main(String[])
    public static void main(String[] args) {

        //没有当前对象this
        
        //System.out.println(num); //编译错误
        //System.out.println(this.num); //编译错误
        
        //想访问num
        ThisTest tt = new ThisTest();
        System.out.println(tt.num);
        
    }
}

package ThisTest03.javase;

public class ThisTest {

    public static void main(String[] args) {

        //调用dosome方法1
        ThisTest.dosome();
        //调用dosome方法2
        dosome();
        
        //调用doOther对象
        //doOther是实例方法，但由于main方法中没有this，
        //所以上面的方法不能用
        ThisTest tt = new ThisTest();
        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”，this就是tt的地址
        System.out.println("run execute!");
        doOther();
        //this.doOther(); //比较完整的写法
    }
}

package ThisTest04.javase;

/**
 * "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;
    } 
    */
    
    public void setId(int id){
        //等号前面的this.id是实例变量id
        //等号后面的id是局部变量id
        this.id = id;
    }
}

package ThisTest05.javase;

/**
 *自定义日期类型
 *
 *this可以用在：
 *    1、可以使用在实例方法当中，
 *        代表当前对象【语法格式：this.】
 *    2、可以使用在构造方法当中，
 *        通过当前构造方法调用其他构造方法【语法格式：this(实参);】
 */
public class Date {

    //属性
    private int year;
    private int month;
    private int day;
    
    //构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    
    /**
     * 需求：当程序员调用以下无参数的构造方法的时候，
     * 默认日期为“1970-1-1”
     */
    public Date() {
        /*
        this.year = 1970;
        this.month = 1;
        this.day = 1;
        */
        
        //上面的代码可以通过调用另一个构造方法来完成，
        //但前提是不能创建新的对象。
        //这种方式不会创建新的java对象，
        //但同时又可以达到调用其他构造方法.
        this(1970,1,1);
    }
    
    //setter and getter    
    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 + "日");
    }
}

package ThisTest05.javase;

public class DateTest {

    public static void main(String[] args) {
        
        //创建日期对象1
        Date time1 = new Date();
        time1.print();
        
        //创建日期对象2
        Date time2 = new Date(2008,8,8);
        time2.print();
    }
}

package ThisTest06.javase;

public class Test {
    
    //没有static的变量
    int i = 10;
    
    //带有static的方法
    public static void doSome(){
        System.out.println("do some!");
    }
    
    //没有static的方法
    public void doOther(){
        System.out.println("do other!");
    }
    
    //带有static的方法
    public static void method1(){
        //调用doSome
        //使用完整的方式调用
        Test.doSome();
        //使用省略的方式调用
        doSome();
        
        //调用doOther
        //使用完整的方式调用
        Test t = new Test();
        t.doOther();
        //使用省略的方式调用
        //没有
        
        //访问i
        //使用完整的方式调用
        System.out.println(t.i);    
        //使用省略的方式调用
        //没有
    }
    
    //没有static的方法
    public void method2(){
        
        //调用doSome
        //使用完整的方式调用
        Test.doSome();
        //使用省略的方式调用
        doSome();
                
        //调用doOther
        //使用完整的方式调用
        this.doOther(); 
        //要执行到method2肯定要创建对象，就有this
        //使用省略的方式调用
        doOther();
        
        //访问i
        //使用完整的方式调用
        System.out.println(this.i);
        //使用省略的方式调用
        System.out.println(i);
    }

    //主方法
    public static void main(String[] args) {
        //要求在这里编写程序调用method1
        //使用完整的方式调用
        Test.method1();
        //使用省略的方式调用
        method1();
        
        //要求在这里编写程序调用method2
        //使用完整的方式调用
        Test t = new Test();
        t.method2();
        //使用省略的方式调用
        //没有
    }
}

package ThisTest07.javase;

public class Test {
    
    public static void main(String[] args) {
        Test.doSome();
        doSome();
        
        Test t = new Test();
        t.doSome();
        
        //引用是空
        t = null;
        //带有static的方法，其实既可以采用类名的方式访问，
        //也可以采用引用的方式访问。
        //但是即使采用引用的方式去访问，
        //实际上执行的时候和引用的指向的对象无关，但最好别这样。
        t.doSome(); //这里不会出现空指针异常
    }
    
    //带有static的方法，需要使用“类名.”的方式访问
    public static void doSome(){
        System.out.println("do some!");
    }
}