黑馬程序員_JavaSE學(xué)習(xí)總結(jié)第09天_面向?qū)ο?

2019-11-15 00:12:41
字體：大中小
供稿：網(wǎng)友
黑馬程序員_javaSE學(xué)習(xí)總結(jié)第09天_面向?qū)ο?
------- android培訓(xùn)、java培訓(xùn)、期待與您交流！ ----------
09.01 final關(guān)鍵字引入
例:
 1 class Fu 2 { 3     public final void show() 4     { 5         System.out.上面的代碼中父類中的show()方法如果不想被子類覆蓋，可以使用final關(guān)鍵字修飾，當子類覆蓋了父類中的show()方法，將會報以下錯誤:
final關(guān)鍵字是最終的意思，可以修飾類，成員變量，成員方法
09.02 final關(guān)鍵字修飾類,方法以及變量的特點
修飾類，類不能被繼承
修飾方法，方法不能被重寫
修飾變量，變量就變成了常量，只能被賦值一次
09.03 final關(guān)鍵字修飾局部變量
例:
 1 class Student 2 { 3     int age = 10; 4 } 5 class Demo  6 { 7     public static void main(String[] args) 8     { 9         //final修飾基本類型的局部變量10         final int x = 10;11         //x = 20; 值不能被改變12         System.out.println(x);13 14         //final修飾引用類型的局部變量15         final Student s = new Student();16         //s = new Student(); 引用類型的地址值不能變17         s.age = 20;18         System.out.println(s.age);19     }20 }
final修飾基本類型的局部變量，該變量的值不能被改變
final修飾引用類型的局部變量，引用類型的地址值不能變
09.04 final修飾變量的初始化時機
例:
 1 class Test 2 { 3     int num1; 4     final int num2; //在對象構(gòu)造完畢前即可 5     public Test() 6     { 7         num1 = 100; 8         num2 = 200; 9     }10 }11 class Demo 12 {13     public static void main(String[] args)14     {15         Test t = new Test();16         System.out.println(t.num1);17         System.out.println(t.num2);18     }19 }
09.05 多態(tài)的概述和前提條件
多態(tài)概述:某一個對象，在不同時刻表現(xiàn)出來的不同狀態(tài)。
舉例:貓可以是貓的類型。Cat c = new Cat();
同時貓也是動物的一種，也可以把貓稱為動物。Animal a = new Animal();
多態(tài)的前提:
1.有繼承關(guān)系 
2.有方法重寫 
3.有父類引用指向子類對象
09.06 按照多態(tài)前提給出代碼體現(xiàn)
 1 class Fu 2 { 3     public void show() 4     { 5         System.out.println("Fu show run") 6     } 7 } 8 class Zi extends Fu 9 {10     public void show()11     {12         System.out.println("Zi show run")13     }14 }15 class Demo 16 {17     public static void main(String[] args)18     {19         //父類引用指向子類對象20         Fu f = new Zi();21     }22 }
09.07 多態(tài)中的成員訪問特點
1.成員變量 編譯看左邊，運行看左邊
例:
 1 class Fu 2 { 3     public int num1 = 10; 4 } 5 class Zi extends Fu 6 { 7     public int num1 = 20; 8     public int num2 = 30; 9     10 }11 class Demo 12 {13     public static void main(String[] args)14     {15         //編譯時查看Fu類中是否有num1，有就編譯通過16         Fu f = new Zi();17         //運行時輸出Fu類中的num118         System.out.println(f.num1);19         //Fu類中沒有num2，編譯失敗20         //System.out.println(f.num2);21     }22 }
2.成員方法 編譯看左邊，運行看右邊
例:
 1 class Fu 2 { 3     public void show() 4     { 5         System.out.println("Fu show run"); 6     } 7  8 } 9 class Zi extends Fu10 {11     public void show()12     {13         System.out.println("Zi show run");14     }15     public void method()16     {17         System.out.println("Zi method run");18     }19 20 }21 class Demo 22 {23     public static void main(String[] args)24     {25         Fu f = new Zi();26         //編譯時查看Fu類中是否有show()方法，有就編譯通過27         //運行時輸出Zi類中show()方法28         f.show();29         //Fu類中沒有num2，編譯失敗30         //f.method();31     }32 }
3.靜態(tài)方法 編譯看左邊，運行看左邊(靜態(tài)方法與類相關(guān)，不能算方法的重寫)
例:
 1 class Fu 2 { 3     public static void show() 4     { 5         System.out.println("Fu show run"); 6     } 7  8 } 9 class Zi extends Fu10 {11     public static void show()12     {13         System.out.println("Zi show run");14     }15     public void method()16     {17         System.out.println("Zi method run");18     }19 20 }21 class Demo 22 {23     public static void main(String[] args)24     {25         Fu f = new Zi();26         //編譯時查看Fu類中是否有show()方法，有就編譯通過27         //運行時輸出Fu類中show()方法28         f.show();29     }30 }
09.08 多態(tài)的好處
多態(tài)的好處
提高了程序的維護性(由繼承保證)
提高了程序的擴展性(由多態(tài)保證)
例:
 1 class Animal 2 { 3     public void eat() 4     { 5         System.out.println("eat"); 6     } 7 } 8 class Cat extends Animal 9 {10     public void eat()11     {12         System.out.println("貓吃魚");13     }14 }15 class Dog extends Animal16 {17     public void eat()18     {19         System.out.println("狗吃肉");20     }21 }22 class Demo 23 {24     public static void main(String[] args)25     {26         Cat c = new Cat();27         Dog d = new Dog();28         method(c);29         method(d);30     }31 　　 //提高了代碼的擴展性，前期定義的代碼可以使用后期的內(nèi)容32     public static void method(Animal a)33     {34         a.eat();35     }36 }
09.09 多態(tài)的弊端
多態(tài)的弊端:不能訪問子類特有功能
例:
 1 class Fu 2 { 3     public void show() 4     { 5         System.out.println("Fu show run"); 6     } 7 } 8 class Zi extends Fu 9 {10     public void show()11     {12         System.out.println("Zi show run");13     }14     public void method()15     {16         System.out.println("Zi method run");17     }18 }19 class Demo 20 {21     public static void main(String[] args)22     {23         Fu f = new Zi();24         f.show();25         //錯誤，不能訪問子類特有功能26         //f.method();27     }28 }
09.10 多態(tài)中向上轉(zhuǎn)型和向下轉(zhuǎn)型
例:
 1 class Fu 2 { 3     public void show() 4     { 5         System.out.println("Fu show run"); 6     } 7 } 8 class Zi extends Fu 9 {10     public void show()11     {12         System.out.println("Zi show run");13     }14     public void method()15     {16         System.out.println("Zi method run");17     }18 }19 class Demo 20 {21     public static void main(String[] args)22     {23         Fu f = new Zi();24         f.show();25         //使用向下轉(zhuǎn)型以使用子類特有方法26         Zi z = (Zi)f;27         z.method();28     }29 }
運行結(jié)果:
Zi show runZi method run
向上轉(zhuǎn)型:從子到父，父類引用指向子類對象。例:Fu f = new Zi();
向下轉(zhuǎn)型:從父到子，父類引用轉(zhuǎn)為子類對象。例:Zi z = (Zi)f;
09.11 孔子裝爹案例講解多態(tài)現(xiàn)象
多態(tài)的問題理解:
 1 class 孔子爹  2 { 3     public int age = 40; 4      5     public void teach()  6     { 7         System.out.println("講解JavaSE"); 8     } 9 }10     11 class 孔子 extends 孔子爹12 {13     public int age = 20;14     public void teach()15     {16         System.out.println("講解論語");17     }18     public void playGame() 19     {20         System.out.println("英雄聯(lián)盟");21     }22 }23     24     //Java培訓(xùn)特別火,很多人來請孔子爹去講課，這一天孔子爹被請走了25     //但是還有人來請，就剩孔子在家，價格還挺高。孔子一想，我是不是可以考慮去呢?26     //然后就穿上爹的衣服，帶上爹的眼睛，粘上爹的胡子。就開始裝爹27     //向上轉(zhuǎn)型28     孔子爹 k爹 = new 孔子();29     //到人家那里去了30     System.out.println(k爹.age); //4031     k爹.teach(); //講解論語32     //k爹.playGame(); //這是兒子才能做的33     34     //講完了，下班回家了35     //脫下爹的裝備，換上自己的裝備36     //向下轉(zhuǎn)型37     孔子 k = (孔子) k爹; 38     System.out.println(k.age); //2039     k.teach(); //講解論語40     k.playGame(); //英雄聯(lián)盟
09.12 多態(tài)繼承中的內(nèi)存圖解
09.13 多態(tài)中的對象變化內(nèi)存圖解
09.14 貓狗案例多態(tài)版 1 class Animal 2 { 3     public void eat() 4     { 5         System.out.println("吃飯"); 6     } 7 } 8 class Cat extends Animal 9 {10     public void eat()11     {12         System.out.println("貓吃魚");13     }14     public void playGame()15     {16         System.out.println("貓玩運行結(jié)果:
狗吃肉狗看門------貓吃魚貓玩游戲
09.15 南北方人案例
 1 class Person  2 { 3     String name; 4     Person(String name) 5     { 6         this.name = name; 7         System.out.println(name); 8     } 9     public void eat() 10     {11         System.out.println("吃飯");12     }13 }14 15 class SouthPerson extends Person 16 {17     SouthPerson(String name)18     {19         super(name);20     }21     public void eat() 22     {23         System.out.println("炒菜,吃米飯");24     }25     26     public void jingShang() 27     {28         System.out.println("經(jīng)商");29     }30 }31 32 class NorthPerson extends Person 33 {34     NorthPerson(String name)35     {36         super(name);37     }38     public void eat() 39     {40         System.out.println("燉菜,吃饅頭");41     }42     43     public void yanJiu() 44     {45         System.out.println("研究");46     }47 }48 class Demo 49 {50     public static void main(String[] args)51     {52         //測試53         //南方人54         Person p = new SouthPerson("南方人");55         p.eat();56         SouthPerson sp = (SouthPerson)p;57         sp.jingShang();58         System.out.println("--------");59         60         //北方人61         p = new NorthPerson("北方人");62         p.eat();63         NorthPerson np = (NorthPerson)p;64         np.yanJiu();65     }66 }
運行結(jié)果:
南方人炒菜,吃米飯經(jīng)商--------北方人燉菜,吃饅頭研究
09.16 多態(tài)的練習(xí)題看程序?qū)懡Y(jié)果
1.看程序?qū)懡Y(jié)果:先判斷有沒有問題，如果沒有，寫出結(jié)果
 1 class Fu  2 { 3     public void show()  4     { 5         System.out.println("fu show run"); 6     } 7 } 8  9 class Zi extends Fu 10 {11     public void show() 12     {13         System.out.println("zi show run");14     }15 16     public void method() 17     {18         System.out.println("zi method run");19     }20 }21 class Demo 22 {23     public static void main(String[] args)24     {25         Fu f = new Zi();26         //找不到符號27         //f.method();28         f.show();29     }30 }
運行結(jié)果:
zi show run
2.看程序?qū)懡Y(jié)果:先判斷有沒有問題，如果沒有，寫出結(jié)果
 1 class A  2 { 3     public void show()  4     { 5         show2(); 6     } 7     public void show2()  8     { 9         System.out.println("hello ");10     }11 }12 class B extends A 13 {14     /*15     //從父類繼承16     public void show() 17     {18         show2();19     }20     */21 22     public void show2() 23     {24         System.out.println("world ");25     }26 }27 class C extends B 28 {29     public void show() 30     {31         super.show();32     }33     public void show2() 34     {35         System.out.println("java ");36     }37 }38 class Demo 39 {40     public static void main(String[] args)41     {42         A a = new B();43         a.show();44         45         B b = new C();46         b.show();47     }48 }
運行結(jié)果:
worldjava
09.17 抽象類的引入
動物本身并不是一個具體的事物，而是一個抽象的事物。只有真正的貓，狗才是具體的動物。同理，不同的動物吃的東西應(yīng)該是不一樣的，所以，我們不應(yīng)該在動物類中給出具體體現(xiàn)，而是應(yīng)該給出一個聲明即可。
在Java中，一個沒有方法體的方法應(yīng)該定義為抽象方法，而類中如果有抽象方法，該類必須定義為抽象類。
09.18 抽象類的特點
抽象類特點:
1.抽象類和抽象方法必須用abstract關(guān)鍵字修飾
格式: abstract class 類名 {}
public abstract void method();
2.抽象類不一定有抽象方法，有抽象方法的類一定是抽象類
3.抽象類不能實例化，因為抽象類不是具體的，抽象類有構(gòu)造方法，按照多態(tài)的方式，由具體的子類實例化。其實這也是多態(tài)的一種，抽象類多態(tài)。
4.抽象類的子類如果不重寫父類中的抽象方法，那么該子類還是抽象類，否則必須重寫抽象類中的所有抽象方法
例:
 1 abstract class Animal 2 { 3     public abstract void eat(); 4 } 5 class Cat extends Animal 6 { 7     public void eat() 8     { 9         System.out.println("貓吃魚");10     }11 }12 class Demo 13 {14     public static void main(String[] args)15     {16         //多態(tài)17         Animal a = new Cat();18         a.eat();19     }20 }
運行結(jié)果:
貓吃魚
09.19 抽象類的成員特點
成員變量:可以是變量，也可以是常量
構(gòu)造方法:有構(gòu)造方法，但是不能實例化，構(gòu)造方法的作用是用于子類訪問父類數(shù)據(jù)的初始化
成員方法:可以有抽象方法限定子類必須完成某些動作，也可以有非抽象方法提高代碼復(fù)用性
例:
 1 abstract class Animal 2 { 3     public int num1 = 10;//變量 4     public final int num2 = 20;//常量 5     public Animal(){}//構(gòu)造函數(shù) 6     public abstract void show();//抽象方法 7     public void method()//非抽象方法 8     { 9         System.out.println("Animal method run");10     }11 }12 class Cat extends Animal13 {14     public void show()15     {16         System.out.println("Cat show run");17     }18 }19 class Demo 20 {21     public static void main(String[] args)22     {23         //創(chuàng)建對象24         Animal a = new Cat();25         System.out.println(a.num1);//訪問變量26         System.out.println(a.num2);//訪問常量27         a.show();//訪問抽象方法28         a.method();//訪問非抽象方法29     }30 }
運行結(jié)果:
1020Cat show runAnimal method run
09.20 抽象類練習(xí)貓狗案例
  1 /*  2 貓狗案例  3         具體事物:貓，狗  4         共性:姓名，年齡，吃飯  5   6 分析:從具體到抽象  7 貓:  8     成員變量:姓名，年齡  9     構(gòu)造方法:無參，帶參 10     成員方法:吃飯(貓吃魚) 11              12 狗: 13     成員變量:姓名，年齡 14     構(gòu)造方法:無參，帶參 15     成員方法:吃飯(狗吃肉) 16              17 因為有共性的內(nèi)容，所以就提取了一個父類。動物。 18 但是又由于吃飯的內(nèi)容不一樣，所以吃飯的方法是抽象的， 19 而方法是抽象的類，類就必須定義為抽象類。 20          21 抽象動物類: 22             成員變量:姓名，年齡 23             構(gòu)造方法:無參，帶參 24             成員方法:吃飯(); 25      26 實現(xiàn):從抽象到具體 27 動物類: 28     成員變量:姓名，年齡 29     構(gòu)造方法:無參，帶參 30     成員方法:吃飯(); 31              32 狗類: 33     繼承自動物類 34     重寫吃飯(); 35              36 貓類: 37     繼承自動物類 38     重寫吃飯(); 39 */ 40 abstract class Animal 41 { 42     //姓名 43     private String name; 44     //年齡 45     private int age; 46      47     public Animal() {} 48      49     public Animal(String name,int age)  50     { 51         this.name = name; 52         this.age = age; 53     } 54      55     public String getName()  56     { 57         return name; 58     } 59      60     public void setName(String name)  61     { 62         this.name = name; 63     } 64      65     public int getAge()  66     { 67         return age; 68     } 69      70     public void setAge(int age)  71     { 72         this.age = age; 73     } 74      75     //定義一個抽象方法 76     public abstract void eat(); 77 } 78 //定義具體的狗類 79 class Dog extends Animal  80 { 81     public Dog() {} 82      83     public Dog(String name,int age)  84     { 85         super(name,age); 86     } 87      88     public void eat()  89     { 90         System.out.println("狗吃肉"); 91     } 92 } 93  94 //定義具體的貓類 95 class Cat extends Animal  96 { 97     public Cat() {} 98      99     public Cat(String name,int age) 100     {101         super(name,age);102     }103     104     public void eat() 105     {106         System.out.println("貓吃魚");107     }108 }109 class Demo 110 {111     public static void main(String[] args)112     {113         //測試狗類，具體類用法 方式1114         Dog d = new Dog();115         d.setName("旺財");116         d.setAge(3);117         System.out.println(d.getName()+"---"+d.getAge());118         d.eat();119         //測試狗類，具體類用法 方式2:120         Dog d2 = new Dog("旺財",3);121         System.out.println(d2.getName()+"---"+d2.getAge());122         d2.eat();123         System.out.println("-------------");124         //測試狗類，多態(tài)用法 方式1:125         Animal a = new Dog();126         a.setName("旺財");127         a.setAge(3);128         System.out.println(a.getName()+"---"+a.getAge());129         a.eat();130         //測試狗類，多態(tài)用法 方式2:131         Animal a2 = new Dog("旺財",3);132         System.out.println(a2.getName()+"---"+a2.getAge());133         a2.eat();134     }135 }
運行結(jié)果:
旺財---3狗吃肉旺財---3狗吃肉-------------旺財---3狗吃肉旺財---3狗吃肉
09.21 抽象類練習(xí)老師案例
  1 /*  2 老師案例  3         具體事物:基礎(chǔ)班老師，就業(yè)班老師  4         共性:姓名，年齡，講課。  5   6 分析:      7     基礎(chǔ)班老師  8         姓名，年齡  9         講課。 10     就業(yè)班老師 11         姓名，年齡 12         講課。 13 實現(xiàn): 14     老師類 15         基礎(chǔ)班老師 16         就業(yè)班老師 17 */ 18 //定義抽象的老師類 19 abstract class Teacher  20 { 21     //姓名 22     private String name; 23     //年齡 24     private int age; 25      26     public Teacher() {} 27      28     public Teacher(String name,int age)  29     { 30         this.name = name; 31         this.age = age; 32     } 33      34     public String getName()  35     { 36         return name; 37     } 38      39     public void setName(String name)  40     { 41         this.name = name; 42     } 43      44     public int getAge()  45     { 46         return age; 47     } 48      49     public void setAge(int age)  50     { 51         this.age = age; 52     } 53      54     //抽象方法 55     public abstract void teach(); 56 } 57  58 //基礎(chǔ)班老師類 59 class BasicTeacher extends Teacher  60 { 61     public BasicTeacher(){} 62      63     public BasicTeacher(String name,int age)  64     { 65         super(name,age); 66     } 67      68     public void teach()  69     { 70         System.out.println("基礎(chǔ)班老師講解JavaSE"); 71     } 72 } 73  74 //就業(yè)班老師類 75 class WorkTeacher extends Teacher  76 { 77     public WorkTeacher(){} 78      79     public WorkTeacher(String name,int age)  80     { 81         super(name,age); 82     } 83      84     public void teach()  85     { 86         System.out.println("就業(yè)班老師講解JavaEE"); 87     } 88 } 89 class Demo  90 { 91     public static void main(String[] args) 92     { 93         //多態(tài)測試 94         //基礎(chǔ)班老師 95         Teacher t = new BasicTeacher(); 96         t.setName("小明"); 97         t.setAge(30); 98         System.out.println(t.getName()+"---"+t.getAge()); 99         t.teach();100         System.out.println("--------------------");101         102         t = new BasicTeacher("小明",30);103         System.out.println(t.getName()+"---"+t.getAge());104         t.teach();105         System.out.println("--------------------");106         107         //就業(yè)班老師108         t = new WorkTeacher();109         t.setName("小紅");110         t.setAge(35);111         System.out.println(t.getName()+"---"+t.getAge());112         t.teach();113         System.out.println("--------------------");114         115         t = new WorkTeacher("小紅",35);116         System.out.println(t.getName()+"---"+t.getAge());117         t.teach();118     }119 }
運行結(jié)果:
小明---30基礎(chǔ)班老師講解JavaSE--------------------小明---30基礎(chǔ)班老師講解JavaSE--------------------小紅---35就業(yè)班老師講解JavaEE--------------------小紅---35就業(yè)班老師講解JavaEE
09.22 抽象類練習(xí)學(xué)員案例
  1 /*  2 學(xué)生案例  3         具體事務(wù):基礎(chǔ)班學(xué)員，就業(yè)班學(xué)員  4         共性:姓名，年齡，班級，學(xué)習(xí)，吃飯  5   6 分析:  7     基礎(chǔ)班學(xué)員  8         成員變量:姓名，年齡，班級  9         成員方法:學(xué)習(xí)，吃飯 10     就業(yè)班學(xué)員 11         成員變量:姓名，年齡，班級 12         成員方法:學(xué)習(xí)，吃飯 13              14 得到一個學(xué)員類。 15     成員變量:姓名，年齡，班級 16     成員方法:學(xué)習(xí)，吃飯 17              18 實現(xiàn): 19     學(xué)員類 20     基礎(chǔ)班學(xué)員 21     就業(yè)班學(xué)員 22 */ 23 //定義抽象學(xué)員類 24 abstract class Student  25 { 26     //姓名 27     private String name; 28     //年齡 29     private int age; 30     //班級 31     private String grand; 32      33     public Student() {} 34      35     public Student(String name,int age,String grand)  36     { 37         this.name = name; 38         this.age = age; 39         this.grand = grand; 40     } 41      42     public String getName()  43     { 44         return name; 45     } 46      47     public void setName(String name)  48     { 49         this.name = name; 50     } 51      52     public int getAge()  53     { 54         return age; 55     } 56      57     public void setAge(int age)  58     { 59         this.age = age; 60     } 61      62     public String getGrand()  63     { 64         return grand; 65     } 66      67     public void setGrand(String grand)  68     { 69         this.grand = grand; 70     } 71      72     //學(xué)習(xí) 73     public abstract void study(); 74      75     //吃飯 76     public void eat()  77     { 78         System.out.println("吃飯"); 79     } 80 } 81  82 //具體基礎(chǔ)班學(xué)員類 83 class BasicStudent extends Student  84 { 85     public BasicStudent() {} 86      87     public BasicStudent(String name,int age,String grand)  88     { 89         super(name,age,grand); 90     } 91     //重寫父類抽象方法 92     public void study()  93     { 94         System.out.println("基礎(chǔ)班學(xué)員學(xué)習(xí)JavaSE"); 95     } 96 } 97  98 //具體就業(yè)班學(xué)員類 99 class WorkStudent extends Student 100 {101     public WorkStudent() {}102     103     public WorkStudent(String name,int age,String grand) 104     {105         super(name,age,grand);106     }107     //重寫父類抽象方法108     public void study() 109     {110         System.out.println("就業(yè)班學(xué)員學(xué)習(xí)JavaEE");111     }112 }113 class Demo 114 {115     public static void main(String[] args)116     {117         //按照多態(tài)的方式測試基礎(chǔ)班學(xué)員118         Student s = new BasicStudent();119         s.setName("小明");120         s.setAge(27);121         s.setGrand("1111");122         System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());123         s.study();124         s.eat();125         System.out.println("--------------");126         127         s = new BasicStudent("小紅",28,"1111");128         System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());129         s.study();130         s.eat();131     }132 }
運行結(jié)果:
小明---27---1111基礎(chǔ)班學(xué)員學(xué)習(xí)JavaSE吃飯--------------小紅---28---1111基礎(chǔ)班學(xué)員學(xué)習(xí)JavaSE吃飯
09.23 抽象類練習(xí)員工案例
假如我們在開發(fā)一個系統(tǒng)時需要對員工類進行設(shè)計，員工包含3個屬性:姓名、工號以及工資。
經(jīng)理也是員工，除了含有員工的屬性外，另為還有一個獎金屬性。
請使用繼承的思想設(shè)計出員工類和經(jīng)理類。要求類中提供必要的方法進行屬性訪問。
  1 /*  2   3 分析:  4     普通員工類  5             成員變量:姓名、工號以及工資。  6             成員方法:工作  7     經(jīng)理類:  8             成員變量:姓名、工號以及工資，獎金屬性  9             成員方法:工作 10              11 實現(xiàn): 12     員工類: 13     普通員工類: 14     經(jīng)理類: 15 */ 16 //定義員工類 17 abstract class Employee  18 { 19     //姓名、工號以及工資 20     private String name; 21     private String id; 22     private int salary; 23      24     public Employee() {} 25      26     public Employee(String name,String id,int salary)  27     { 28         this.name = name; 29         this.id = id; 30         this.salary = salary; 31     } 32      33     public String getName()  34     { 35         return name; 36     } 37      38     public void setName(String name)  39     { 40         this.name = name; 41     } 42      43     public String getId()  44     { 45         return id; 46     } 47      48     public void setId(String id)  49     { 50         this.id = id; 51     } 52      53     public int getSalary()  54     { 55         return salary; 56     } 57      58     public void setSalary(int salary)  59     { 60         this.salary = salary; 61     } 62      63     //工作 64     public abstract void work(); 65 } 66  67 //普通員工類 68 class Programmer extends Employee  69 { 70     public Programmer(){} 71      72     public Programmer(String name,String id,int salary)  73     { 74         super(name,id,salary); 75     } 76      77     public void work()  78     { 79         System.out.println("按照需求寫代碼"); 80     } 81 } 82  83 //經(jīng)理類 84 class Manager extends Employee  85 { 86     //獎金 87     private int money; 88  89     public Manager(){} 90      91     public Manager(String name,String id,int salary,int money)  92     { 93         super(name,id,salary); 94         this.money = money; 95     } 96      97     public void work() 98     { 99         System.out.println("跟客戶談需求");100     }101     102     public int getMoney() 103     {104         return money;105     }106     107     public void setMoney(int money) 108     {109         this.money = money;110     }111 }112 class Demo 113 {114     public static void main(String[] args)115     {116         //測試普通員工117         Employee emp = new Programmer();118         emp.setName("小明");119         emp.setId("czbk001");120         emp.setSalary(18000);121         System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());122         emp.work();123         System.out.println("-------------");124         emp = new Programmer("小明","czbk001",18000);125         System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());126         emp.work();127         System.out.println("-------------");128         129         //由于子類有特有的內(nèi)容，所以我們用子類來測試130         Manager m = new Manager();131         m.setName("小紅");132         m.setId("czbk002");133         m.setSalary(8000);134         m.setMoney(2000);135         System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());136         m.work();137         System.out.println("-------------");138         139         //通過構(gòu)造方法賦值140         m = new Manager("小紅","czbk002",8000,2000);141         System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());142         m.work();143     }144 }
運行結(jié)果:
小明---czbk001---18000按照需求寫代碼-------------小明---czbk001---18000按照需求寫代碼-------------小紅---czbk002---8000---2000跟客戶談需求-------------小紅---czbk002---8000---2000跟客戶談需求
09.24 抽象類中的小問題
1.一個類如果沒有抽象方法，可不可以定義為抽象類?如果可以，有什么意義?
可以。不讓創(chuàng)建對象。
2.abstract不能和哪些關(guān)鍵字共存
private 沖突
final 沖突
static 無意義
09.25 接口的引入
為了體現(xiàn)事物功能的擴展性，Java中就提供了接口來定義這些額外功能，并不給出具體實現(xiàn)，將來哪些貓狗需要被培訓(xùn)，只需要這部分貓狗把這些額外功能實現(xiàn)即可。
09.26 接口的特點
接口特點:接口用關(guān)鍵字interface表示，格式:interface 接口名 {}
類實現(xiàn)接口用implements表示，格式:class 類名 implements 接口名 {}
接口不能實例化，按照多態(tài)的方式，由具體的子類實例化。其實這也是多態(tài)的一種，接口多態(tài)。
接口的子類要么是抽象類，要么重寫接口中的所有抽象方法
09.27 接口的成員特點
成員變量:只能是常量，默認修飾符 public static final
構(gòu)造方法:沒有，因為接口主要是擴展功能的，而沒有具體存在
成員方法:只能是抽象方法，默認修飾符 public abstract
09.28 類與類,類與接口,接口與接口的關(guān)系
類與類的關(guān)系:繼承關(guān)系，只能單繼承，但是可以多層繼承
類與接口的關(guān)系:實現(xiàn)關(guān)系，可以單實現(xiàn)，也可以多實現(xiàn)。還可以在繼承一個類的同時實現(xiàn)多個接口
接口與接口的關(guān)系:繼承關(guān)系，可以單繼承，也可以多繼承
09.29 抽象類和接口的區(qū)別
成員區(qū)別:
抽象類:成員變量，可以是變量也可以是常量。構(gòu)造方法，有。成員方法，可以是抽象方法也可以是非抽象方法
接口:成員變量，只可以是常量。構(gòu)造方法，沒有。成員方法，只可以是抽象方法
關(guān)系區(qū)別:
類與類繼承，單繼承
類與接口實現(xiàn)，單實現(xiàn)，多實現(xiàn)
接口與接口繼承，單繼承，多繼承
設(shè)計理念區(qū)別:
抽象類被繼承體現(xiàn)的是:”is a”的關(guān)系。繼承體系的共性功能
接口被實現(xiàn)體現(xiàn)的是:”like a”的關(guān)系。繼承體系的擴展功能
09.30 貓狗案例加入跳高功能分析
貓狗案例,加入跳高的額外功能
分析:從具體到抽象
貓:姓名,年齡 吃飯，睡覺
狗:姓名,年齡 吃飯，睡覺
由于有共性功能，所以，我們抽取出一個父類:
動物:姓名,年齡 吃飯();睡覺(){}   
貓:繼承自動物
狗:繼承自動物
跳高的額外功能是一個新的擴展功能，所以我們要定義一個接口:跳高  
部分貓:實現(xiàn)跳高
部分狗:實現(xiàn)跳高
實現(xiàn):從抽象到具體
使用:使用具體類
09.31 貓狗案例加入跳高功能代碼實現(xiàn)
  1 //定義跳高接口  2 interface Jumpping   3 {  4     //跳高功能  5     public abstract void jump();  6 }  7   8 //定義抽象類  9 abstract class Animal  10 { 11     //姓名 12     private String name; 13     //年齡 14     private int age; 15      16     public Animal() {} 17      18     public Animal(String name,int age)  19     { 20         this.name = name; 21         this.age = age; 22     } 23      24     public String getName()  25     { 26         return name; 27     } 28      29     public void setName(String name)  30     { 31         this.name = name; 32     } 33      34     public int getAge()  35     { 36         return age; 37     } 38      39     public void setAge(int age)  40     { 41         this.age = age; 42     } 43      44     //吃飯(); 45     public abstract void eat(); 46      47     //睡覺(){} 48     public void sleep()  49     { 50         System.out.println("睡覺"); 51     } 52 } 53  54 //具體貓類 55 class Cat extends Animal  56 { 57     public Cat(){} 58      59     public Cat(String name,int age)  60     { 61         super(name,age); 62     } 63      64     public void eat()  65     { 66         System.out.println("貓吃魚"); 67     } 68 } 69  70 //具體狗類 71 class Dog extends Animal  72 { 73     public Dog(){} 74      75     public Dog(String name,int age)  76     { 77         super(name,age); 78     } 79      80     public void eat()  81     { 82         System.out.println("狗吃肉"); 83     } 84 } 85  86 //有跳高功能的貓 87 class JumpCat extends Cat implements Jumpping  88 { 89     public JumpCat() {} 90      91     public JumpCat(String name,int age)  92     { 93         super(name,age); 94     } 95  96     public void jump()  97     { 98         System.out.println("跳高貓"); 99     }100 }101 102 //有跳高功能的狗103 class JumpDog extends Dog implements Jumpping 104 {105     public JumpDog() {}106     107     public JumpDog(String name,int age) 108     {109         super(name,age);110     }111 112     public void jump() 113     {114         System.out.println("跳高狗");115     }116 }117 class Demo118 {119     public static void main(String[] args)120     {121         //定義貓并測試122         JumpCat jc = new JumpCat();123         jc.setName("哆啦A夢");124         jc.setAge(3);125         System.out.println(jc.getName()+"---"+jc.getAge());126         jc.eat();127         jc.sleep();128         jc.jump();129         System.out.println("-----------------");130         131         JumpCat jc2 = new JumpCat("加菲貓",2);132         System.out.println(jc2.getName()+"---"+jc2.getAge());133         jc2.eat();134         jc2.sleep();135         jc2.jump();136     }137 }
運行結(jié)果:
哆啦A夢---3貓吃魚睡覺跳高貓------------加菲貓---2貓吃魚睡覺跳高貓
09.32 老師學(xué)生案例加入抽煙功能分析及代碼實現(xiàn)
  1 /*  2 老師和學(xué)生案例,加入抽煙的額外功能  3 分析:從具體到抽象  4 老師:姓名，年齡，吃飯，睡覺  5 學(xué)生:姓名，年齡，吃飯，睡覺  6 由于有共性功能，我們提取出一個父類，人類。  7 人類:  8     姓名，年齡  9     吃飯(); 10     睡覺(){} 11 抽煙的額外功能不是人或者老師，或者學(xué)生一開始就應(yīng)該具備的，所以，我們把它定義為接口 12 部分老師抽煙:實現(xiàn)抽煙接口 13 部分學(xué)生抽煙:實現(xiàn)抽煙接口 14 實現(xiàn):從抽象到具體 15 */ 16 //定義抽煙接口 17 interface Smoking  18 { 19     //抽煙的抽象方法 20     public abstract void smoke(); 21 } 22  23 //定義抽象人類 24 abstract class Person  25 { 26     //姓名 27     private String name; 28     //年齡 29     private int age; 30      31     public Person() {} 32      33     public Person(String name,int age) 34     { 35         this.name = name; 36         this.age = age; 37     } 38      39     public String getName()  40     { 41         return name; 42     } 43      44     public void setName(String name)  45     { 46         this.name = name; 47     } 48      49     public int getAge()  50     { 51         return age; 52     } 53      54     public void setAge(int age)  55     { 56         this.age = age; 57     } 58      59     //吃飯(); 60     public abstract void eat(); 61      62     //睡覺(){} 63     public void sleep() 64     { 65         System.out.println("睡覺"); 66     } 67 } 68  69 //具體老師類 70 class Teacher extends Person  71 { 72     public Teacher() {} 73      74     public Teacher(String name,int age)  75     { 76         super(name,age); 77     } 78      79     public void eat()  80     { 81         System.out.println("吃大白菜"); 82     } 83 } 84  85 //具體學(xué)生類 86 class Student extends Person  87 { 88     public Student() {} 89      90     public Student(String name,int age)  91     { 92         super(name,age); 93     } 94      95     public void eat()  96     { 97         System.out.println("吃紅燒肉"); 98     } 99 }100 101 //抽煙的老師102 class SmokingTeacher extends Teacher implements Smoking 103 {104     public SmokingTeacher() {}10