Java基础之面向对象详细讲解（3)——this关键字，构造方法，静态static

this关键字和构造方法都不是很难，所以放在一起写

1、this关键字

1.1、this关键字

this关键字是在方法里面用到的一个东西

当方法执行时会有一个默认的参数this，表示当前正在执行这个方法的对象

谁调用该方法，那么this就代表谁

1.2、this关键字，代码助理解

package main;

public class GirlFriend {
    /*女朋友的属性（外貌）*/
    int age;
    String name;
    String height;
    String weight;
    String skin_color;
    String hair_color;
    String bra_size;

    /*女朋友的行为*/
    public void kiss_smile(){
        System.out.println("女朋友亲的时候还笑了一下");
    }
    public void kiss(){

        System.out.println("女朋友年纪"+this.age);
        System.out.println("女朋友名字"+this.name);
        System.out.println("女朋友原来罩杯大小"+this.bra_size);
        this.bra_size="F";
        System.out.println("女朋友现在罩杯大小"+this.bra_size);
        System.out.println("女朋友亲了一口");
        this.kiss_smile();
    }

    public static void main(String[] args) {
        /*女朋友具体化*/
        GirlFriend MyGirlFriend = new GirlFriend();

        /*女朋友方法的设置*/
        MyGirlFriend.age = 22;
        MyGirlFriend.name = "Lisa";
        MyGirlFriend.height = "168"+"cm";
        MyGirlFriend.weight = "45"+"kg";
        MyGirlFriend.skin_color = "white";
        MyGirlFriend.hair_color = "Yellow_White";
        MyGirlFriend.bra_size = "C";

        /*女朋友行为的执行*/
        MyGirlFriend.kiss();

        /*注意看结果，我是在kiss方法中通过调用this关键字来输出属性,如果我再次对属性赋值，那么就会优先等于此值，
        我同时还可以继续调用方法；如果我调用自己，这就俗称套娃，会陷入循环*/
    }
}

2、构造方法

2. 1、构造方法

什么是构造方法

在创建对象的时候，自动调用的方法

（new的时候自动调用构造方法）

2.2、构造方法，代码助理解

package main;

public class GirlFriendse {
    /*属性*/
    String name;

    /*方法*/
    public void kiss(String MyName){
        System.out.println(this.name+"亲了一口"+MyName);
    }

    /*构造方法，在创建对象时自动调用*/
    public GirlFriendse(String GirlFriendName,String MyName){
        /*就等于在实例化MyGirl后进行：
        MyGirl.name = "Lisa";
        MyGirl.kiss("暴走code");
        System.out.println("我是构造方法,只要进行类的实例化时就会调用我");

        在实例化MyGirl2后进行：
        MyGirl.name = "Candy";
        MyGirl.kiss("暴走code");
        System.out.println("我是构造方法,只要进行类的实例化时就会调用我");
        */
        this.name = GirlFriendName;
        this.kiss(MyName);
        System.out.println("我是构造方法,只要进行类的实例化时就会调用我");
    }

    public static void main(String[] args) {
        /*在实例化时，直接将参数丢给构造方法*/
        GirlFriendse MyGirl = new GirlFriendse("Lisa","暴走code");
        GirlFriendse MyGirlSecond = new GirlFriendse("Candy","暴走code");
    }
}

2.3、构造方法重载

构造方法不能同时满足两个对象的需求

此时需要两个构造方法，方法的名字相同，但是参数不同

可以以更多的方式创建对象

2.4、构造方法重载，代码助理解

package main;

public class GirlFriendse {
    /*属性*/
    String name;
    String BraSize;
    String SexPlace;
    /*方法*/
    public void sex(String MyName){
        System.out.println("胸大小为 "+this.BraSize+" 的 "+this.name+" 和 "+MyName+" 在 "+this.SexPlace+"爱爱");
    }

    /*构造方法，在创建对象时自动调用*/
    public GirlFriendse(String GirlFriendName,String braSize,String MyName){
        this.name = GirlFriendName;
        this.BraSize = braSize;
        System.out.println("我现在构造的是："+GirlFriendName+" 老婆");
    }
    /*因为我对另一个老婆有不同的需求，所以我重载构造方法*/
    public GirlFriendse(String GirlFriendName,String braSize,String MyName,String place){
        /*
        当需要重载的构造方法有很多类似的属性时
        可以使用this调用当前类中其它的构造方法
        下面就相当于：
        this.name = GirlFriendName;
        this.BraSize = braSize;
        */
        this(GirlFriendName,braSize,MyName);
        this.SexPlace = place;
        this.sex(MyName);
    }

    public static void main(String[] args) {
        /*在实例化时，直接将参数丢给构造方法*/
        /*我现在创建两个老婆，她们有名字，胸的大小
        一个是Lisa，我今天不临幸她，所以不需要设置SexPlace属性
        另一个是Candy，我今天临幸她，所以需要设置SexPlace属性*/
        GirlFriendse MyGirl = new GirlFriendse("Lisa","B","暴走code");
        GirlFriendse MyGirlSecond = new GirlFriendse("Candy","F","暴走code","白宫");
    }
}

3、静态static

3.1、静态

非静态的被称为成员变量和成员方法

静态的被称为静态变量和静态方法

成员变量和成员方法需要进行类的实例化，成为一个对象后，才可以进行使用

静态方法和静态变量不需要进行类的实例化就可以进行使用

静态内容（静态方法，静态块）不能调用非静态的内容，只有在静态方法中才能焦勇静态的东西

3.2、执行顺序

先执行静态内容，再创建对象

3.3、代码助理解

执行顺序以及使用规则

package main;
public class StaticTest {
    String name;
    /*通用构造方法，类实例化的时候被执行，比构造方法优先执行*/
    {
        this.name="通用构造方法";
        System.out.println("通用构造方法");
    }
    /*静态构造器，任何时候都会被执行*/
    static{
        /*静态方法中不能使用非静态变量，例如this*/
        //this.name="test";
        System.out.println("静态构造器");
    }
    /*构造方法，类实例化的时候被执行，可以传递参数*/
    public StaticTest(){
        this.name = "构造方法";
        System.out.println("构造方法");
    }
    /*静态方法1*/
    public static void static_method(){
        /*静态方法中不能使用非静态变量，例如this*/
        //this.name="test";
        System.out.println("静态方法static_method");
        /*在静态方法中直接调用静态方法*/
        static_method2();
    }
    /*静态方法2*/
    public static void static_method2(){
        System.out.println("静态方法static_method2");
    }
    public static void main(String[] args) {
        StaticTest staticTest = new StaticTest();
        System.out.println("name的值是："+staticTest.name);
        /*在静态方法中直接调用静态方法*/
        static_method();
    }
}

案例2

package main;
public class StaticTest {
    String name;
    static String identity = "少女";

    public StaticTest(String name){
        this.name = name;
    }
    public static void main(String[] args) {
        StaticTest GirlFriend1 = new StaticTest("Candy");
        StaticTest GirlFriend2 = new StaticTest("Lucia");
        System.out.println(identity);
        StaticTest.identity = "妇女";
        System.out.println(GirlFriend1.identity);
        System.out.println(GirlFriend2.identity);
    }
}