一、抽象类介绍

　　

下面通过一下的小程序深入理解抽象类

　　因此在类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 }