技術標籤：JAVA學習筆記java

學習目標：

繼承，抽象類，final關鍵字

學習內容：

一.繼承

1. 繼承的概述
2. 繼承的格式
3. 繼承中成員的訪問規則
4. 方法重寫
5. this代表本類物件的引用
6. super代表父類物件的引用
7. 繼承的特點
8. 抽象類
9. 抽象類的概述
10. 抽象類的格式
11. 模板設計模式
12. final 關鍵字
13. final關鍵字的概述
14. final關鍵字的使用

1.1.1 繼承的概述

1. 多個類存在相同的屬性和方法時，可以將這些內容抽取到一個類中。
2. 其餘類無需再定義這些屬性和方法，只需繼承定義的那個類。
3. 繼承之後，多個類特有的屬性和方法可以在自己的類中定義。
4. 繼承後，多個類稱為子類，單獨定義的類稱為父類。

1.1.2 繼承的含義

1. 子類可以繼承父類，使得子類具有和父類相同的屬性和行為。
2. 子類可以訪問父類非私有的屬性和方法，私有的屬性和方法可以通過set/get獲取。

1.1.3 繼承的優點

1. 提高程式碼的複用性
2. 使類與類之間聯絡在一起
3. 多型的前提

1.2.1 繼承的格式

class 父類 {
	...
}
class 子類 extends 父類 {
	...
}

/*
定義一個人類：具有名字，年齡。可以吃飯，睡覺。
定義一個學生：具有名字，年齡，學號。可以吃飯，睡覺，打遊戲，學習
*/

1. 學生類繼承人類的年齡、名字屬性和吃飯、睡覺方法，並擁自己獨特的學號屬性和玩遊戲、學習方法。

public class Person {
    String name;
 

    int age;

    public void sleep(){
        System.out.println("睡覺");
    }
    public void eat(){
        System.out.println("吃飯");
    }
}

public class Student extends Person {
    int studentNumber;

    public void play() {
        System.out.println("玩遊戲");
    }
 


    public void study() {
        System.out.println("學習");
    }
}

1.3.1 子類繼承規則

1. 子類不能繼承父類的構造方法。
2. 子類可以繼承父類的私有成員（成員變數，成員方法），但是子類無法直接訪問，需要通過get/set方法訪問。

例1

1. 當父類中成員變數為私有時，子類不能直接訪問

//父類
public class Person {
    private String name;
    //不寫構造方法時，會預設提供一個空參的構造方法
    /*
    	public Person() {}
    */
    public String getName() {
        return name;
    }

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

//子類
public class Student extends Person {
    int studentNumber;

    public void shou() {
       	//父類屬性為私有時，無法直接訪問，需要通過get/set
        //System.out.println(name);
        System.out.println(getName());
    }
}

1.3.2當子類與父類成員變數名相同時

1. 按照就近原則處理(先看區域性變數，再看子類變數，最後看父類變數)

//定義類：40歲的父親(父類)
public class Father {
    int age = 40;
}

//定義類：18歲的學生(子類)
public class Student extends Father {
    int age =18;

	//子類中定義一個方法
    public void show() {
        int age =17;
        System.out.println("展示的年齡"+age);
        System.out.println("子類的年齡"+age);
        System.out.println("父類的年齡"+age);
		//列印結果為 17,17,17
		//按照就近原則處理(先看區域性變數，再看子類變數，最後看父類變數)

		System.out.println("展示的年齡"+age);
        System.out.println("子類的年齡"+this.age);
        System.out.println("父類的年齡"+super.age);
        //列印結果為17,18,40
        //super代表的是父類的引用，this代表的是當前物件的引用。
    }
}

public class Test {
    public static void main(String[] args) {
        Student st = new Student();
        st.show();
    }
}

1.3.3當子類與父類成員變數名相同時

1.當子類方法與父類方法重名時,建立子類物件呼叫該方法時,子類會優先呼叫自己的方法.

public class Fu {
    public void method(){
        System.out.println("父類的方法");
    }
}

public class Zi extends Fu {

	//此處子類重寫的父類的方法
    public void method(){
    //若是子類的方法中需要使用父類的方法,可以新增
    //super.method();
        System.out.println("子類的方法");
    }
}

public class Test {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}

控制檯輸出語句為:子類的方法
說明呼叫的是子類的物件

1.4.1方法的重寫

1.當子類方法的返回值型別,方法名,引數列表(引數個數,引數型別)全都相等時,會出現覆蓋的效果.

public class Fu {
    public String method() {
        String str = "父類的方法";
        return str;
    }
}

public class Zi extends Fu {

