18.【抽象类】

概述

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

• 抽象方法：没有方法体的方法。
• 抽象类：包含抽象方法的类。

抽象方法

使用abstract关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
定义格式：

修饰符 abstract 返回值类型方法名(参数列表);

代码举例：

public abstract void run();

抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。
定义格式：

abstract class 类名称 {
    
}

代码举例：

public abstract class Animal {
    public abstract void eat();
}

使用方式

如何使用抽象类和抽象方法：

1. 不能直接创建new抽象类对象。

2. 必须用一个子类来继承抽象父类。

3. 子类必须覆盖重写父类当中所有的抽象方法。

   覆盖重写(实现)：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。

4. 创建子类对相关进行使用。

抽象类细节

1. 抽象类不能创建对象

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

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

代码；

public abstract class Animal {

    // 这是一个抽象方法，代表吃东西，但具体吃什么(大括号的内容)不确定。
    public abstract void eat();

    // 这是普通的成员方法
    public void normalMethod() {

    }
}

Cat

package cn.luis.demo9;

public class Cat extends Animal {

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

DemoMain

package cn.luis.demo9;

public class DemoMain {

    public static void main(String[] args) {
//        Animal a = new Animal();  // 错误写法！不能直接new抽象类对象。
        Cat cat = new Cat();
        cat.eat();
    }
}

结果：

猫吃鱼！

2. 抽象类中可以有构造方法

它是供子类创建对象时，初始化父类成员使用的。

子类的构造方法中，有默认的super(); 需要访问父类构造方法。

代码：

DemoMain

package cn.luis.demo10;

public class DemoMain {

    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.eat();

    }
}

package cn.luis.demo10;

public abstract class Fu {

    public Fu() {
        System.out.println("抽象父类构造方法执行");
    }

    public abstract void eat();
}


package cn.luis.demo10;

public class Zi extends Fu {

    public Zi() {
        // super();
        System.out.println("子类构造方法执行");
    }

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

结果：

抽象父类构造方法执行
子类构造方法执行
吃饭饭

3. 抽象类不一定含有抽象方法

只要保证抽象方法所在的类是抽象类即可。

这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。

代码：

package cn.luis.demo10;

public abstract class MyAbstract {
}

Animal

package cn.luis.demo11;
// 最高的抽象父类
public abstract class Animal {

    public abstract void eat();

    public abstract void sleep();


}

Dog

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

package cn.luis.demo11;

/*
    子类也是一个抽象类
    是父亲辈，只对一个抽象方法进行了处理，另一个没有理会
 */
public abstract class Dog extends Animal {
    
//    public abstract void eat();// 继承下来了一个抽象方法，所以类必须是抽象类

    @Override
    public void sleep() {
        System.out.println("呼噜噜~~~~~~");
    }
}

Dog2Ha

package cn.luis.demo11;

// 是一个普通子类，孙子辈 二哈
public class Dog2Ha extends Dog {

    @Override
    public void eat() {
        System.out.println("二哈吃饺子!");
    }
}

**DogGolden **

package cn.luis.demo11;

// 是一个普通子类，孙子辈 金毛
public class DogGolden extends Dog {

    @Override
    public void eat() {
        System.out.println("金毛吃火腿!");
    }
}

3. 抽象类的子类，必须重写抽象父类中所有的抽象方法

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

假设不重写所有抽象方法，则类中可能包含抽象方法。

那么创建对象后，调用抽象的方法，没有意义。

代码：

DemoMain

package cn.luis.demo11;

/*
   
*/

public class DemoMain {

    public static void main(String[] args) {
//        Animal A = new Animal();  // 错误！

//        Dog dog = new Dog();  // 错误！这也是一个抽象类

        Dog2Ha ha = new Dog2Ha();  // 这是普通类，可以直接new对象。
        ha.eat();
        ha.sleep();
        System.out.println("================");

        DogGolden golden = new DogGolden();
        golden.eat();
        golden.sleep();

    }
}

结果：

二哈吃饺子!
呼噜噜~~~~~~
================
金毛吃火腿!
呼噜噜~~~~~~

总结

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

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

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

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

   理解：子类的构造方法中，有默认的super（），需要访问父类构造方法。

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

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

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

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