4.0、Java继承与多态 - 抽象类与抽象方法

4.0、Java继承与多态 - 抽象类与抽象方法

先给大家举个例子 ->

创建一个父类 - 图形类；图形类中有一个计算面积的方法 calculateArea()；

创建三个子类 - 正方形、三角形、圆形 类；

        由于我们图形类父类中未明确指明是什么图形，所以他的计算面积的方法也无法实现，因为你不知道到底是什么图形嘛；那么这种方法就被我们称作为 抽象方法；

        而下图中的正方形、三角形、圆形三个子类，都是继承自父类图形类；父类中的抽象方法在被子类继承之后会被重写（实现）；

 

如何创建一个抽象类以及抽象方法呢？ 如下代码所示->

/**
 * 抽象类：抽象方法所在的类，必须是抽象类；也就是说拥有抽象方法的类一定是抽象类；在 class 前加上 abstract 即可；
 * 抽象方法：就是加上 abstract 关键字，然后去掉大括号，直接分号结束即可；
 */
    //创建一个抽象类 Shapes
public abstract class Shapes {
    //创建一个抽象方法，代表计算图形的面积；
    //但是具体如何计算（方法体）不确定；
    public abstract void calculateArea();
    //在一个抽象类中定义普通方法也是可以的 ->
    public void normalMethod() {
        System.out.println("这是一个普通方法~");
    }
}

        - 抽象类：抽象方法所在的类，必须是抽象类；[ 也就是说拥有抽象方法的类一定是抽象类 ]；在 class 前加上 abstract 即可；

        - 抽象方法：就是加上 abstract 关键字，然后去掉大括号，直接分号结束即可；

        - 当然在抽象类中也不一定只有抽象抽象方法，也是可以定义普通方法的；

如何使用抽象类和抽象方法呢？

        注意：不能直接创建 new 抽象对象；[ 其实很好理解 -> 创建对象的过程也称之为实例化，既然已经实例化了，肯定是应该得到一个具体的对象，而不是一个抽象的对象 ]；

        第一步：创建一个子类来继承抽象父类；

        第二步：子类必须覆盖重写（ 或者叫 - 实现 ）父类中所有的抽象方法 [ 实际上就是将父类中的抽象方法去掉 abstract 然后加上方法体 ]；

        注意：[ 如果希望子类为普通类，那么子类就必须要实现父类中所有的抽象方法；因为如果没有实现父类中所有的抽象方法，子类中继承了这些没有实现的抽象方法，那么会导致子类也会变成抽象类； ]

        第三步：最后创建子类对象进行使用；

上代码理解一下 ->
创建子类正方形类 Square.java 文件，并继承上面已创建好的父类图形 Shapes 类如下所示 ->

public class Square extends Shapes {
    @Override
    public void calculateArea() {
        System.out.println("长乘宽得到正方形的面积");
    }
}

注意事项

        关于抽象类的使用，一下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背；

        1.抽象类不能创建对象，如果创建，编译无法通过会报错；只能创建其非抽象子类的对象；

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义；

        2.抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的；

理解：子类的构造方法中，有默认的 super() ，会默认访问父类的构造方法；

        3.抽象类中，不一定包含抽象方法，但是有抽象方法的必定只有抽象类；

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的结构设计；

        4.抽象类的子类，必须重写父类中所有的抽象方法，否则编译无法通过会报错；除非子类也是抽象类；

理解：假设不重写所有的抽象方法，则类中可能包含抽象方法；那么创建对象后，调用抽象的方法，没有意义；

一定有人会疑惑为什么会有子类不重写所有父类抽象方法的情况存在；

下面给大家举个父类是抽象类，子类也是抽象类，然后子类的子类是普通类的例子 ->

- 创建 Animal.java 顶级父类，文件如下所示 ->

public abstract class Animal {

    public Animal() {
        System.out.println("Animal构造方法执行......");
    }
    //动物的饮食
    public abstract void eat();
    //动物的颜色
    public abstract void color();
}

- 创建 Cat.java 且让他继承自上面 Animal 父类，文件如下所示->

public abstract class Cat extends Animal {

    public Cat() {
        System.out.println("Cat构造方法执行......");
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼......");
    }
}

- 创建 MuppetCat.java 布偶猫类，且让他继承自上面的 Cat 父类，文件如下所示->

//布偶猫
public class MuppetCat extends Cat {

    public MuppetCat() {
        System.out.println("MuppetCat构造方法执行......");
    }

    @Override
    public void color() {
        System.out.println("布偶猫 - 白色");
    }
}

- 创建 OrangeCat.java 橘猫类，且让他也继承自上面的 Cat 父类，文件如下所示 ->

//橘猫
public class OrangeCat extends Cat {

    public OrangeCat() {
        System.out.println("OrangeCat构造方法执行......");
    }

    @Override
    public void color() {
        System.out.println("橘猫 - 橘色");
    }
}

- 创建测试类 CatMain.java 文件如下所示 ->

public class CatMain {

    public static void main(String[] args) {
//        Animal animal = new Animal();//错误，无法创建抽象类对象
//        Cat cat = new Cat();//错误，无法创建抽象类对象
        MuppetCat mc = new MuppetCat();
        mc.eat();
        mc.color();

        OrangeCat oc = new OrangeCat();
        oc.eat();
        oc.color();
    }
}

- CatMain.java文件，执行结果如下所示 ->

解释一下：

        由于 Animal 是顶级父类，Cat 是 Animal 子类，而 MuppetCat 是 Cat 的子类；所以当我们创建 MuppetCat 对象的时候，默认会执行 super()；方法调用父类的构造函数；所以可以看到上图中构造函数的执行顺序是 Animal -> Cat -> MuppetCat；[ 由于抽象类不能创建对象，所以这也是一种调用抽象类构造函数的方法； ]

        可以发现我们在 Cat 类中仅仅实现了抽象类父类 Animal 中的 eat() 方法，并没有实现 color() 方法，所以Cat 仍然是一个抽象类；[ 其实从逻辑上也很好理解，因为 Cat 仅仅是一个猫的类，并没有具体指明是什么品种的猫，所以只能确定猫的食物是鱼；而没法知道它是什么颜色，所以没法实现颜色的方法； ]

        最后在 MuppetCat 和 OrangeCat 两个类中，由于他们都继承自 Cat 类，而Cat又继承自 Animal 类，所以他们如果想要成为普通类就必须要实现 eat() 和 color() 两个抽象方法；而在 Cat 类中已经将 eat() 方法实现了，所以在这两个类里只需要实现 color() 方法即可成为普通类；

        然后就可以通过创建 MuppetCat 或者 OrangeCat 的对象去调用 eat() 和 color() 两个方法啦~