1.Java中的多態
多態是指對象的多種形態，主要包括這兩種：
1.1引用多態
a.父類的引用可以指向本類的對象
b.父類的引用可以指向子類的對象
舉個例子：父類Anmail,子類Dog,可以使用父類Anmail來創建父類或者子類的對象，但是子類無法創建父類的對象
1 //父類
2 public class Animal {
3
4 }
5
6 //子類
7 public class Dog extends Animal {
8
9
10 }
11
12 //測試類，創建子類對象
13 public class testDog {
14 public static void main(String[] args) {
15 //引用多態a.父類的引用指向本類的對象
16 Animal obj1 = new Animal();
17 //引用多態b.父類的引用指向子類的對象
18 Animal obj2 = new Dog();
19 //引用多態，子類的引用不能指向父類的對象，下面是錯誤的
20 //Dog obj3 = new Animal();
21 }
22
23 }1.2方法多態
a.創建本類對像時，調用的方法爲本類方法
b.創建子類對像時，調用的方法爲子類重寫的方法或者繼承的方法
c.如果創建子類對象時，不能調用在子類中新寫的方法
1 //父類
2 public class Animal {
3 public void eat(){
4 System.out.println("動物具有吃的能力！");
5 }
6
7 }
8
9 //子類
10 public class Dog extends Animal {
11 public void eat(){
12 System.out.println("狗是吃肉的！");
13 }
14
15 public void watchDoor(){
16 System.out.println("狗具有看門的能力！");
17 }
18
19 }
20
21
22 //子類
23 public class Cat extends Animal {
24
25 }
26
27 //測試類，創建子類對象
28 public class testDog {
29 public static void main(String[] args) {
30 //引用多態a.父類的引用指向本類的對象
31 Animal obj1 = new Animal();
32 //引用多態b.父類的引用指向子類的對象
33 Animal obj2 = new Dog();
34 //引用多態，子類的引用不能指向父類的對象，下面是錯誤的
35 //Dog obj3 = new Animal();
36 Animal obj3 = new Cat();
37
38 obj1.eat(); //調用的是父類的方法
39 obj2.eat(); //調用的是子類重寫的方法
40 obj3.eat(); //調用子類繼承的方法
41 //obj2.watchDoor(); //父類中不存在，則子類沒有繼承到這個方法，則無法調用
42 }
43
44 }2.多態中的引用類型轉換
1.向上類型轉換（隱式/自動類型轉換），是小類型到大類型的轉換
2.向下類型轉換（強制類型轉換），是大類型到小類型的轉換
3.instanceof運算符，用來解決引用對象的類型，避免類型轉換的安全性問題
下面是一個例子，只放測試類，子類和父類跟上面是一樣的
1 //測試類
2 public class testDog {
3 public static void main(String[] args) {
4 Dog dog = new Dog();
5 Animal animal = dog; //自動類型提升 向上類型轉換，這種操作是沒有問題的
6 //Dog dog2 = animal; //向下類型轉換，出現了問題，不錯誤
7 //上面是錯誤的，下面是強制做類型轉換，
8 Dog dog2 = (Dog) animal;//向下類型轉換 強制類型轉換
9 //強制類型轉換容易出現問題，可以用下面的最佳方法進行轉換
10 if (animal instanceof Dog){
11 Dog dog3 = (Dog) animal;
12 }else {
13 System.out.println("無法進行強制類型轉換");
14 }
15 }
16 }instanceof通過返回一個布爾值來指出，這個對象是否是這個特定類或者是它的子類的一個實例。
3.Java中的抽象類
3.1語法定義
在一個類前面使用abstract關鍵字修飾，則該類爲抽象類
3.2應用場景
a.在某些情況下，抽象類是約束子類必須要有哪些方法，但是卻不要求是怎麼實現的
b.從多個具有相同特徵的類中抽象出一個抽象類，以這個抽象類作爲子類的模板，從而避免了子類設計的隨意性。
3.3作用
限制規定子類必須實現某些方法，但不關注實現細節
抽象的意義在於：將方法的設計和實現分離了
3.4使用規則
a.abstract定義抽象類
b.abstract定義抽象方法，只有聲明，不需要實現
c.包含抽象方法的類是抽象類
d.抽象類不能直接創建，可以定義引用變量
1 public abstract class Telphone {
2 //父類抽象類定義了兩個方法，子類要來實現這兩個方法
3 //下面是兩個抽象類，注意定義的方法，不用寫大括號
4 public abstract void call();
5 public abstract void message();
6
7 }
8
9 public class CellPhone extends Telphone {
10 子類實現抽象類中規定要實現的方法
11 @Override
12 public void call() {
13 System.out.println("通過鍵盤打電話");
14 }
15
16 @Override
17 public void message() {
18 System.out.println("通過鍵盤發短信");
19 }
20 }4.Java中的接口
4.1接口概念
類是具體實現某一些功能的集合，而接口定義了某一批類所要遵守的規範，而不關心這些數據。
在大型項目中，設計人員只需要在接口中設計好什麼方法返回什麼值，剩下的就需要程序員利用類來實現這些方法了。
4.2語法格式
[修飾符] interface 接口名 [extends 父接口1，父接口2……]{
零到多個常量定義……
零個到多個抽象方法的定義……
}4.3接口定義
修飾符：因爲接口是設計好要用來繼承和實現的，所以修飾符用public，不能使用private和protected。
abstract:接口也是抽象的，跟抽象類一樣，要實現這裏定義的方法，所有要添加abstract，但是一般系統會默認添加，所有不用重複寫了
繼承：一個接口可以繼承多個父接口，這是一個需要注意的地方
定義：接口裏面只需要定義常量或者抽象方法
interface:和類定義不同，定義接口不再使用class關鍵字，要換成interface關鍵字
常量:接口中的屬性是常量，即使定義時不添加public static final修飾符，系統也會自動加上
方法：接口的方法只能是抽象方法，總是被使用，即使定義時不添加public abstract修飾符，系統也會自動添加上。
4.4實現接口
一個類可以實現一個或者多個類，實現接口使用implements關鍵字。java中一個類只能繼承一個父類，是不夠靈活的，但是通過實現多個接口可以做補充
繼承父類實現接口的語法爲：
[修飾符] class 類名 extends 父類 implements 接口1，接口2……
{
類體部分 //如果繼承了抽象類，需要實現繼承的抽象方法；要實現接口中的抽象方法
}如果要繼承父類，繼承父類必須在實現接口之前，即extends和implements不能調換
4.5例子
以下例子，我們在上面的例子上添加了一個IPlayGame接口，接口前面一般都用I標識，方便區分。然後分別在一個Psp類中實現了接口中的方法，也在一個繼承了父類的子類中實現了接口的方法，需要注意創建接口引用對象的方法
1 //定義一個接口，設計了一個方法
2 public interface IPlayGame { //省略了abstract關鍵字
3 public void playGame(); //省略了abstract關鍵字
4 }
5
6
7 //定義了一個抽象類
8 public abstract class Telphone {
9 //下面是兩個抽象類，注意定義的方法，不用寫大括號
10 public abstract void call();
11 public abstract void message();
12
13 }
14
15
16 //實現抽象類的類
17 public class CellPhone extends Telphone {
18 @Override
19 public void call() {
20 System.out.println("通過鍵盤打電話");
21 }
22
23 @Override
24 public void message() {
25 System.out.println("通過鍵盤發短信");
26 }
27 }
28
29
30
31 //PSP單獨一個類實現IplayGame接口
32 public class Psp implements IPlayGame {
33 @Override
34 public void playGame() {
35 System.out.println("具有了玩遊戲的功能");
36 }
37 }
38
39
40 //實現Telphone類，並實現IPlayGame接口
41 public class SmartPhone extends Telphone implements IPlayGame{
42 @Override
43 public void call() {
44 System.out.println("通過語音打電話");
45 }
46
47 @Override
48 public void message() {
49 System.out.println("通過語音發短信");
50 }
51
52 //實現IPlayGame接口
53 @Override
54 public void playGame() {
55 System.out.println("智能手機具有玩遊戲的功能");
56 }
57 }4.6另一種使用接口使用方法
使用接口:
接口在使用過程當中，還經常與匿名內部類配合使用
匿名內部類就是沒有名字的內部類，多用於關注實現而不關注實現類的名稱
語法格式
直接new一個接口，並在這個new裏面實現這個方法
Interface i = new Interface(){
public void method(){
System.out.println("匿名內部類實現接口的方法");
}
}在4.5裏的例子上修改：
1 public class intail {
2 public static void main(String[] args) {
3
4 //接口引用 一個 實現了接口的對象
5 IPlayGame ip1 = new SmartPhone();
6 ip1.playGame(); //調用方法
7 IPlayGame ip2 = new Psp();
8 ip2.playGame();
9
10
11 //使用匿名內部類實現接口，方法1
12 IPlayGame ip3 = new IPlayGame() {
13 @Override
14 public void playGame() {
15 System.out.println("使用匿名內部類的方法接口111");
16 }
17 };
18 ip3.playGame();
19
20
21 //也可以直接new來用匿名內部類實現接口，方法2
22 new IPlayGame(){
23 public void playGame(){
24 System.out.println("使用匿名內部類的方法接口222");
25 }
26 }.playGame();
27 }
28 }