今日內(nèi)容
- 面向?qū)ο髲?fù)習(xí)
- 類的創(chuàng)建------>必須掌握
- 對(duì)象的創(chuàng)建和使用------>必須掌握
- 匿名對(duì)象
- 繼承
- 如何繼承---繼承的格式------>必須掌握
- 繼承之后成員的訪問(wèn)特點(diǎn)------>必須掌握
- 方法重寫以及this和super關(guān)鍵字------>理解并會(huì)使用
- 抽象類
- 定義抽象類------>必須掌握
- 抽象方法的定義和使用------>必須掌握
- 模板設(shè)計(jì)模式------>必須掌握
- final 關(guān)鍵字
- 修飾類格式和特點(diǎn)
- 修飾方法格式和特點(diǎn)
- 修飾變量格式和特點(diǎn)------>必須掌握
第1章 復(fù)習(xí)回顧
1.1 類和對(duì)象
定義一個(gè)類
-
格式:
修飾符 class 類名{ // 成員變量 // 成員方法 // 構(gòu)造方法 // 代碼塊 // 內(nèi)部類 } -
代碼:
public class Person { // 成員變量 private String name; private int age; // 構(gòu)造方法 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); } }
創(chuàng)建并使用對(duì)象
-
格式:
創(chuàng)建對(duì)象: 類名 對(duì)象名 = new 類名(實(shí)參); 使用對(duì)象: 訪問(wèn)成員變量: 對(duì)象名.成員變量名 訪問(wèn)成員方法: 無(wú)返回值的方法: 對(duì)象名.方法名(實(shí)參); 有返回值的方法: 直接調(diào)用: 對(duì)象名.方法名(實(shí)參); 賦值調(diào)用: 數(shù)據(jù)類型 變量名 = 對(duì)象名.方法名(實(shí)參); 輸出調(diào)用: System.out.println(對(duì)象名.方法名(實(shí)參)); -
代碼:
public class Test { public static void main(String[] args) { // 通過(guò)調(diào)用空參構(gòu)造方法,創(chuàng)建Person類的對(duì)象 Person p1 = new Person(); // 通過(guò)調(diào)用滿參構(gòu)造方法,創(chuàng)建Person類的對(duì)象 Person p2 = new Person("李四", 19); // 使用p1對(duì)象調(diào)用方法 p1.setName("張三"); p1.setAge(18); String name = p1.getName(); System.out.println("姓名:" + name); System.out.println("年齡:" + p1.getAge()); // 使用p2調(diào)用show方法 p2.show(); } }
1.2 對(duì)象的內(nèi)存圖
畫圖依據(jù)
- 只要是new對(duì)象就會(huì)在堆區(qū)開(kāi)辟一塊獨(dú)立的空間
- 只要調(diào)用方法,方法就會(huì)被加載進(jìn)棧
- 只要方法執(zhí)行完畢,方法就會(huì)被彈棧
- 方法執(zhí)行的流程: 調(diào)用方法-->加載方法到棧區(qū)-->聲明形參-->把實(shí)參傳遞給形參--->執(zhí)行方法體-->結(jié)束方法,彈棧
內(nèi)存圖
1.3 匿名對(duì)象
概述
- 概述:匿名對(duì)象指的就是沒(méi)有名字的對(duì)象.
- 特點(diǎn): 只能使用一次
使用
import com.itheima.demo1_復(fù)習(xí)類的定義和對(duì)象的使用.Person;
public class Test {
public static void main(String[] args) {
/*
- 概述:匿名對(duì)象指的就是沒(méi)有名字的對(duì)象.
- 特點(diǎn): 只能使用一次
- 使用: 如果某個(gè)類的對(duì)象只要使用一次,就可以使用匿名對(duì)象
*/
// 創(chuàng)建Person對(duì)象---有名字
Person p1 = new Person("張三",18);
p1.show();
System.out.println("-------------------");
// 匿名對(duì)象
new Person("李四",19).show();
new Person("李四",19).show();
// 這是2個(gè)不同的對(duì)象,只是所有屬性值一樣,因?yàn)橹灰猲ew就會(huì)在堆區(qū)開(kāi)辟一塊空間創(chuàng)建該對(duì)象
System.out.println("-------------------");
// 調(diào)用method方法
//以前的方式---使用有名字的對(duì)象
//Person p2 = new Person("老王",20);
//method(p2);
//現(xiàn)在的方式----使用匿名對(duì)象
method(new Person("老王",20));
}
public static void method(Person p){
p.show();
}
}
第2章 繼承
2.1 繼承概述
為什么要有繼承
-
生活中為什么要有繼承
-
程序中為什么還要有繼承
繼承的概述
- 繼承在java中指的是“一個(gè)類”可以“繼承自”“另一個(gè)類”。 "被繼承的類"叫做: 父類/超類/基類，"繼承其他類的類"叫做:子類。繼承后，“子類”中就“擁有”了“父類”中所有的成員(成員變量、成員方法)。 “子類就不需要再定義了”。
繼承的好處
- 提高代碼的復(fù)用性;
- 使類與類之間產(chǎn)生了關(guān)系,作為多態(tài)的前提條件
2.2 繼承的格式
繼承的格式
修飾符 class 子類名 extends 父類名{
}
繼承的演示
-
父類
public class Person { // 成員變量 private String name; private int age; // 構(gòu)造方法 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); } } -
子類
public class Student extends Person { } -
測(cè)試類
public class Test { public static void main(String[] args) { // 創(chuàng)建Student對(duì)象 Student stu = new Student(); // 調(diào)用set\get方法以及show方法 stu.setName("張三"); stu.setAge(18); System.out.println(stu.getName()+","+stu.getAge()); stu.show(); } }
2.3 擴(kuò)展一個(gè)文件定義多個(gè)類
class Person{
String name;
}
class Student extends Person{
}
public class Test {
public static void main(String[] args) {
/*
1.一個(gè)文件中是可以定義多個(gè)類的
2.注意:
2.1 一個(gè)文件中定義多個(gè)類,只能有一個(gè)public修飾的類
2.2 使用public修飾的類的類名必須和文件名一致
2.3 工作中,都是一個(gè)類對(duì)應(yīng)一個(gè)文件,不要一個(gè)文件中定義多個(gè)類,現(xiàn)在只是過(guò)渡一下
*/
Student stu = new Student();
stu.name = "zs";
System.out.println(stu.name);// zs
}
}
2.4 繼承后成員訪問(wèn)規(guī)則
繼承后構(gòu)造方法的訪問(wèn)規(guī)則
-
子類無(wú)法繼承父類的構(gòu)造方法
class Person{ String name; int age; public Person(String name, int age) { this.name = name; this.age = age; } public Person() { } } class Student extends Person{ } public class Test { public static void main(String[] args) { // 子類是無(wú)法繼承父類的構(gòu)造方法 // 創(chuàng)建Student對(duì)象 //Student stu = new Student("張三",18);// 編譯報(bào)錯(cuò) } }
繼承后私有成員的訪問(wèn)規(guī)則
-
子類可以繼承父類的私有成員,但無(wú)法直接訪問(wèn),可以間接訪問(wèn)
-
私有成員變量: 通過(guò)set\get方法間接訪問(wèn)
-
私有成員方法: 通過(guò)其他公共的方法間接訪問(wèn)
class Person{
private String name;private void method(){ System.out.println("Person method方法..."); } public String getName() { return name; } public void setName(String name) { this.name = name; } public void show(){ method(); }}
class Student extends Person{
}
public class Test {
public static void main(String[] args) {
/*
子類可以繼承父類的私有成員,但無(wú)法直接訪問(wèn),可以間接訪問(wèn)
- 私有成員變量: 通過(guò)set\get方法間接訪問(wèn)
- 私有成員方法: 通過(guò)其他公共的方法間接訪問(wèn)
*/
// 創(chuàng)建Student對(duì)象
Student stu = new Student();
//System.out.println(stu.name);// 編譯報(bào)錯(cuò)
//stu.method();// 編譯報(bào)錯(cuò)// 給從父類繼承過(guò)來(lái)的name屬性賦值和取值 stu.setName("張三"); System.out.println("name:"+stu.getName()); // 調(diào)用從父類繼承過(guò)來(lái)的method方法---可以調(diào)用公共的show方法 stu.show();// Person method方法... }}
-
繼承后非私有成員的訪問(wèn)規(guī)則
-
子類可以繼承父類的非私有成員,并且可以直接訪問(wèn)
-
訪問(wèn)規(guī)則: 優(yōu)先在子類中查找,如果在子類中找到了就直接使用子類的,如果沒(méi)有找到就去父類中查找...
class Person{ String name = "張三"; public void method(){ System.out.println("Person method..."); } } class Student extends Person{ String name = "李四"; public void method(){ System.out.println("Student method..."); } } public class Test { public static void main(String[] args) { /* - 子類可以繼承父類的非私有成員,并且可以直接訪問(wèn) - 訪問(wèn)規(guī)則: 優(yōu)先在子類中查找,如果在子類中找到了就直接使用子類的,如果沒(méi)有找到就去父類中查找... */ // 創(chuàng)建Student對(duì)象 Student stu = new Student(); // 訪問(wèn)從父類繼承過(guò)來(lái)的非私有成員變量 System.out.println(stu.name);// 李四 // 訪問(wèn)從父類繼承過(guò)來(lái)的非私有成員方法 stu.method();// Student method... } }
2.5 方法重寫
方法重寫的概念
-
概念:子類中出現(xiàn)與父類一模一樣的方法時(shí)（返回值類型，方法名和參數(shù)列表都相同）,該方法就是重寫的方法。
-
代碼:
class Person{ public void method(){ System.out.println("Person method..."); } } class Student extends Person{ // 重寫的方法 @Override public void method(){ System.out.println("Student method..."); } public void show(){ System.out.println("Student show..."); } } public class Test { public static void main(String[] args) { /* 概念:子類中出現(xiàn)與父類一模一樣的方法時(shí)（返回值類型，方法名和參數(shù)列表都相同）,該方法就是重寫的方法。 特點(diǎn): 1.重寫的方法可以使用@Override注解進(jìn)行標(biāo)識(shí) 2.子類繼承父類的成員方法,如果子類有不同的實(shí)現(xiàn),子類就可以重寫從父類繼承過(guò)來(lái)的方法 3.子類重寫父類方法的訪問(wèn)權(quán)限,不能低于父類方法的訪問(wèn)權(quán)限 訪問(wèn)權(quán)限修飾符的大小: public > protected > 空的(默認(rèn)) > private */ } }
重寫的注意事項(xiàng)
- 方法重寫是發(fā)生在父子類之間的關(guān)系。
- 子類方法重寫父類方法，返回值類型、方法名和參數(shù)列表都要一模一樣。
- 使用場(chǎng)景:父類的方法,子類有不同的實(shí)現(xiàn),那么子類就需要重寫父類的該方法
- 子類方法重寫父類方法，必須要保證權(quán)限大于等于父類權(quán)限。
訪問(wèn)權(quán)限從大到小: public > protected > (默認(rèn)) > private - 使用@Override注解，檢驗(yàn)是否重寫成功，重寫注解校驗(yàn)！
- 建議重寫方法都加上這個(gè)注解，一方面可以提高代碼的可讀性，一方面可以防止重寫出錯(cuò)！
2.6 this和super關(guān)鍵字
this關(guān)鍵字的三種用法
-
介紹:this可以訪問(wèn)本類的成員屬性、成員方法、構(gòu)造方法；
-
this訪問(wèn)本類成員變量: this.成員變量
class Fu { int num = 10; public void method(){ int num = 20; System.out.println("訪問(wèn)局部變量num:"+num);// 20 System.out.println("訪問(wèn)成員變量num:"+this.num);// 10 } } public class Test { public static void main(String[] args) { // this修飾本類成員變量: this.成員變量名 // 作用: 用了區(qū)別同名的成員變量和局部變量 // 創(chuàng)建Fu類對(duì)象,調(diào)用method方法 Fu f = new Fu(); f.method(); //new Fu().method(); } } -
this訪問(wèn)本類成員方法: this.成員方法名(實(shí)參);
class Fu { public void method1(){ System.out.println("Fu method1..."); } public void method2(){ System.out.println("Fu method2..."); } public void show(){ // 調(diào)用Fu類中method1,method2方法 this.method1(); this.method2(); } } public class Test { public static void main(String[] args) { // this訪問(wèn)本類的成員方法: this.方法名(實(shí)參); Fu f = new Fu(); f.show(); } } -
this訪問(wèn)本類構(gòu)造方法: 在本類的一個(gè)構(gòu)造方法中，調(diào)用本類另一個(gè)構(gòu)造方法
- 空參構(gòu)造:
this(); - 有參構(gòu)造:
this(實(shí)參); - 注意:
- 1.調(diào)用本類的構(gòu)造方法需要在本類的一個(gè)構(gòu)造方法中
- 2.調(diào)用本類的構(gòu)造方法的代碼必須放在構(gòu)造方法的第一行
- 3.調(diào)用本類的構(gòu)造方法不能2個(gè)構(gòu)造方法之間相互調(diào)用
class Fu{ String name; int age; public Fu() { System.out.println("Fu 空參構(gòu)造..."); } public Fu(String name) { this.name = name; } public Fu(int age) { this.age = age; } public Fu(String name, int age) { // 訪問(wèn)本類的空參構(gòu)造 //this(); // 訪問(wèn)本類的有參構(gòu)造 this(name); //this.name = name; this.age = age; } } public class Test { public static void main(String[] args) { /* this訪問(wèn)本類構(gòu)造方法: **在本類的一個(gè)構(gòu)造方法中，調(diào)用本類另一個(gè)構(gòu)造方法** - 空參構(gòu)造: `this();` - 有參構(gòu)造: `this(實(shí)參);` - 注意: - 1.調(diào)用本類的構(gòu)造方法需要在本類的一個(gè)構(gòu)造方法中 - 2.調(diào)用本類的構(gòu)造方法的代碼必須放在構(gòu)造方法的第一行 - 3.調(diào)用本類的構(gòu)造方法不能2個(gè)構(gòu)造方法之間相互調(diào)用 */ Fu f = new Fu("張三", 18); System.out.println(f.name+","+f.age); } } - 空參構(gòu)造:
super關(guān)鍵字的三種用法
-
介紹:super可以訪問(wèn)父類的成員屬性、成員方法、構(gòu)造方法；
-
super訪問(wèn)父類的成員變量: super.父類成員變量名
class Fu { int num = 10; } class Zi extends Fu { int num = 20; public void show() { int num = 30; System.out.println("笨類中局部變量num的值:" + num); System.out.println("本類中成員變量num的值:" + this.num); System.out.println("父類中成員變量num的值:" + super.num); } } public class Test { public static void main(String[] args) { // super訪問(wèn)父類的成員變量: super.父類成員變量名 // 創(chuàng)建Zi類對(duì)象 Zi zi = new Zi(); zi.show(); } } -
super訪問(wèn)父類的成員方法: super.成員方法名(實(shí)參);
class Fu { public void method(){ System.out.println("Person HelloWorld..."); } } class Zi extends Fu { @Override public void method() { // 訪問(wèn)父類的method方法 super.method(); System.out.println("Student HelloWorld..."); } public void show(){ // 訪問(wèn)本類的method方法 this.method(); // 訪問(wèn)父類的method方法 super.method(); } } public class Test { public static void main(String[] args) { // super訪問(wèn)父類的成員方法: super.成員方法名(實(shí)參); // 創(chuàng)建Zi類對(duì)象 Zi zi = new Zi(); zi.method(); System.out.println("------"); zi.show(); } } -
super訪問(wèn)父類的構(gòu)造方法: super(實(shí)參)
class Fu{ private String name; private int age; public Fu() { System.out.println("Fu 空參構(gòu)造..."); } public Fu(String name, int age) { this.name = name; this.age = age; System.out.println("Fu 有參構(gòu)造..."); } } class Zi extends Fu{ public Zi() { super(); } public Zi(String name,int age){ // 調(diào)用父類的有參構(gòu)造方法 super(name,age); } } public class Test { public static void main(String[] args) { /* super訪問(wèn)父類構(gòu)造方法: **在子類的一個(gè)構(gòu)造方法中，調(diào)用父類的構(gòu)造方法** - 空參構(gòu)造: `super();` - 有參構(gòu)造: `super(實(shí)參);` - 注意: - 1.調(diào)用父類的構(gòu)造方法需要在子類的一個(gè)構(gòu)造方法中 - 2.調(diào)用父類的構(gòu)造方法的代碼必須放在子類構(gòu)造方法的第一行 */ // 通過(guò)空參構(gòu)造方法創(chuàng)建Zi類對(duì)象 //Zi zi1 = new Zi(); // 通過(guò)有參構(gòu)造方法創(chuàng)建Zi類對(duì)象 //Zi zi2 = new Zi("張三",18); } }
2.7 super的注意事項(xiàng)
super的注意事項(xiàng)一
-
super訪問(wèn)成員變量和成員方法: 優(yōu)先去父類中找,如果有就直接使用,如果沒(méi)有就去爺爺類中找,如果有,就用,依次類推...
class Ye /*extends Object*/{ // Object類是根類 int num = 10; public void method(){ System.out.println("Ye method..."); } } class Fu extends Ye{ /*int num = 20; public void method(){ System.out.println("Fu method..."); }*/ } class Zi extends Fu{ public void show(){ System.out.println(super.num); super.method(); } } public class Test1 { public static void main(String[] args) { /* #### super的注意事項(xiàng)一 - super訪問(wèn)成員變量和成員方法: 優(yōu)先去父類中找,如果有就直接使用,如果沒(méi)有就去爺爺類中找,如果有,就用,依次類推... */ // 創(chuàng)建Zi類對(duì)象 Zi zi = new Zi(); // 使用zi類對(duì)象訪問(wèn)num成員方法 System.out.println(zi.num); // 使用zi類對(duì)象訪問(wèn)method成員方法 zi.method(); System.out.println("---------------"); // 使用zi類對(duì)象訪問(wèn)show成員方法 zi.show(); } }
super的注意事項(xiàng)二
-
子類的構(gòu)造方法默認(rèn)會(huì)調(diào)用父類的空參構(gòu)造方法,如果父類中沒(méi)有空參構(gòu)造方法,只定義了有參構(gòu)造方法,會(huì)編譯報(bào)錯(cuò)
class Fu{ public Fu() { System.out.println("Fu 空參構(gòu)造..."); } public Fu(String name,int age) { System.out.println("Fu 有參構(gòu)造..."); } } class Zi extends Fu{ public Zi() { //super();// 不寫,默認(rèn)也有 } public Zi(String name){ //super();// 不寫,默認(rèn)也有 } } public class Test { public static void main(String[] args) { /* #### super的注意事項(xiàng)二 - 子類的構(gòu)造方法默認(rèn)會(huì)調(diào)用父類的空參構(gòu)造方法 - 如果父類中沒(méi)有空參構(gòu)造方法,只定義了有參構(gòu)造方法,子類中會(huì)編譯報(bào)錯(cuò) */ // 通過(guò)zi類空參構(gòu)造方法創(chuàng)建對(duì)象 Zi zi1 = new Zi(); // 通過(guò)zi類有參構(gòu)造方法創(chuàng)建對(duì)象 Zi zi2 = new Zi("itheima"); } }
2.8 繼承體系對(duì)象的內(nèi)存圖
書寫繼承案例
class Fu{
int num = 10;
public void method(){
System.out.println("Fu method...");
}
}
class Zi extends Fu{
int num = 20;
@Override
public void method() {
System.out.println("Zi method...");
}
public void show(){
int num = 30;
System.out.println("局部變量num的值:"+num);
System.out.println("本類成員變量num的值:"+this.num);
System.out.println("父類成員變量num的值:"+super.num);
// 調(diào)用本類的成員方法
this.method();
// 調(diào)用父類的成員方法
super.method();
}
}
public class Test {
public static void main(String[] args) {
// 創(chuàng)建Zi類對(duì)象
Zi zi = new Zi();
// 調(diào)用show方法
zi.show();
}
}
根據(jù)案例繪制內(nèi)存圖
2.9 繼承的特點(diǎn)
- Java只支持單繼承，不支持多繼承。
public class A{}
public class B{}
public class C extends A extends B{} // 都是錯(cuò)誤的
public class C extends A , B{} // 都是錯(cuò)誤的
- 一個(gè)類只能有一個(gè)父類,但可以有多個(gè)子類。
public class A{}
public class B extends A{}
public class C extends A{}
- 可以多層繼承。
public class A{}
public class B extends A{}
public class C extends B{}
補(bǔ)充: Java中頂層父類是Object類。所有的類默認(rèn)繼承Object，作為父類。
class A {} 默認(rèn)繼承Object類 直接繼承Object
class B extends A{} B的父類就是A,但是A的父類是Object類 間接繼承Object類
第3章 抽象類
3.1 抽象類的概述和定義
抽象類的概述
- 概述: 使用abstract修飾的類就是抽象類
- 特點(diǎn):
- 抽象類不能創(chuàng)建對(duì)象
- 抽象類中可以寫抽象方法
抽象類的定義
-
格式:
修飾符 abstract class 類名{ // 成員變量 // 成員方法 // 構(gòu)造方法 // 代碼塊 // 內(nèi)部類 // 抽象方法 }
案例
public abstract class Animal {
// 成員變量
private String name;
// 構(gòu)造方法
public Animal(String name) {
this.name = name;
}
public Animal() {
}
// 成員方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show() {
System.out.println("name:" + name);
}
// 抽象方法
// 代碼塊
// 內(nèi)部類
}
3.2 抽象方法的概述和定義
抽象方法的概述
- 概述: 沒(méi)有方法體,并且使用abstract修飾的方法就是抽象方法
抽象方法的定義
-
格式:
修飾符 abstract 返回值類型 方法名(形參列表); -
案例:
public abstract void method();
3.3 抽象類的注意事項(xiàng)
-
抽象類不能被創(chuàng)建對(duì)象，只能用來(lái)做“父類”，被子類繼承的，體現(xiàn)的是模板思想 。
abstract class Animal{ } public class Test { public static void main(String[] args) { // 抽象類不能被創(chuàng)建對(duì)象，只能用來(lái)做“父類”，被子類繼承的，體現(xiàn)的是模板思想 。 //Animal anl = new Animal();// 編譯報(bào)錯(cuò) } } -
抽象類不能被創(chuàng)建對(duì)象，但可以有“構(gòu)造方法”——目的:給子類初始化從父類繼承過(guò)來(lái)的屬性。
abstract class Animal{ private String name; private int age; public Animal() { } public Animal(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } } class Dog extends Animal{ public Dog(){ } public Dog(String name,int age){ super(name,age); } } public class Test { public static void main(String[] args) { // 抽象類不能被創(chuàng)建對(duì)象，但可以有“構(gòu)造方法”——目的:給子類初始化從父類繼承過(guò)來(lái)的屬性。 // 說(shuō)白了就是抽象父類中的構(gòu)造方法就是供子類構(gòu)造方法來(lái)調(diào)用的 // 需求: 創(chuàng)建Dog類對(duì)象,并初始化從Animal類中繼承過(guò)來(lái)的成員變量 Dog dog = new Dog("旺財(cái)",2); System.out.println(dog.getName()); System.out.println(dog.getAge()); } } -
抽象類中可以沒(méi)有抽象方法,但抽象方法必須定義在抽象類中
// 抽象類 abstract class Animal{ // 抽象類中可以沒(méi)有抽象方法 } abstract class Person{ // 但抽象方法必須定義在抽象類中 public abstract void method(); } public class Test { public static void main(String[] args) { // 抽象類中可以沒(méi)有抽象方法,但抽象方法必須定義在抽象類中 } } -
子類繼承抽象類后,必須重寫抽象類中所有的抽象方法,否則子類必須也是一個(gè)抽象類
abstract class Animal{ public abstract void eat(); public abstract void drink(); } // 抽象類的子類是抽象類,可以不用重新抽象類中的抽象方法 abstract class Cat extends Animal{ } // 抽象類的子類是普通類,那就必須重寫抽象類中所有的抽象方法 class Dog extends Animal{ @Override public void eat() { } @Override public void drink() { } } public class Test { public static void main(String[] args) { // 子類繼承抽象類后,必須重寫抽象類中所有的抽象方法,否則子類必須也是一個(gè)抽象類 } }
3.4 模板設(shè)計(jì)模式
-
設(shè)計(jì)模式: 設(shè)計(jì)模式就是解決一些問(wèn)題時(shí)的固定思路，也就是代碼設(shè)計(jì)思路經(jīng)驗(yàn)的總結(jié)。
-
模板思想:
-
模板是通用的東西，抽象類體現(xiàn)的是模板思想。
-
抽象類中可以是具體實(shí)現(xiàn)的方法(通用模板),也可以有抽象方法(填充模板)。
-
模板中能決定的行為就定義成有方法體的方法，讓需要使用模板的類（子類）直接繼承調(diào)用即可。
-
模板中不能決定的行為定義成抽象方法，讓需要使用模板的類（子類）負(fù)責(zé)重寫抽象方法實(shí)現(xiàn)。
-
-
案例:
-
需求:按照下述要求，使用代碼實(shí)現(xiàn)
定義新、老司機(jī)類，新、老司機(jī)類都有開(kāi)車功能，開(kāi)車的步驟一樣，但駕駛時(shí)的姿勢(shì)不同
新司機(jī):開(kāi)門,點(diǎn)火,雙手緊握方向盤,剎車,熄火
老司機(jī):開(kāi)門,點(diǎn)火,右手握方向盤左手抽煙,剎車,熄火 -
代碼:
// 抽象父類 public abstract class Driver { // 通用模板(有方法體的方法) public void drive(){ System.out.println("開(kāi)門"); System.out.println("點(diǎn)火"); // 姿勢(shì) ziShi(); System.out.println("剎車"); System.out.println("熄火"); } // 填充模板(沒(méi)有方法體的方法) public abstract void ziShi(); } public class NewDriver extends Driver { @Override public void ziShi() { System.out.println("雙手緊握方向盤"); } } public class OldDriver extends Driver { @Override public void ziShi() { System.out.println("右手握方向盤左手抽煙"); } } package com.itheima.demo12_模板設(shè)計(jì)模式; public class Test { public static void main(String[] args) { // 創(chuàng)建新司機(jī)對(duì)象,調(diào)用開(kāi)車的方法 new NewDriver().drive(); // 創(chuàng)建老司機(jī)對(duì)象,調(diào)用開(kāi)車的方法 new OldDriver().drive(); } }
-
第4章 final關(guān)鍵字
4.1 final關(guān)鍵字的概述和使用
final關(guān)鍵字的概述
- 概述: final是一個(gè)關(guān)鍵字,表示最終,不可變的意思,可以用來(lái)修飾類,修飾方法,修飾變量
- 特點(diǎn):
- 被final修飾的類不能被繼承
- 被final修飾的方法不能被重寫
- 被final修飾的變量不能重復(fù)賦值,只能賦值一次
final關(guān)鍵字的使用
修飾類
-
格式:
修飾符 final class 類名{ } -
案例:
final class Fu{ } class Zi /*extends Fu*/{ // 編譯報(bào)錯(cuò),被final修飾的類不能被繼承 } public class Test { public static void main(String[] args) { } }
修飾方法
-
格式:
修飾符 final 返回值類型 方法名(形成列表){ 方法體 } -
特點(diǎn): 被final修飾的方法不能被重寫
-
案例:
class Fu{ public final void method(){ System.out.println("Fu method..."); } } class Zi extends Fu{ // 編譯報(bào)錯(cuò),因?yàn)楸籪inal修飾的方法不能被重寫 /*@Override public void method(){ System.out.println("Zi method..."); }*/ } public class Test { public static void main(String[] args) { } }
修飾變量
-
格式:
- 方式一:
final 數(shù)據(jù)類型 變量名 = 值; - 方式二:
final 數(shù)據(jù)類型 變量名; 變量名 = 值;
- 方式一:
-
特點(diǎn):
- 被final修飾的變量不能重復(fù)賦值,只能賦值一次
- 被final修飾的變量其實(shí)也叫作常量,常量命名規(guī)范是所有字母大寫
-
final修飾局部變量案例:
public class Test1_局部變量 { public static void main(String[] args) { // 定義一個(gè)NUM局部變量并賦值 final int NUM = 10; // 重新給num賦值 // NUM = 20;// 編譯報(bào)錯(cuò),被final修飾的變量不能重復(fù)賦值,只能賦值一次 // 打印輸出 System.out.println(NUM);// 10 System.out.println("-----------------"); final int A; A = 20; //A = 30;// 編譯報(bào)錯(cuò),被final修飾的變量不能重復(fù)賦值,只能賦值一次 System.out.println(A);// 20 } } -
final修飾成員變量案例:
方式一: class Person{ // final 數(shù)據(jù)類型 變量名 = 值; final int AGE = 10; } 方式二: class Animal{ final int age; public Animal(int age) { this.age = age; } public Animal() { age = 20; } // 只要保證age成員變量出現(xiàn)的時(shí)候有值 } public class Test2_成員變量 { public static void main(String[] args) { /* 成員變量和局部變量的區(qū)別: 1.成員變量定義在類中方法外,局部變量定義在方法中或者方法聲明之上(參數(shù)) 2.成員變量是在堆區(qū),局部變量是在棧區(qū) 3.成員變量是隨著對(duì)象的創(chuàng)建而存在,隨著對(duì)象的銷毀而銷毀; 局部變量是隨著方法的調(diào)用而存在,隨著方法的彈棧而銷毀 4.成員變量有默認(rèn)值,而局部變量沒(méi)有默認(rèn)值 */ Animal anl = new Animal(20); //anl.age = 100;// 編譯報(bào)錯(cuò),因?yàn)楸籪inal修飾的變量不能重復(fù)賦值,只能賦值一次 System.out.println(anl.age); } }
總結(jié)
必須練習(xí):
1.定義類,創(chuàng)建對(duì)象,使用對(duì)象----->必須掌握
2.繼承的格式,繼承后成員訪問(wèn)規(guī)則--->必須掌握
3.this和super關(guān)鍵字的三種用法--->必須掌握
4.方法重寫--->必須掌握
5.抽象類的定義以及使用--->必須掌握
6.抽象方法的定義以及使用--->必須掌握
7.fianl關(guān)鍵字修飾類,方法,變量--->必須掌握
- 能夠?qū)懗鲱惖睦^承格式
修飾符 class 子類名 extends 父類名{}
- 能夠說(shuō)出繼承的特點(diǎn)
1.子類繼承父類后,就可以擁有父類所有的成員變量和成員方法
2.子類繼承父類后,可以直接訪問(wèn)從父類繼承過(guò)來(lái)的非私有成員
3.只能單繼承,不能多繼承,但可以多層繼承
4.不要為了繼承而繼承,必須滿足is a的關(guān)系才去繼承
- 能夠說(shuō)出子類調(diào)用父類的成員特點(diǎn)
子類繼承父類后,可以直接訪問(wèn)從父類繼承過(guò)來(lái)的非私有成員
子類繼承父類后,不可以直接訪問(wèn)從父類繼承過(guò)來(lái)的私有成員,需要間接訪問(wèn)
- 夠說(shuō)出方法重寫的概念
概念: 子類中出現(xiàn)和父類一模一樣的方法(返回值類型,方法名,參數(shù)列表),該方法就是重寫的方法
特點(diǎn):
1.子類重寫的方法的權(quán)限不能低于父類方法的權(quán)限
public > protected > 默認(rèn) > private
2.重寫的方法可以使用@Override注解進(jìn)行標(biāo)識(shí),可以起到提高代碼可讀性以及校驗(yàn)重寫是否正確的作用
- 能夠說(shuō)出this可以解決的問(wèn)題
this可以訪問(wèn)本類的成員變量: this.成員變量名
this可以訪問(wèn)本類的成員方法: this.成員方法名(實(shí)參);
this可以訪問(wèn)本類的構(gòu)造方法: this(實(shí)參);
- 能夠說(shuō)出super可以解決的問(wèn)題
super可以訪問(wèn)父類的成員變量: super.成員變量名
super可以訪問(wèn)父類的成員方法: super.成員方法名(實(shí)參);
super可以訪問(wèn)父類的構(gòu)造方法: super(實(shí)參);
- 描述抽象方法的概念
概念: 沒(méi)有方法體,并且使用abstract修飾的方法
- 寫出抽象類的格式
概述:使用abstract修飾的類就是抽象類
格式:修飾符 abstract class 類名{}
特點(diǎn):
1.抽象類的子類可以是普通類,也可以是抽象類
2.抽象類的子類是普通類,必須重寫抽象類中所有的抽象方法,否則抽象類的子類必須也是抽象類
3.有抽象方法的類一定是抽象類,但抽象類中不一定有抽象方法
- 寫出抽象方法的格式
格式: 修飾符 abstract 返回值類型 方法名(實(shí)參);
- 能夠說(shuō)出父類抽象方法的存在意義
強(qiáng)制要求子類重寫
- 描述final修飾的類的特點(diǎn)
不能被繼承
- 描述final修飾的方法的特點(diǎn)
不能被重寫
- 描述final修飾的變量的特點(diǎn)
只能賦值一次,不能重復(fù)賦值
浙公網(wǎng)安備 33010602011771號(hào)