this關鍵字

this調用構造方法:

在之前學習方法之間調用時，可以通過方法名進行調用。可是針對構造方法，無法通過構造方法名來相互調用。

構造方法之間的調用，可以通過this關鍵字來完成。

|------構造方法調用格式：

this(參數列表);

|------構造方法的調用:

package com.oracle.demo01;
public class student {
    private String name;
    private int age;
    public student(){
        //this()在構造方法中調用本類的其他構造方法
        //this()必須放在本構造方法的第一行
 

        this("zhangsan",18);
    }
    public student (String name,int age){
        this.name=name;
        this.age=age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    
 
public void setAge(int age) {
        this.age = age;
    }
    
}

package com.oracle.demo01;

public class test {

    public static void main(String[] args) {
        student s=new student();
        System.out.println(s.getName()+"..."+s.getAge());

    }

}

結果:

super關鍵字:

子父類中構造方法的調用:

在創建子類對象時，父類的構造方法會先執行，因為子類中所有構造方法的第一行有默認的隱式

格式：

調用本類中的構造方法

this(實參列表);

調用父類中的空參數構造方法

super();

調用父類中的有參數構造方法

super(實參列表);

子類繼承了父類的內容，所以創建對象時，必須要先看父類是如何對其內容進行初始化的

package com.oracle.demo02;
public class person {
    private String name;
    private int age;
    public person() {
        super();
    }
    public person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

package com.oracle.demo02;
public class gongren extends person{
    public gongren(String name ,int age){
        super(name,age);
    }
}

package com.oracle.demo02;
public class student extends person{
    public student(String name,int age){
    super(name,age);
    }
}

package com.oracle.demo02;
public class test {
    public static void main(String[] args) {
        student s =new student("小明",2);
        System.out.println(s.getName()+"..."+s.getAge());
        gongren w=new gongren("小紅",28);
        System.out.println(w.getName()+"..."+w.getAge());
    }
}

結果為:

子類構造方法執行時中，調用了父類構造方法，這說明，子類構造方法中有一句super()。

子類會繼承父類中的內容，所以子類在初始化時，必須先到父類中去執行父類的初始化動作。這樣，才可以使用父類中的內容。

當父類中沒有空參數構造方法時，子類的構造方法必須有顯示的super語句，指定要訪問的父類有參數構造方法。

註意:

類中的構造方法默認第一行都有隱式的super()語句，在訪問父類中的空參數構造方法。所以父類的構造方法既可以給自己的對象初始化，也可以給自己的子類對象初始化。

如果默認的隱式super()語句在父類中沒有對應的構造方法，那麽必須在構造方法中通過this或者super的形式明確要調用的構造方法。

final關鍵字

final的概念:

繼承的出現提高了代碼的復用性，並方便開發。但隨之也有問題，有些類在描述完之後，不想被繼承，或者有些類中的部分方法功能是固定的，不想讓子類重寫。需要使用到一個關鍵字final，final的意思為最終，不可變。final是個修飾符，它可以用來修飾類，類的成員，以及局部變量。不能修飾構造方法。

final的特點:

final修飾類不可以被繼承，但是可以繼承其他類。

class Yy {}

final class Fu extends Yy{} //可以繼承Yy類

class Zi extends Fu{} //不能繼承Fu類

final修飾的方法不可以被子類重寫,但父類中沒有被final修飾方法，子類重寫後可以加final。

class Fu {

// final修飾的方法，不可以被覆蓋，但可以繼承使用

    public final void method1(){}

