08面向物件_繼承_方法_final
08.01_面向物件(程式碼塊的概述和分類)(瞭解)(面試的時候會問,開發很少用)
- A:程式碼塊概述
- 在Java中,使用{}括起來的程式碼被稱為程式碼塊。
- B:程式碼塊分類
- 根據其位置和宣告的不同,可以分為區域性程式碼塊,構造程式碼塊,靜態程式碼塊,同步程式碼塊(多執行緒講解)。
- C:常見程式碼塊的應用
- a:區域性程式碼塊
- 在方法中出現;限定變數生命週期,及早釋放,提高記憶體利用率
- b:構造程式碼塊 (初始化塊)
- 在類中方法外出現;多個構造方法方法中相同的程式碼存放到一起,每次呼叫構造都執行,並且在構造方法前執行
- c:靜態程式碼塊
- 在類中方法外出現,並加上static修飾;用於給類進行初始化,在載入的時候就執行,並且只執行一次。
- 一般用於載入驅動
- a:區域性程式碼塊
class Demo1_Code { public static void main(String[] args) { {//區域性程式碼塊 int x = 10; //限定變數的宣告週期 System.out.println(x); } Student s1 = new Student(); System.out.println("---------------"); Student s2 = new Student("張三",23); } static {//靜態程式碼塊,即使在主方法下面,但是優先於主方法執行 System.out.println("我是在主方法類中的靜態程式碼塊"); } } class Student { private String name; private int age; public Student(){ //study(); System.out.println("空參構造"); } //空參構造 public Student(String name,int age) {//有參構造 //study(); this.name = name; this.age = age; System.out.println("有參構造"); } public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; } { //構造程式碼塊:每建立一次物件就會執行一次,優先於建構函式執行 //System.out.println("構造程式碼塊"); study(); } public void study() { System.out.println("學生學習"); } static { //隨著類載入而載入,且只執行一次,即使建立兩個物件,也只執行一次 System.out.println("我是靜態程式碼塊"); //作用:用來給類進行初始化,一般用來載入驅動 } //靜態程式碼塊是優先於主方法執行 }
08.02_面向物件(程式碼塊的面試題)(掌握)
- A:看程式寫結果
-
class Student { static { System.out.println("Student 靜態程式碼塊");//3 } { System.out.println("Student 構造程式碼塊");//4//6 } public Student() { System.out.println("Student 構造方法");//5//7 } } class Demo2_Student { static { System.out.println("Demo2_Student靜態程式碼塊");//1 } public static void main(String[] args) { System.out.println("我是main方法");//2 Student s1 = new Student(); Student s2 = new Student(); } }
輸出結果:1234567
08.03_面向物件(繼承案例演示)(掌握)
- A:繼承(extends)
- 讓類與類之間產生關係,子父類關係
- B:繼承案例演示:
- 動物類,貓類,狗類
- 定義兩個屬性(顏色,腿的個數)兩個功能(吃飯,睡覺)
- C:案例演示
- 使用繼承前
- D:案例演示
- 使用繼承後
class Demo1_Extends {
public static void main(String[] args) {
Cat c = new Cat();
c.color = "花";
c.leg = 4;
c.eat();
c.sleep();
System.out.println(c.leg + "..." + c.color);
}
}
class Animal {
String color; //動物的顏色
int leg; //動物腿的個數
public void eat() { //吃飯的功能
System.out.println("吃飯");
}
public void sleep() { //睡覺的功能
System.out.println("睡覺");
}
}
class Cat extends Animal {
}
class Dog extends Animal {
}
/*
extends是繼承的意思
Animal是父類
Cat和Dog都是子類
*/
08.04_面向物件(繼承的好處和弊端)(掌握)
- A:繼承的好處
- a:提高了程式碼的複用性
- b:提高了程式碼的維護性
- c:讓類與類之間產生了關係,是多型的前提
- B:繼承的弊端
-
類的耦合性增強了。
-
開發的原則:高內聚,低耦合。
-
耦合:類與類的關係
-
內聚:就是自己完成某件事情的能力
-
08.05_面向物件(Java中類的繼承特點)(掌握)
- A:Java中類的繼承特點
- a:Java只支援單繼承,不支援多繼承。(一個兒子只能有一個爹)
- 有些語言是支援多繼承,格式:extends 類1,類2,…
- b:Java支援多層繼承(繼承體系)
- a:Java只支援單繼承,不支援多繼承。(一個兒子只能有一個爹)
- B:案例演示
- Java中類的繼承特點
- 如果想用這個體系的所有功能用最底層的類建立物件
- 如果想看這個體系的共性功能,看最頂層的類
- Java中類的繼承特點
08.06_面向物件(繼承的注意事項和什麼時候使用繼承)(掌握)
-
A:繼承的注意事項
- a:子類只能繼承父類所有非私有的成員(成員方法和成員變數)
- b:子類不能繼承父類的構造方法,但是可以通過super(馬上講)關鍵字去訪問父類構造方法。
- c:不要為了部分功能而去繼承
- 專案經理 姓名 工號 工資 獎金
- 程式設計師 姓名 工號 工資(專案經理,程式設計師不能繼承)
-
B:什麼時候使用繼承
- 繼承其實體現的是一種關係:“is a”。
Person
Student
Teacher
水果
蘋果
香蕉
橘子
採用假設法。
如果有兩個類A,B。只有他們符合A是B的一種,或者B是A的一種,就可以考慮使用繼承。 - 繼承其實體現的是一種關係:“is a”。
08.07_面向物件(繼承中成員變數的關係)(掌握)
- A:案例演示(父類、子類中)
- a:不同名的變數
- b:同名的變數(就近原則,子父類出現同名的變數只是在講課中舉例子有,在開發中是不會出現這種情況的
子類繼承父類就是為了使用父類的成員,那麼如果定義了同名的成員變數沒有意義了)
08.08_面向物件(this和super的區別和應用)(掌握)
- A:this和super都代表什麼
- this:代表當前物件的引用,誰來呼叫我,我就代表誰
- super:代表當前物件父類的引用
- B:this和super的使用區別
- a:呼叫成員變數
- this.成員變數 呼叫本類的成員變數,也可以呼叫父類的成員變數
- super.成員變數 呼叫父類的成員變數
- a:呼叫成員變數
class Demo4_Extends {
public static void main(String[] args) {
Son s = new Son();
s.print();
}
}
class Father {
int num1 = 10;
int num2 = 30;
}
class Son extends Father {
int num2 = 20;
public void print() {
System.out.println(this.num1); //10 //this既可以呼叫本類的,也可以呼叫父類的(本類沒有的情況下)
System.out.println(this.num2); //20 //就近原則,子類有就不用父類的了
System.out.println(super.num2); //30
}
}
- b:呼叫構造方法
* this(…) 呼叫本類的構造方法
* super(…) 呼叫父類的構造方法 - c:呼叫成員方法
* this.成員方法 呼叫本類的成員方法,也可以呼叫父類的方法
* super.成員方法 呼叫父類的成員方法
08.09_面向物件(繼承中構造方法的關係)(掌握)
- A:案例演示
- 子類中所有的構造方法預設都會訪問父類中空引數的構造方法
- B:為什麼呢?
-
因為子類會繼承父類中的資料,可能還會使用父類的資料。
-
所以,子類初始化之前,一定要先完成父類資料的初始化。
-
其實:
- 每一個構造方法的第一條語句預設都是:super() Object類最頂層的父類,如果不寫繼承,就預設繼承Object類。
-
class Demo5_Extends {
public static void main(String[] args) {
Son s = new Son();
}
}
class Father extends Object {
public Father() {
super();
System.out.println("Father 的構造方法");
}
}
class Son extends Father {
public Son() {
super(); //這是一條語句,如果不寫,系統會預設加上,用來訪問父類中的空參構造
System.out.println("Son 的構造方法");
}
}
08.10_面向物件(繼承中構造方法的注意事項)(掌握)
- A:案例演示
- 父類沒有無參構造方法,子類怎麼辦?
- super解決
- this解決
- B:注意事項
- super(…)或者this(….)必須出現在構造方法的第一條語句上
class Demo6_Extends {
public static void main(String[] args) {
Son s1 = new Son();
System.out.println(s1.getName() + "..." + s1.getAge());
System.out.println("--------------------");
Son s2 = new Son("張三",23);
System.out.println(s2.getName() + "..." + s2.getAge());
}
}
class Father {
private String name; //姓名
private int age; //年齡
public Father(String name,int age) { //有參構造
this.name = name;
this.age = age;
System.out.println("Father 有參構造");
}
public void setName(String name) { //設定姓名
this.name = name;
}
public String getName() { //獲取姓名
return name;
}
public void setAge(int age) { //設定年齡
this.age = age;
}
public int getAge() { //獲取年齡
return age;
}
}
class Son extends Father {
public Son() { //空參構造
this("王五",25); //本類中的構造方法
//super("李四",24); //呼叫父類中的構造方法
System.out.println("Son 空參構造");
}
public Son(String name,int age) { //有參構造
super(name,age); //父類有參構造
System.out.println("Son 有參構造");
}
}
08.11_面向物件(繼承中的面試題)(掌握)
- A:案例演示
-
看程式寫結果1 class Fu{ public int num = 10; public Fu(){ System.out.println("fu"); } } class Zi extends Fu{ public int num = 20; public Zi(){ System.out.println("zi"); } public void show(){ int num = 30; System.out.println(num); System.out.println(this.num); System.out.println(super.num); } } class Test1_Extends { public static void main(String[] args) { Zi z = new Zi(); z.show(); } }
fu zi 30 20 10
看程式寫結果2
class Fu {
static {
System.out.println(“靜態程式碼塊Fu”);
}
{
System.out.println("構造程式碼塊Fu");
}
public Fu() {
System.out.println("構造方法Fu");
}
}
class Zi extends Fu {
static {
System.out.println("靜態程式碼塊Zi");
}
{
System.out.println("構造程式碼塊Zi");
}
public Zi() {
System.out.println("構造方法Zi");
}
}
Zi z = new Zi(); 請執行結果。
1、vm呼叫了main方法,main方法進棧
2、遇到Zi z=new Zi();會將Fu.class和Zi.class分別載入進記憶體,再建立物件,當Fu.class載入進記憶體,父類的靜態程式碼塊會隨著Fu.class一起載入,當Zi.class載入進記憶體,子類的靜態程式碼塊會隨著Zi.class一起載入。第一個輸出靜態程式碼塊Fu,第二個輸出靜態程式碼塊Zi
3、走子類的構造方法,因為Java是分層初始化的,先初始化父類再初始化子類,所以先走的是父類構造,但是在執行父類構造時發現父類有構造程式碼塊,構造程式碼塊是優先於構造方法執行的,所以第三個輸出是構造程式碼塊Fu,第四個輸出構造方法Fu
4、Fu類初始化結束,子類初始化,第五個輸出的是構造程式碼塊Zi,構造方法Zi
08.12_面向物件(繼承中成員方法關係)(掌握)
- A:案例演示
- a:不同名的方法
- b:同名的方法
class Demo7_Extends {
public static void main(String[] args) {
Son s = new Son();
s.print();
s.method();
}
}
class Father {
public void print() {
System.out.println("Fu print");
}
}
class Son extends Father {
public void method() {
System.out.println("Zi Method");
}
public void print() { //父類方法重寫
super.print(); //super可以呼叫父類的成員方法
System.out.println("Zi print");
}
}
08.13_面向物件(方法重寫概述及其應用)(掌握)
- A:什麼是方法重寫
- 重寫:子父類出現了一模一樣的方法(注意:返回值型別可以是子父類,這個我們學完面向物件講)
- B:方法重寫的應用:
- 當子類需要父類的功能,而功能主體子類有自己特有內容時,可以重寫父類中的方法。這樣,即沿襲了父類的功能,又定義了子類特有的內容。
- C:案例演示
- a:定義一個手機類。
class Demo7_Phone {
public static void main(String[] args) {
Ios8 i = new Ios8();
i.siri();
i.call();
}
}
/*
B:方法重寫的應用:
* 當子類需要父類的功能,而功能主體子類有自己特有內容時,可以重寫父類中的方法。這樣,即沿襲了父類的功能,又定義了子類特有的內容。
ios7系統 siri speak English
ios8系統 siri 說中文
*/
class Ios7 {
public void call() {
System.out.println("打電話");
}
public void siri() {
System.out.println("speak English");
}
}
class Ios8 extends Ios7 {
public void siri() { //方法重寫
System.out.println("說中文");
super.siri();//呼叫原本父類方法
}
}
08.14_面向物件(方法重寫的注意事項)(掌握)
- A:方法重寫注意事項
-
a:父類中私有方法不能被重寫(private)
- 因為父類私有方法子類根本就無法繼承
-
b:子類重寫父類方法時,訪問許可權不能更低
- 最好就一致
-
c:父類靜態方法,子類也必須通過靜態方法進行重寫(static)
- 其實這個算不上方法重寫,但是現象確實如此,至於為什麼算不上方法重寫,多型中我會講解(靜態只能覆蓋靜態)
-
子類重寫父類方法的時候,最好宣告一模一樣。
-
- B:案例演示
- 方法重寫注意事項
08.15_面向物件(方法重寫的面試題)(掌握)
- A:方法重寫的面試題
-
Override(重寫)和Overload(過載)的區別?Overload能改變返回值型別嗎?
-
overload可以改變返回值型別,只看引數列表
-
方法重寫:子類中出現了和父類中方法宣告一模一樣的方法。與返回值型別有關,返回值是一致(或者是子父類)的
-
方法過載:本類中出現的方法名一樣,引數列表不同的方法。與返回值型別無關。
-
子類物件呼叫方法的時候:
- 先找子類本身,再找父類。
-
08.16_面向物件(使用繼承前的學生和老師案例)(掌握)
- A:案例演示
- 使用繼承前的學生和老師案例
- 屬性:姓名,年齡
- 行為:吃飯
- 老師有特有的方法:講課
- 學生有特有的方法:學習
08.17_面向物件(使用繼承後的學生和老師案例)(掌握)
- A:案例演示
- 使用繼承後的學生和老師案例
public class Demo2_Dollection {
public static void main(String[] args) {
Student s1=new Student();
s1.setName("張三");
s1.setAge(23);
System.out.println(s1.getName()+"..."+s1.getAge());
s1.eat();
s1.study();
System.out.println("--------------");
Student s2=new Student("李四",24);
System.out.println(s2.getName()+"..."+s2.getAge());
s2.eat();
s2.study();
}
}
class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void eat() {
System.out.println("吃飯");
}
}
class Student extends Person {
public Student() {
}
public Student(String name, int age) {
super(name, age);
}
public void study() {
System.out.println("學生學習");
}
}
class Teacher extends Person {
public Teacher() {}
public Teacher(String name, int age) {
super(name, age);
}
public void teach() {
System.out.println("老師講課");
}
}
08.18_面向物件(貓狗案例分析,實現及測試)(掌握)
- A:貓狗案例分析
- B:案例演示
- 貓狗案例繼承版
- 屬性:毛的顏色,腿的個數
- 行為:吃飯
- 貓特有行為:抓老鼠catchMouse
- 狗特有行為:看家lookHome
class Test5_Animal {
public static void main(String[] args) {
Cat c1 = new Cat("花",4);
System.out.println(c1.getColor() + "..." + c1.getLeg());
c1.eat();
c1.catchMouse();
Dog d1 = new Dog("黑",2);
System.out.println(d1.getColor() + "..." + d1.getLeg());
d1.eat();
d1.lookHome();
}
}
class Animal {
private String color; //毛的顏色
private int leg; //腿的個數
public Animal(){}
public Animal(String color,int leg) {
this.color = color;
this.leg = leg;
}
public void setColor(String color) { //設定顏色
this.color = color;
}
public String getColor() { //獲取顏色
return color;
}
public void setLeg(int leg) { //設定腿的個數
this.leg = leg;
}
public int getLeg() { //獲取腿的個數
return leg;
}
public void eat() { //吃飯
System.out.println("吃飯");
}
}
class Cat extends Animal {
public Cat() {} //空參構造
public Cat(String color,int leg) { //有參構造
super(color,leg);
}
public void eat() { //吃魚
System.out.println("貓吃魚");
}
public void catchMouse() { //抓老鼠
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public Dog() {} //空參構造
public Dog(String color,int leg) { //有參構造
super(color,leg);
}
public void eat() { //吃肉
System.out.println("狗吃肉");
}
public void lookHome() { //看家
System.out.println("看家");
}
}
08.19_面向物件(final關鍵字修飾類,方法以及變數的特點)(掌握)
- A:final概述
- B:final修飾特點
- 修飾類,類不能被繼承
- 修飾變數,變數就變成了常量,只能被賦值一次
- 修飾方法,方法不能被重寫
- C:案例演示
- final修飾特點
final修飾變數叫做常量,一般會與public static 公用,public static final double PI=3.14;
常量命名規範,如果是一個單詞,所有字母大寫,如果有多個單詞,將每個單詞的首字母大寫,中間加上下劃線
08.20_面向物件(final關鍵字修飾區域性變數)(掌握)
- A:案例演示
-
方法內部或者方法宣告上都演示一下(瞭解)
-
基本型別,是值不能被改變
-
引用型別,是地址值不能被改變,物件中的屬性可以改變
-
class Demo2_Final {
public static void main(String[] args) {
final int num = 10;
//num = 20; //基本資料型別,值不能被改變
System.out.println(num);
final Person p = new Person("張三",23);
//p = new Person("李四",24); //引用資料型別,地址值不能被改變
p.setName("李四");
p.setAge(24);
System.out.println(p.getName() + "..." + p.getAge()); //李四 24
method(10);
method(20);//method(10)執行完後就彈棧了
}
public static void method(final int x) {
System.out.println(x);
}
}
class Person {
private String name; //姓名
private int age; //年齡
public Person(){} //空參構造
public Person(String name,int age) {
this.name = name;
this.age = age;
}
public void setName(String name) { //設定姓名
this.name = name;
}
public String getName() { //獲取姓名
return name;
}
public void setAge(int age) { //設定年齡
this.age = age;
}
public int getAge() { //獲取年齡
return age;
}
}
08.21_面向物件(final修飾變數的初始化時機)(掌握)
- A:final修飾變數的初始化時機
- 顯示初始化
- 在物件構造完畢前即可
class Demo3_Final {
public static void main(String[] args) {
Demo d = new Demo();
d.print();
}
}
class Demo {
final int num; //成員變數的預設初始化值是無效值
public Demo() {
num = 10;
}
public void print() {
System.out.println(num);
}
}