復習總結【復習回顧、繼承、抽象類模板設計模式】

今日內容

• 面向對象復習------>必須掌握
• 繼承
  • 繼承的格式------>必須掌握
  • 繼承后成員訪問特點------>必須掌握
• 抽象類----->必須掌握
  • 抽象類的定義以及使用
  • 抽象方法的定義以及調用
• 模板設計模式----->必須掌握
• final 關鍵字----->必須掌握
  • 修飾類
  • 修飾方法
  • 修飾變量

第1章 復習回顧

1.1 類和對象

定義一個類

• 格式:

  修飾符 class 類名{//類中的五大成分。1.成員變量（屬性）2.成員方法 (行為) 3.構造器 （初始化類的對象數據的）4.內部類5.代碼塊 }

• 代碼:

  public class Student {// 成員變量: private 數據類型 變量名;/*** 姓名*/private String name;/*** 年齡*/private int age;// 構造方法: alt + insert -->Constructorpublic Student() {}public Student(String name, int age) {this.name = name;this.age = age;}// set\get方法: alt + insert --> getter and setterpublic 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;}// 成員方法public void show() {System.out.println("我的姓名是:" + name + ",年齡是:" + age);}}

創建并使用對象

• 格式:

  創建對象的格式: 類名 對象名 = new 類名(實參); // 通過new調用構造方法創建對象 訪問成員變量: 對象名.成員變量名 // 調用set\get方法訪問成員變量 訪問成員方法: 無返回值的方法: 對象名.成員方法名(實參);有返回值的方法:直接調用: 對象名.成員方法名(實參); // 不常見賦值調用: 數據類型 變量名 = 對象名.成員方法名(實參); // 開發中常見輸出調用: System.out.println(對象名.成員方法名(實參));// 講課中常見

• 代碼:

  public class Test {public static void main(String[] args) {// 需求:創建學生對象,訪問成員變量和成員方法// 通過調用空參構造方法創建對象Student stu1 = new Student();// 通過調用滿參構造方法創建對象Student stu2 = new Student("李四",18);// 訪問成員變量--set\get方法stu1.setName("張三");stu1.setAge(18);System.out.println(stu1.getName()+","+stu1.getAge());// 張三,18// 訪問成員方法stu1.show();stu2.show();} }

1.2 對象的內存圖

畫圖依據

- 只要是new對象就會在堆區開辟一塊獨立的空間 - 只要調用方法,方法就會被加載進棧 - 只要方法執行完畢,方法就會被彈棧 - 方法執行的流程: 調用方法-->加載方法到棧區-->聲明形參-->把實參傳遞給形參--->執行方法體-->結束方法,彈棧

1.3 匿名對象

概述

• 概述:匿名對象就是指沒有名字的對象。

使用

public class Test {public static void main(String[] args) {/*概述:匿名對象就是指沒有名字的對象。使用: 匿名對象只能使用一次*/// 以前:Student stu1 = new Student("張三",18);// 0x111 有名字的對象method(stu1);// 我的姓名是:張三,年齡是:18method(stu1);// 我的姓名是:張三,年齡是:18// 匿名對象:new Student("李四",19);// 匿名對象method(new Student("李四",19));// 我的姓名是:李四,年齡是:19method(new Student("李四",19));// 我的姓名是:李四,年齡是:19}public static void method(Student stu){stu.show();} }

第2章 繼承

2.1 繼承概述

為什么要有繼承

• 生活中為什么要有繼承

• 程序中為什么還要有繼承

  [外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-Db1GlRhe-1616243060416)(imgs\image-20210317101015832.png)]

繼承的概述

• 繼承在java中指的是“一個類”可以“繼承自”“另一個類”。 "被繼承的類"叫做: 父類/超類/基類，"繼承其他類的類"叫做:子類。繼承后，“子類”中就“擁有”了“父類”中所有的成員(成員變量、成員方法)。 “子類就不需要再定義了”。

繼承的好處

• 提高代碼的復用性;
• 使類與類之間產生了關系,作為多態的前提條件

2.2 繼承的格式

繼承的格式

修飾符 class 子類名 extends 父類名{}

繼承的演示

• 父類

// 父類 public class Person {private String name;private int age;private String gender;public Person(String name, int age, String gender) {this.name = name;this.age = age;this.gender = gender;}public Person() {}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;}public String getGender() {return gender;}public void setGender(String gender) {this.gender = gender;}public void eat() {System.out.println("吃東西...");}public void sleep() {System.out.println("睡覺...");}public void show() {System.out.println("姓名:" + name + ",年齡:" + age + ",性別:" + gender);} }

• 子類

  // 子類 public class Student extends Person { }// 子類 public class Teacher extends Person { }

• 測試類

  public class Test {public static void main(String[] args) {/*繼承的格式:修飾符 class 子類名 extends 父類名{}*/// 創建學生對象Student stu = new Student();// 訪問成員變量stu.setName("張三");stu.setAge(18);stu.setGender("男");// 訪問成員方法stu.eat();stu.sleep();stu.show();} }

2.3 擴展一個文件定義多個類

class Person{}class Student extends Person{}class Teacher extends Person{}public class Test {public static void main(String[] args) {/*一個文件可以定義多個類該文件中只能有一個public修飾的類public修飾的類的類名必須和文件名一致注意: 開發中,一般是一個類對應一個文件,只是目前階段為了更好的理解知識點,所以才一個文件定義多個類*/} }

2.4 繼承后成員訪問規則

繼承后構造方法的訪問規則

• 子類無法繼承父類的構造方法

  class Fu{public Fu(){}public Fu(String name,int age){} }class Zi extends Fu{}public class Test {public static void main(String[] args) {// 繼承后構造方法的訪問規則: 子類無法繼承父類的構造方法// Zi zi = new Zi("張三",18);// 編譯報錯} }

繼承后私有成員的訪問規則

• 子類可以繼承父類的私有成員,但無法直接訪問,可以間接訪問

  • 私有成員變量: 通過set\get方法間接訪問
  • 私有成員方法: 通過其他公共的方法間接訪問
  class Fu {// 私有成員變量private String name;// 私有成員方法private void show() {System.out.println("姓名:" + name);}// 公共的方法public void method(){show();// 調用私有的show()方法} }class Zi extends Fu {}public class Test {public static void main(String[] args) {/*私有成員訪問規則: 子類可以繼承父類的私有成員,但無法直接訪問,可以間接訪問快捷鍵: alt+鼠標左鍵往下拽: 同時操作多行*/// 創建子類對象Zi zi = new Zi();// System.out.println(zi.name);// 編譯報錯// zi.show();// 編譯報錯// 間接訪問show方法: 通過調用method方法,來執行show方法zi.method();} }

繼承后非私有成員的訪問規則

• 子類可以繼承父類的非私有成員,并且可以直接訪問

• 訪問規則: 優先在子類中查找,如果在子類中找到了就直接使用子類的,如果沒有找到就去父類中查找

  class Fu{public int num = 10;public void show(){System.out.println("Fu num:"+num);} }class Zi extends Fu{public int num = 20;public void show(){System.out.println("Zi num:"+num);} }public class Test {public static void main(String[] args) {/*- 子類可以繼承父類的非私有成員,并且可以直接訪問- 訪問規則: 優先在子類中查找,如果在子類中找到了就直接使用子類的,如果沒有找到就去父類中查找*/// 創建子類對象Zi zi = new Zi();// 訪問非私有成員System.out.println(zi.num);// 20zi.show();// Zi num: 20} }

2.5 方法重寫

方法重寫的概念

• 概念:子類中出現與父類一模一樣的方法時（返回值類型，方法名和參數列表都相同）,該方法就是重寫的方法。

• 代碼:

  class Fu{public void method(){System.out.println("Fu method...");} }class Zi extends Fu{// 重寫的method方法public void method(){System.out.println("Zi method...");} }public class Test {public static void main(String[] args) {/*方法重載概述: 在同一個類中,出現多個同名的方法,但參數列表不同,與其他無關方法重寫概述: 子類中出現與父類一模一樣的方法時（返回值類型，方法名和參數列表都相同）,該方法就是重寫的方法。*/} }

重寫的注意事項

• 代碼:

  class Fu{public void method(){System.out.println("Fu method...");} }class Zi extends Fu{@Overridepublic void method(){System.out.println("Zi method...");}public void show(){} }public class Test {public static void main(String[] args) {/*- 方法重寫是發生在父子類之間的關系。- 子類方法重寫父類方法，返回值類型、方法名和參數列表都要一模一樣。- 使用場景:父類的方法,子類有不同的實現,那么子類就需要重寫父類的該方法- 子類方法重寫父類方法，必須要保證權限大于等于父類權限。訪問權限從大到小: public > protected > (默認) > private- 使用@Override注解，檢驗是否重寫成功，重寫注解校驗！- 建議重寫方法都加上這個注解，一方面可以提高代碼的可讀性，一方面可以防止重寫出錯！*/} }

2.6 this和super關鍵字

this關鍵字的三種用法

• 介紹:this可以訪問本類的成員屬性、成員方法、構造方法；

• this訪問本類成員變量: this.成員變量

  class Fu {int num = 10;public void show() {int num = 20;System.out.println("局部變量num:" + num);// 20System.out.println("成員變量num:" + this.num);// 10}}public class Test {public static void main(String[] args) {/*this訪問本類的成員變量: this.成員變量名使用場景: 區別同名的局部變量和成員變量*/Fu f = new Fu();f.show();} }

• this訪問本類成員方法: this.成員方法名(實參);

  class Fu{public void show1(){System.out.println("show1...");}public void show2(){System.out.println("show2...");}public void show3(){System.out.println("show3...");// 調用show1方法,show2方法this.show1();this.show2();} }public class Test {public static void main(String[] args) {// this訪問本類的成員變量: this.成員方法名(實參);Fu f = new Fu();f.show3();} }

• this訪問本類構造方法: this(實參)可以在本類的一個構造方法中，調用另一個構造方法

  class Fu{String name;int age;public Fu(String name) {this();// 訪問本類的空參構造this.name = name;System.out.println("有參構造...");}public Fu() {System.out.println("空參構造....");}public Fu(String name,int age){this(name);this.age = age; }}public class Test {public static void main(String[] args) {/*this訪問本類構造方法: this(實參);注意:1.只能在本類的構造方法中使用this調用本類的其他構造方法2.this調用本類的構造方法必須放在構造方法的第一行3.兩個本類的構造方法不能使用this相互調用*/// 調用Fu類的有參構造創建對象Fu f1 = new Fu("張三");System.out.println("==============");// 調用Fu類的滿參構造創建對象Fu f2 = new Fu("李四",18);System.out.println(f2.name+","+f2.age);// 李四,18} }

super關鍵字的三種用法

• 介紹:super可以訪問父類的成員屬性、成員方法、構造方法；

• super訪問父類的成員變量: super.父類成員變量名

  class Fu {int num = 10; }class Zi extends Fu {int num = 100;public void show() {int num = 1000;System.out.println("局部變量num:" + num);// 1000System.out.println("本類成員變量num:" + this.num);// 100System.out.println("父類成員變量num:" + super.num);// 10} }public class Test {public static void main(String[] args) {// super訪問父類的成員變量: super.成員變量名// 使用場景: 區別父子類中同名的成員變量Zi zi = new Zi();zi.show();} }

• super訪問父類的成員方法: super.成員方法名(實參);

  class Fu{public void show(){System.out.println("Fu show...");}public void show1(){System.out.println("Java...");System.out.println("Java...");System.out.println("Java...");} }class Zi extends Fu{@Overridepublic void show(){System.out.println("Zi show...");}public void method(){// 調用子類的show方法this.show();// 調用父類的show方法super.show();}@Overridepublic void show1() {super.show1();// 調用父類的show1方法System.out.println("itheima...");System.out.println("itheima...");System.out.println("itheima...");} }public class Test {public static void main(String[] args) {// super訪問父類的成員方法: super.成員方法名(實參);// 使用場景: 區別父子類中同名的方法Zi zi = new Zi();zi.method();zi.show1();} }

• super訪問父類的構造方法: super(實參)

  class Fu {private String name;private int age;public Fu() {System.out.println("Fu 空參構造...");}public Fu(String name, int age) {this.name = name;this.age = age;System.out.println("Fu 滿參構造...");}public void show() {System.out.println(name + "," + age);} }class Zi extends Fu {public Zi(){super();// 調用父類的空參構造}public Zi(String name,int age){super(name,age);// 調用父類的滿參構造} }public class Test {public static void main(String[] args) {/*super訪問父類的構造方法: super(實參);注意:1.super訪問父類的構造方法一定要放在子類構造方法的第一行2.子類構造方法默認會調用父類的空參構造方法3.在子類構造方法中調用父類的構造方法,其實就是為了初始化從父類繼承過來的屬性*/// 調用Zi類的空參構造方法創建對象Zi zi1 = new Zi();System.out.println("============");// 創建Zi類對象的時候,為Zi類對象的屬性賦初始值Zi zi2 = new Zi("張三",18);zi2.show();// 張三,18} }

2.7 super的注意事項

super的注意事項一

• super訪問成員變量和成員方法: 優先去父類中找,如果有就直接使用,如果沒有就去爺爺類中找,如果有,就用,依次類推…

  class Ye /*extends Object*/{int num = 10; }class Fu extends Ye{int num = 20; }class Zi extends Fu{int num = 30;public void show(){System.out.println(super.num);// 20} }public class Test {public static void main(String[] args) {/*super訪問成員變量和成員方法: 優先去父類中找,如果有就直接使用,如果沒有就去爺爺類中找,如果有,就用,依次類推...Java中頂層父類是Object類,所有的類都直接或者間接繼承Object類Ye類直接繼承Object類Fu類,Zi類間接繼承Object類*/Zi zi = new Zi();zi.show();} }

super的注意事項二

• 子類的構造方法默認會調用父類的空參構造方法,如果父類中沒有空參構造方法,只定義了有參構造方法,會編譯報錯

  class Fu{String name;int age;public Fu(String name, int age) {this.name = name;this.age = age;} }// 子類編譯報錯: 子類會自動生成空參構造方法,而該空參構造方法中會默認調用父類的空參構造方法,而父類沒有生成空參構造方法 /*class Zi extends Fu{}*/ public class Test {public static void main(String[] args) {/*子類的構造方法默認會調用父類的空參構造方法,如果父類中沒有空參構造方法,只定義了有參構造方法,會編譯報錯*/} }

2.8 繼承體系對象的內存圖

書寫繼承案例

class Fu{int num = 10;public void method(){System.out.println("Fu method");} }class Zi extends Fu{int num = 20;@Overridepublic void method() {System.out.println("Zi method");}public void show(){int num = 30;System.out.println("局部變量num:"+num);// 30System.out.println("本類成員變量num:"+this.num);// 20System.out.println("父類成員變量num:"+super.num);// 10// 訪問本類成員方法methodthis.method();// Zi method// 訪問父類成員方法methodsuper.method();// Fu method} }public class Test {public static void main(String[] args) {Zi zi = new Zi();zi.show();} }

根據案例繪制內存圖

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-J99Pqklt-1616243060417)(imgs\image-20201206151202543.png)]

2.9 繼承的特點

Java只支持單繼承，不支持多繼承。

// 一個類只能有一個父類，不可以有多個父類。 class A {} class B {} class C1 extends A {// ok} class C2 extends A, B {// error}

一個類只能有一個父類,但可以有多個子類。

// A可以有多個子類 class A {} class C1 extends A {} class C2 extends A {}

可以多層繼承。

class A /*extends Object*/{// 爺爺 默認繼承Object類 直接} class B extends A {// 父親 間接} class C extends B {// 兒子}

補充: Java中頂層父類是Object類。所有的類默認繼承Object，作為父類。

class A {} 默認繼承Object類 直接繼承Object

class B extends A{} B的父類就是A,但是A的父類是Object類 間接繼承Object類

第3章 抽象類

3.1 抽象類的概述和定義

抽象類的概述

• 概述: 使用abstract關鍵字修飾的類就是抽象類

抽象類的定義

• 格式:

  修飾符 abstract class 類名{}

抽象類中的成員

• 成員變量,成員方法,構造方法,抽象方法

案例

// 抽象類 public abstract class Person {// 成員變量private String name;private int age;// 構造方法public Person(String name, int age) {this.name = name;this.age = age;}public Person() {}// 成員方法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;}public void show() {System.out.println(name + "," + age);}// 抽象方法 }

3.2 抽象方法的概述和定義

抽象方法的概述

• 概述:沒有方法體,使用abstract修飾的方法就是抽象方法
• 特點:
  • 有抽象方法的類一定是抽象類,抽象類中不一定有抽象方法
  • 強制要求子類重寫

抽象方法的定義

• 格式: 修飾符 abstract 返回值類型 方法名(形參列表);

• 代碼:

  public abstract class Person {// 抽象方法public abstract void eat();public abstract void sleep(); }// 子類是普通類,但必須重寫抽象父類中所有的抽象方法 class Student extends Person{@Overridepublic void eat() {}@Overridepublic void sleep() {} }// 子類是抽象類 abstract class Teacher extends Person{}

3.3 抽象類的注意事項

• 抽象類不能被創建對象，只能用來做“父類”，被子類繼承的，體現的是模板思想 。

  public abstract class Animal{public void sleep(){// 所有子類通用的方法System.out.println("兩眼一閉,就睡覺了...");}public abstract void eat();// 所有子類都需要重寫的方法 }public class Dog extends Animal{@Overridepublic void eat(){System.out.println("狗吃骨頭...");} }public class Cat extends Animal{@Overridepublic void eat(){System.out.println("貓吃魚...");} }

• 抽象類不能被創建對象，但可以有“構造方法”——為從父類繼承過來的屬性初始化。

  public abstract class Animal{private String name;private int age;// 抽象類中的構造方法其實就是給子類調用的public Animal(){}public Animal(String name,int age){this.name = name;this.age = age;} }public class Dog extends Animal{public Dog(){super(); // 調用父類的空參構造}public Dog(String name, int age){super(name,age);// 調用父類的滿參構造} }public class Test{public static void main(String[] args){// 編譯報錯// Animal anl = new Animal();} }

• 抽象類中可以沒有抽象方法,但抽象方法必須定義在抽象類中

  public abstract class Person {// 抽象方法public abstract void eat();public abstract void sleep(); }public abstract class Animal {// 沒有抽象方法 }

• 子類繼承抽象類后,必須重寫抽象類中所有的抽象方法,否則子類必須也是一個抽象類

  public abstract class Person {// 抽象方法public abstract void eat();public abstract void sleep(); }// 子類是普通類,但必須重寫抽象父類中所有的抽象方法 class Student extends Person{@Overridepublic void eat() {}@Overridepublic void sleep() {} }// 子類是抽象類 abstract class Teacher extends Person{}

3.4 模板設計模式

• 設計模式: 設計模式就是解決一些問題時的固定思路，也就是代碼設計思路經驗的總結。

• 模板思想:

  • 模板是通用的東西，抽象類體現的是模板思想。
  • 抽象類中可以是具體實現的方法(通用模板),也可以有抽象方法(填充模板)。
  • 模板中不能決定的行為定義成抽象方法，讓需要使用模板的類（子類）負責重寫抽象方法實現。
  • 模板中能決定的行為就定義成有方法體的方法，讓需要使用模板的類（子類）直接繼承調用即可。

• 案例:

  • 需求:按照下述要求，使用代碼實現
    定義新、老司機類，新、老司機類都有開車功能，開車的步驟一樣，但駕駛時的姿勢不同
    新司機:開門,點火,雙手緊握方向盤,剎車,熄火
    老司機:開門,點火,右手握方向盤左手抽煙,剎車,熄火

  • 代碼:

    // 抽象父類: 體現的就是模板設計思想 public abstract class Driver {// 開車的方法: 通用方法public void driveCar(){System.out.println("開門...");System.out.println("點火...");// 開車的姿勢ziShi();System.out.println("剎車...");System.out.println("熄火...");}// 姿勢的方法: 填充方法public abstract void ziShi();}public class NewDriver extends Driver {@Overridepublic void ziShi() {System.out.println("雙手緊握方向盤...");} }public class OldDriver extends Driver {@Overridepublic void ziShi() {System.out.println("右手握方向盤左手抽煙...");} }public class Test {public static void main(String[] args) {/*需求:按照下述要求，使用代碼實現定義新、老司機類，新、老司機類都有開車功能，開車的步驟一樣，但駕駛時的姿勢不同新司機:開門,點火,雙手緊握方向盤,剎車,熄火老司機:開門,點火,右手握方向盤左手抽煙,剎車,熄火*/// 創建新司機對象NewDriver d1 = new NewDriver();// 創建老司機對象OldDriver d2 = new OldDriver();// 開車d1.driveCar();System.out.println("========");d2.driveCar();} }

第4章 final關鍵字

4.1 final關鍵字的概述和使用

final關鍵字的概述

• 概述: final是一個關鍵字,表示最終,不可變的意思,可以用來修飾類,修飾方法,修飾變量
• 特點:
  • 被final修飾的類不能被繼承
  • 被final修飾的方法不能被重寫
  • 被final修飾的變量不能重復賦值,只能賦值一次

final關鍵字的使用

修飾類

• 格式:

  修飾符 final class 類名{} // 被final修飾的類不能被繼承

• jdk中被final修飾的類: String類,Scanner類,Math類…

• 案例:

  final class Fu{}/*class Zi extends Fu{// 編譯報錯}*/public class Test {public static void main(String[] args) {Fu f = new Fu();} }

修飾方法

• 格式: 修飾符 final 返回值類型 方法名(形參列名){ 方法體 }

• 特點: 被final修飾的方法不能被重寫

• 案例:

  class Fu{public final void show(){System.out.println("Fu show...");} }class Zi extends Fu{// 編譯報錯,因為final修飾的方法不能被重寫/*@Overridepublic void show() {}*/ }public class Test {public static void main(String[] args) {Zi zi = new Zi();zi.show();} }

修飾變量

• 格式:

  • 方式一: final 數據類型 變量名 = 值;
  • 方法二: final 數據類型 變量名; 變量名 = 值;

• 特點:

  • 被final修飾的變量只能賦值一次,不能重復賦值
  • 一般開發中,被final修飾的變量,變量名都是全部字母大寫( fianl修飾的變量其實就是自定義的常量)

• final修飾局部變量案例:

  public class Test {public static void main(String[] args) {// 方式一: final int A = 10;// A = 20; // 編譯報錯,因為final修飾的變量只能賦值一次// 方式二:final int B;B = 100;// B = 200;// 編譯報錯,因為final修飾的變量只能賦值一次} }

• final修飾成員變量案例:

  class Person{public final int NUM = 10;// 開發中常見 }class Student{public final int NUM;public Student(){NUM = 20;}public Student(String name){NUM = 30;// 對象和對象之間的關系是相互獨立的} }public class Test {public static void main(String[] args) {Student stu = new Student();System.out.println(stu.NUM);// 20// stu.NUM = 30;// 編譯報錯,因為final修飾的變量只能賦值一次Student stu2 = new Student("張三");System.out.println(stu2.NUM);// 30// stu2.NUM = 40;// 編譯報錯,因為final修飾的變量只能賦值一次} }

總結

必須練習:1.定義類,創建對象,使用對象----->必須掌握2.繼承的格式,繼承后成員訪問規則--->必須掌握3.this和super關鍵字的三種用法--->必須掌握4.方法重寫--->必須掌握5.抽象類的定義以及使用--->必須掌握6.抽象方法的定義以及使用--->必須掌握7.fianl關鍵字修飾類,方法,變量--->必須掌握- 能夠寫出類的繼承格式修飾符 class 子類名 extends 父類名{}- 能夠說出繼承的特點1.子類繼承父類后,就可以擁有父類所有的成員變量和成員方法2.子類繼承父類后,可以直接訪問從父類繼承過來的非私有成員3.只能單繼承,不能多繼承,但可以多層繼承4.不要為了繼承而繼承,必須滿足is a的關系才去繼承- 能夠說出子類調用父類的成員特點子類繼承父類后,可以直接訪問從父類繼承過來的非私有成員子類繼承父類后,不可以直接訪問從父類繼承過來的私有成員,需要間接訪問- 夠說出方法重寫的概念概念: 子類中出現和父類一模一樣的方法(返回值類型,方法名,參數列表),該方法就是重寫的方法特點:1.子類重寫的方法的權限不能低于父類方法的權限public > protected > 默認 > private2.重寫的方法可以使用@Override注解進行標識,可以起到提高代碼可讀性以及校驗重寫是否正確的作用- 能夠說出this可以解決的問題this可以訪問本類的成員變量: this.成員變量名this可以訪問本類的成員方法: this.成員方法名(實參);this可以訪問本類的構造方法: this(實參);- 能夠說出super可以解決的問題super可以訪問父類的成員變量: super.成員變量名super可以訪問父類的成員方法: super.成員方法名(實參);super可以訪問父類的構造方法: super(實參);- 描述抽象方法的概念概念: 沒有方法體,并且使用abstract修飾的方法- 寫出抽象類的格式概述:使用abstract修飾的類就是抽象類格式:修飾符 abstract class 類名{}特點: 1.抽象類的子類可以是普通類,也可以是抽象類2.抽象類的子類是普通類,必須重寫抽象類中所有的抽象方法,否則抽象類的子類必須也是抽象類3.有抽象方法的類一定是抽象類,但抽象類中不一定有抽象方法- 寫出抽象方法的格式格式: 修飾符 abstract 返回值類型 方法名(實參);- 能夠說出父類抽象方法的存在意義強制要求子類重寫- 描述final修飾的類的特點不能被繼承- 描述final修飾的方法的特點不能被重寫- 描述final修飾的變量的特點只能賦值一次,不能重復賦值

總結

以上是生活随笔為你收集整理的day01-【复习回顾、继承、抽象类、模板设计模式】的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。