Java中什么是抽象类？

---

抽象的概念

  比如我们把动物看作是一个父类，里面有个吃东西的方法；猫和狗都属于动物，可以看成继承于动物这个父类的两个子类。狗类里有个吃东西的方法是狗吃骨头，猫类中也有一个吃东西的方法是猫吃鱼。猫和狗我们都知道具体是吃什么的，但是父类是动物，是什么动物不具体，太抽象了，我们不知道动物吃什么，所以父类中吃东西的方法就是一个抽象方法。

因此Java中父类中的方法不确定如何进行方法体的实现，那么这就应该是一个抽象方法。

---

一、抽象方法和抽象类的格式

抽象方法：

就是加上 abstract关键字，然后去掉大括号{}，直接分号结束。

抽象类：

抽象方法所在的类，必须是 抽象类，在 class关键字之前加上 abstract即可。

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

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

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

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

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

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

代码如下（示例）：

1.定义一个父类（动物抽象类）

public abstract class Animal {

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

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

    }
}

2.定义一个子类（猫类）继承于父类（动物抽象类）

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

3.创建子类对象进行使用

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

---

二、注意事项

关于抽象类的使用，以下为语法上要注意的细节：

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

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

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

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

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

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

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

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

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

代码如下（示例）：

(1)定义一个父类（动物抽象类）

public abstract class Animal {

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

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

    }
}

(2)创建子类对象进行使用

public class DemoMain {
    public static void main(String[] args) {
        //Animal animal = new Animal(); // 错误写法！不能直接创建抽象类对象
    }
}

2.抽象类中，可以有 构造方法，是供子类创建对象时，初始化父类成员使用的。
代码如下（示例）：

(1)定义一个抽象父类

public abstract class Fu {

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

(2)定义一个子类继承于父类

public class Zi extends Fu {

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

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

(3)创建子类对象

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

输出结果：
 抽象父类构造方法执行
 子类构造方法执行
 吃饭饭


3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
代码如下（示例）：

/*
一个抽象类不一定含有抽象方法，
只要保证抽象方法所在的类是抽象类，即可。

这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。
 */
public abstract class MyAbstract {
}

4.抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
代码如下（示例）：

(1)定义一个动物抽象类（父类）

// 最高的抽象父类
public abstract class Animal {

    public abstract void eat();

    public abstract void sleep();

}

(2)定义一个狗类（子类）

// 子类也是一个抽象类
public class Dog extends Animal  {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    //此时会报错，因为该子类不是一个抽象类，没有重写抽象父类中所有的抽象方法
}

正确写法

// 子类也是一个抽象类
public abstract class Dog extends Animal {

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

    // public abstract void sleep();
}

Dog类也是一个抽象类，这种情况下如何使用该类呢？

(3)定义一个Dog2Ha类（子类）继承Dog类

public class Dog2Ha extends Dog {

    @Override
    public void sleep() {
        System.out.println("嘿嘿嘿……");
    }
}

定义一个DogGolden类（子类）继承Dog类

public class DogGolden extends Dog {
    @Override
    public void sleep() {
        System.out.println("呼呼呼……");
    }
}

(4)创建对象使用

public class DemoMain {

    public static void main(String[] args) {
        //Animal animal = 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();
    }

}

输出结果：
 狗吃骨头
 嘿嘿嘿……
 ==========
 狗吃骨头
 呼呼呼……

---

总结

以上就是抽象类的使用，希望对大家有所帮助。