自学java （day13）：this关键字

 

/**
 * this关键字：
 *      1、this是个关键字，翻译为：这个
 *      2、this是个引用，this是个变量，this保存内存地址指向自身，this存储在JVM堆内存的java对象内部
 *      3、创建多少java对象就有多少this
 *      4、this可以出现在实例方法中，this指向当前正在执行这个动作的对象（this代表当前对象）
 *      5、this在多数情况下可以省略不写
 *      6、this不能使用在带有static的方法当中
 *
 *      7、实例变量的访问必须要先创建对象才可以访问
 */

/**
 *              构造方法：：：：不带返回值
 *              实例方法：：：：带有返回值
 */

/**
 *      1、this什么时候不能省略？？？？
 *      this关键字用来区分局部变量和实例变量的时候   this不能省略
 *      2、什么时候加this，什么时候不加this？？？？
 *          实例变量和局部变量同名的时候必须加上this
 *          实例变量和局部变量不同名的时候可以不加this
 */

/**
 * 1、this可以在那里？？？
 *      this可以采用在实例方法中，代表当前对象【语法格式：this.】
 *      this也可以使用在构造方法中，可以通过当前的构造方法调用其他的构造方法【语法格式：this（实参）】
 * 重点【记忆】：：：this（）；这种语法只能出现在构造方法的第一行，一个构造方法只能出现一次this（）；
 */

 

public class Test {

    //带有static的方法
    public static void method1(){
        //调用doSome（带static）
        //完整方式调用
        Test.doSome();
        //省略方式调用
        doSome();

        //调用doOther(没有static）
        //完整方式调用
        Test t=new Test();
        t.doOther();
        //省略方式调用
            //不带static的没有省略的方式

        //访问i
        //采用完整方式访问
        System.out.println(t.i);
        //省略方式访问
                //没有省略的方式

    }

    //不带有static的方法
    public void method2(){
        //调用dosome
        //完整方式调用
        Test.doSome();
        //省略方式调用
        doSome();

        //调用doother
        //完整方式调用
        Test t=new Test();
        t.doOther();
        //省略方式调用
        doOther();

        //访问i
        //采用完整方式访问
        System.out.println(this.i);
        //省略方式访问
        System.out.println(i);

    }

    //主方法
    public static void main(String[] args){
        //要求在这编写程序调用mothod1(带static）
        //使用完整方式调用
        Test.method1();
        //使用省略方式调用
        method1();

        //要求在这编写程序调用mothod2(不带static）
        //使用完整方式调用
        Test t=new Test();//需要先创建对象在使用（引用.类名）的方式
        t.method2();
        //使用省略方式调用
              //不带static的没有省略的方式

    }

    //没有static的变量
    int i=10;

    //带有static的方法
    public static void doSome(){
        System.out.println("do some!");
    }

    //不带static的方法
    public  void doOther(){
        System.out.println("do other!");
    }
}

1 

//顾客类

public class Customer {

    //名字
    String name;

    //构造方法
    //无参构造
    public Customer(){

    }

    //有参构造
    public Customer(String name){
        this.name=name;
    }

    //购物
    //不带static  属于“实例方法”
    public void Shopping(){

        //张三购物的时候输出：张三在购物
        //李四购物的时候输出：李四在购物

        // System.out.println(name+"在购物");
        System.out.println(this.name+"在购物");//this可以省略不写
    }

    public static void tesr(){

        //创建对象
        Customer c=new Customer();
        c.name="fgf";
        System.out.println(c.name);

        Customer c1=new Customer("fafa");
        System.out.println(c1.name);

    }
}

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();

        //调用tesr
        Customer.tesr();


    }
}

2 

/**
 *      1、this什么时候不能省略？？？？
 *      this关键字用来区分局部变量和实例变量的时候   this不能省略
 *      2、什么时候加this，什么时候不加this？？？？
 *          实例变量和局部变量同名的时候必须加上this
 *          实例变量和局部变量不同名的时候可以不加this
 */
//用户类
public class User {
    //属性
    private int id;//实例变量
    private String name;//实例变量

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

//构造函数
    //无参构造方法
    public User(){

    }

    /**
    //有参构造,,,,,,之前的有参构造方法
    public User(int a,String s){
        id=a;
        name=s;

    }
     */

    //有参构造方法，，，，现在学习了this
    public User(int id,String name){
        this.id=id;
        this.name=name;
    }

    //set and get

    /**
     * 编译报错
    public void setId(int id){
        id=id;
    }
     */

    public void setId(int id){
        //等号前边的id是实例变量的id
        //等号后边的id是局部变量的id
        //这里的this不能省略
        this.id=id;
    }
}

public class UserTest {
    public static void main(String[] args){

        //调用无参构造方法
        User u1=new User();
        System.out.println(u1.getId());
        System.out.println(u1.getName());

        //调用有参构造方法
        User u2=new User(78,"詹三");
        System.out.println(u2.getId());
        System.out.println(u2.getName());
        //修改名字
        u2.setName("李四");
        System.out.println(u2.getName());
     //   System.out.println(u2.setName("lisi"));//编译报错 此处不允许使用 '空' 类型 ，，这里不能直接改直接输出

    }
}

3

//自定义的日期类型

/**
 * 1、this可以在那里？？？
 *      this可以采用在实例方法中，代表当前对象【语法格式：this.】
 *      this也可以使用在构造方法中，可以通过当前的构造方法调用其他的构造方法【语法格式：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;
         */
        //以下代码创建了一个全新的对象
        //new Date(1970,1,1,);

        //可以采用以下的语法来完成构造方法的调用
        //这种方式不会创建新的java对象，但可以同时达到调用别的构造方法
        //这个语句只能出现在构造方法的第一行
        this(1970,1,1);

    }

    //有参构造
    public Date(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
    }


    //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);
    }
}

public class DateTest {
    public static void main(String[] args){
        //创建日期对象1
        Date time1=new Date();
        time1.print();

        //创建日期对象2
        Date time2=new Date(2008,1,9);
        time2.print();

    }
}