java基础学习总结——抽象类

一、抽象类介绍

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

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

作者：孤傲苍狼

来源：https://www.cnblogs.com/xdp-gacl/p/3648398.html