	//@Override:註解，重寫註解校驗！
	//這個註解標記的方法，就說明這個方法必須是重寫父類的方法，否則編譯階段報錯。
	//建議重寫都加上這個註解，一方面可以提高程式碼的可讀性，一方面可以防止重寫出錯！
    @Override
    public String method(){
        String str ="子類的方法";
        return str;
    }
    //方法重寫的注意事項
    //1.方法重寫是發生在父子類之間的關係。
    //2.子類方法覆蓋父類方法，必須要保證許可權大於等於父類許可權。
    //3.子類方法覆蓋父類方法，返回值型別、函式名和引數列表都要一模一樣。
}

public class Fu {
    public Fu() {
        System.out.println("父類的構造方法");
    }
}

public class Zi extends Fu {
    public Zi() {
    //使用super呼叫了子類的構造方法
    //對於父類有引數的構造方法,可在super()的括號中填入相應引數
        super();
        System.out.println("子類的構造方法");
    }
}
//1.首行：在子類中呼叫構造方法一定要放在子類構造方法中的第一行
//2.預設：所有子類的構造方法第一行都會預設一個super()呼叫父類的空參構造方法
//3.- 手動替代預設：如果子類的構造方法中手動呼叫了父類的構造方法,那麼就不會自動呼叫父類的空參構造方法

public class Test {
    public static void main(String[] args) {
        Zi zi = new Zi();
    }
}
/*
列印結果為:	 父類的構造方法
			 子類的構造方法
*/	

1.5.1子類只能繼承一個父類

//class A extend B,C
編譯錯誤

1.5.2父類可以擁有多個子類

  class A {}
  class B1 extends A {}
  class B2 extends  A {}
  //B1,B2都繼承A

  //子類可以父類的父類中的內容
  class A {}
  class B extends A {}
  class C extends B {}
  //C繼承B,B繼承A

二.抽象類,模組思想

2.1.1抽象類

1.某一種類,他有一個方法,他每個子類對這個方法實現的方式都不一樣.

1.定義抽象類的格式
許可權修飾符 abstract 返回值型別 方法名(形參);

2.定義抽象類的格式
許可權修飾符 abstract class 類名{
	//1.成員變數
	//2.成員方法
	//3.構造方法
	//4.抽象方法
}

public abstract class Animal {
    public abstract void eat() ;
}

public class Cat extends Animal {
    @Override
    public void eat(){
        System.out.println("吃魚");
    }
}

public class Dog extends Animal {
    @Override
    public void eat(){
        System.out.println("吃骨頭");
    }
}

子類繼承抽象類時,必須重寫抽象方法

注意事項:

1. 抽象類不一定有抽象方法.
2. 有抽象方法的類一定是抽象類
3. 抽象類不能建立物件,若建立物件,程式將報錯.
4. 抽象類可以有有構造方法,是提供子類建立物件使用.
5. 抽象類的子類必須重寫抽象類中所有的抽象方法
6. 抽象類存在的意義就是為了被子類繼承

2.1.1抽象類的模組思想

• 抽象類體現的是模板思想，模板是通用的東西。
• 抽象類中可以是具體的實現（抽象類中可以有成員變數和實現方法），也可以有抽象方法。
• 模板中不能決定的東西定義成抽象方法，讓使用模板（繼承抽象類的類）的類去重寫抽象方法實現需求。

三.final關鍵字

3.1.1 final關鍵字的概述

Java提供了final 關鍵字，用於修飾不可改變內容。可以用於修飾類、方法和變數。
1.修飾類：被修飾的類，不能被繼承。

public final class A {

}

// public class B extends A {//由於A類是最終類，所以B類不能繼承
public class B{
    public final  void method(){
        System.out.println("final method");
    }
}

public class C extends B {
    /*
    //因為父類中method被final修飾，所以子類不能重寫
    public  void method(){
       System.out.println("final method");
    }
     */
    public final int NUM1 = 10;
    public final int NUM2;
    NUM2一旦被賦值,就無法修改.
    //等同於常量

2.修飾方法：被修飾的方法，不能被重寫。
3.修飾變數：被修飾的變數，不能被重新賦值。

• 被final修飾的常量名稱，一般都有書寫規範，所有字母都大寫。
• 變數被final修飾後，只能賦值一次，不能再更改。

案例
寫法1：
    final int C = 0;
	for (int i = 0; i < 10; i++) {
    	c = i;
    	System.out.println(C);
	}
//寫法一會出現編譯錯誤
寫法2：
    for (int i = 0; i < 10; i++) {
    final int C = i;
    System.out.println(C);
	}

學習時間：