一、抽象類介紹
下面通過一下的小程序深入理解抽象類
因此在類Animal里面只需要定義這個enjoy()方法就可以了，使用abstract關鍵字把enjoy()方法定義成一個抽象方法，定義如下：public abstract void enjoy();
從某種意義上來說，抽象方法就是被用來重寫的，所以在父類聲明的抽象方法一定要在子類里面重寫。如果真的不想在子類里面重寫這個方法，那么可以再在子類里面把這個方法再定義為抽象方法，因為子類覺得我去實現也不合適，應該讓繼承我的子類去實現比較合適，因此也可以在繼承這個子類的下一個子類里面重寫在父類里面聲明的抽象方法，這是可以的。
這里有一個規則：既然父類里面的方法是抽象的，那么對於整個類來說，它就有一個沒有實現的方法，這個方法不知道怎么去實現，那么這個類是就是殘缺不全的，因此這個類應該被定義為一個抽象類。所以前面這樣聲明的聲明的class Animal應該要在class的前面加上abstract，即聲明成這樣：abstract class Animal，這樣Animal類就成了一個抽象類了。Animal類的最終定義代碼如下：
1 /** 2 * 父類Animal 3 * 在class的前面加上abstract，即聲明成這樣：abstract class Animal 4 * 這樣Animal類就成了一個抽象類了 5 */ 6 abstract class Animal { 7 8 public String name; 9 10 public Animal(String name) { 11 this.name = name; 12 } 13 14 /** 15 * 抽象方法 16 * 這里只有方法的定義，沒有方法的實現。 17 */ 18 public abstract void enjoy(); 19 20 }
Java語言規定，當一個類里面有抽象方法的時候，這個類必須被聲明為抽象類。
子類繼承父類時，如果這個父類里面有抽象方法，並且子類覺得可以去實現父類的所有抽象方法，那么子類必須去實現父類的所有抽象方法，如：
1 /** 2 * 子類Dog繼承抽象類Animal，並且實現了抽象方法enjoy 3 * @author gacl 4 * 5 */ 6 class Dog extends Animal { 7 /** 8 * Dog類添加自己特有的屬性 9 */ 10 public String furColor; 11 12 public Dog(String n, String c) { 13 super(n);//調用父類Animal的構造方法 14 this.furColor = c; 15 } 16 17 @Override 18 public void enjoy() { 19 System.out.println("狗叫...."); 20 } 21 22 }
這個父類里面的抽象方法，子類如果覺得實現不了，那么把就子類也聲明成一個抽象類，如：
1 /** 2 * 這里的子類Cat從抽象類Animal繼承下來，自然也繼承了Animal類里面聲明的抽象方法enjoy()， 3 * 但子類Cat覺得自己去實現這個enjoy()方法也不合適，因此它把它自己也聲明成一個抽象的類， 4 * 那么，誰去實現這個抽象的enjoy方法，誰繼承了子類，那誰就去實現這個抽象方法enjoy()。 5 * @author gacl 6 * 7 */ 8 abstract class Cat extends Animal { 9 10 /** 11 * Cat添加自己獨有的屬性 12 */ 13 public String eyeColor; 14 15 public Cat(String n, String c) { 16 super(n);//調用父類Animal的構造方法 17 this.eyeColor = c; 18 } 19 }
這里的子類Cat從抽象類Animal繼承下來，自然也繼承了Animal類里面聲明的抽象方法enjoy()，但子類Cat覺得自己去實現這個enjoy()方法也不合適，因此它把它自己也聲明成一個抽象的類，那么，誰去實現這個抽象的enjoy方法，誰繼承了子類，那誰就去實現這個抽象方法enjoy()。如：
1 /** 2 * 子類BlueCat繼承抽象類Cat，並且實現了從父類Cat繼承下來的抽象方法enjoy 3 * @author gacl 4 * 5 */ 6 class BlueCat extends Cat { 7 8 public BlueCat(String n, String c) { 9 super(n, c); 10 } 11 12 /** 13 * 實現了抽象方法enjoy 14 */ 15 @Override 16 public void enjoy() { 17 System.out.println("藍貓叫..."); 18 } 19 20 }
完整的測試代碼如下：
1 package javastudy.summary; 2 3 /** 4 * 父類Animal 5 * 在class的前面加上abstract，即聲明成這樣：abstract class Animal 6 * 這樣Animal類就成了一個抽象類了 7 */ 8 abstract class Animal { 9 10 public String name; 11 12 public Animal(String name) { 13 this.name = name; 14 } 15 16 /** 17 * 抽象方法 18 * 這里只有方法的定義，沒有方法的實現。 19 */ 20 public abstract void enjoy(); 21 22 } 23 24 /** 25 * 這里的子類Cat從抽象類Animal繼承下來，自然也繼承了Animal類里面聲明的抽象方法enjoy()， 26 * 但子類Cat覺得自己去實現這個enjoy()方法也不合適，因此它把它自己也聲明成一個抽象的類， 27 * 那么，誰去實現這個抽象的enjoy方法，誰繼承了子類，那誰就去實現這個抽象方法enjoy()。 28 * @author gacl 29 * 30 */ 31 abstract class Cat extends Animal { 32 33 /** 34 * Cat添加自己獨有的屬性 35 */ 36 public String eyeColor; 37 38 public Cat(String n, String c) { 39 super(n);//調用父類Animal的構造方法 40 this.eyeColor = c; 41 } 42 } 43 44 /** 45 * 子類BlueCat繼承抽象類Cat，並且實現了從父類Cat繼承下來的抽象方法enjoy 46 * @author gacl 47 * 48 */ 49 class BlueCat extends Cat { 50 51 public BlueCat(String n, String c) { 52 super(n, c); 53 } 54 55 /** 56 * 實現了抽象方法enjoy 57 */ 58 @Override 59 public void enjoy() { 60 System.out.println("藍貓叫..."); 61 } 62 63 } 64 65 /** 66 * 子類Dog繼承抽象類Animal，並且實現了抽象方法enjoy 67 * @author gacl 68 * 69 */ 70 class Dog extends Animal { 71 /** 72 * Dog類添加自己特有的屬性 73 */ 74 public String furColor; 75 76 public Dog(String n, String c) { 77 super(n);//調用父類Animal的構造方法 78 this.furColor = c; 79 } 80 81 @Override 82 public void enjoy() { 83 System.out.println("狗叫...."); 84 } 85 86 } 87 88 public class TestAbstract { 89 90 /** 91 * @param args 92 */ 93 public static void main(String[] args) { 94 95 /** 96 * 把Cat類聲明成一個抽象類以后，就不能再對Cat類進行實例化了， 97 * 因為抽象類是殘缺不全的，缺胳膊少腿的，因此抽象類不能被實例化。 98 */ 99 //Cat c = new Cat("Catname","blue"); 100 Dog d = new Dog("dogname","black"); 101 d.enjoy();//調用自己實現了的enjoy方法 102 103 BlueCat c = new BlueCat("BlueCatname","blue"); 104 c.enjoy();//調用自己實現了的enjoy方法 105 } 106 }