    public void method2(){}

}

class Zi extends Fu {

//重寫method2方法

public final void method2(){}

}

final修飾的變量稱為常量，這些變量只能賦值一次。而且終身不變。

final int i = 20;
i = 30; //賦值報錯，final修飾的變量只能賦值一次

引用類型的變量值為對象地址值，地址值不能更改，但是地址內的對象屬性值可以修改。

final Person p = new Person();
Person p2 = new Person();
p = p2; //final修飾的變量p，所記錄的地址值不能改變
p.name = "小明";//可以更改p對象中name屬性值

p對象中的name或age可以更改

修飾成員變量，需要在創建對象前賦值，否則報錯。(當沒有顯式賦值時，多個構造方法的均需要為其賦值。)

class Demo {
//直接賦值
final int m = 100;
//final修飾的成員變量，需要在創建對象前賦值，否則報錯。
final int n;
public Demo(){
//可以在創建對象時所調用的構造方法中，為變量n賦值
n = 2016;
}
}

例子

package com.oracle.demo03;
//final修飾類(太監類)
//不能被繼承,但能繼承其他類
public final class fu {
}

package com.oracle.demo03;
public class fu2 {
    public final void xiuche(){
        System.out.println("失傳");
    }
    public void maiche(){
        System.out.println("賣車");
    }
}

package com.oracle.demo03;
public class zi extends fu2{
    /*public final void xiuche(){
        System.out.println("失傳");
    }*/
    public final void maiche(){
        System.out.println("賣車");
    }
}

package com.oracle.demo03;
public class zi2 {
    public void eat(){
        final int i=3;
        fu2 f=new fu2();
        f =null;
    }
}

package com.oracle.demo03;
//被final修飾的成員變量沒有系統默認初始值
public class zi3 {
    final String name;
    public zi3(String name){
        this.name=name;
    }
}

static關鍵字

static概念:

當在定義類的時候，類中都會有相應的屬性和方法。而屬性和方法都是通過創建本類對象調用的。當在調用對象的某個方法時，這個方法沒有訪問到對象的特有數據時，方法創建這個對象有些多余。我們可以通過static關鍵字來實現。static它是靜態修飾符，一般用來修飾類中的成員。

static特點:

1,被static修飾的成員變量屬於類，不屬於這個類的某個對象。（也就是說，多個對象在訪問或修改static修飾的成員變量時，其中一個對象將static成員變量值進行了修改，其他對象中的static成員變量值跟著改變，即多個對象共享同一個static成員變量）

class Demo {
    public static int num = 100;
}
class Test {
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = new Demo();
        d1.num = 200;
        System.out.println(d1.num); //結果為200
        System.out.println(d2.num); //結果為200
    }
}

2.被static修飾的成員可以並且建議通過類名直接訪問。

訪問靜態成員的格式：

類名.靜態成員變量名

類名.靜態成員方法名(參數)

對象名.靜態成員變量名      ------不建議使用該方式，會出現警告

對象名.靜態成員方法名(參數) ------不建議使用該方式，會出現警告

class Demo {
    //靜態成員變量
    public static int num = 100;
    //靜態方法
    public static void method(){
        System.out.println("靜態方法");
    }
}
class Test {
    public static void main(String[] args) {
        System.out.println(Demo.num);
        Demo.method();
    }
}

static註意事項:

1.靜態內容是優先於對象存在，只能訪問靜態，不能使用this/super。靜態修飾的內容存於靜態區。

class Demo {
    //成員變量
    public int num = 100;
    //靜態方法
    public static void method(){
        //this.num; 不能使用this/super。
        System.out.println(this.num);
    }
}

2.同一個類中,靜態成員只能訪問靜態成員

class Demo {
    //成員變量
    public int num = 100;
    //靜態方法
    public static void method(){
        //this.num; 不能使用this/super。
        System.out.println(this.num);
    }
}

3.main方法為靜態方法僅僅為程序執行入口，它不屬於任何一個對象，可以定義在任意類中。

4.多態調用方法中，編譯看=左邊，父類有，編譯成功，父類沒有，編譯失敗

運行，靜態方法，運行父類中的靜態方法，

運行，非靜態方法，運行子類的重寫方法

成員變量，編譯運行全是父類

定義靜態常量

開發中，我們想在類中定義一個靜態常量，通常使用public static final修飾的變量來完成定義。此時變量名用全部大寫，多個單詞使用下劃線連接。

定義格式：

public static final 數據類型 變量名 = 值;

如下演示：

class School {

public static final String SCHOOL_NAME = "北京大學";

public static void method(){

System.out.println("一個靜態方法");

}

}

當我們想使用類的靜態成員時，不需要創建對象，直接使用類名來訪問即可。

System.out.println(Company.SCHOOL_NAME);

Company.method(); // 調用一個靜態方法

註意：

接口中的每個成員變量都默認使用public static final修飾。

所有接口中的成員變量已是靜態常量，由於接口沒有構造方法，所以必須顯示賦值。可以直接用接口名訪問。

interface Inter {
public static final int COUNT = 100;
}

訪問接口中的靜態變量

Inter.COUNT

=======================================================================================================================================

package com.oracle.demo04;
public class demo {
//靜態只能調用靜態,不能調用非靜態
//非靜態可以訪問靜態
    //成員變量不管靜態不靜態都看父類成員變量
    public static void main(String[] args) {
        demo d=new demo();
        d.eat();
    }
    public void eat(){
        
    }
}

package com.oracle.demo04;
public class student {
    String name;
    int age;
    static String schoolname;
}

package com.oracle.demo04;
public class test {
    public static void main(String[] args) {
        student s=new student();
        s.name="xiaohong";
        student.schoolname="beijingdaxue";
        student s2=new student();
        s2.name="xiaoming";
        student.schoolname="qinghuadaxue";
    System.out.println(student.schoolname+"..."+student.schoolname);
    }

}

結果:

this,final super,static關鍵字