答案是：不必须。

这个题目主要是考察对抽象类的理解。

说一下我个人的理解吧。

1.如果一个类使用了abstract关键字修饰，那么这个类就是一个抽象类。

2.抽象类可以没有抽象方法

3.一个类如果包含抽象方法，那么这个类必须是抽象类，否则编译就会报错。

4.最关键的一点就是如果一个类是抽象类，那么这个类是不能被实例化的。

  如下：     

public abstract class  MQTest {
    
}

 现在user这个类就是一个抽象类，如果直接 使用该类创建新对象是行不通的,编译直接报错。

抽象类只能用其子类（该子类不能是抽象类）去创建新对象。

接下来我就用狗的例子来说明，先创建一个动物类（抽象类），然后创建一个狗类（抽象类），狗下面再分为金毛和二哈（非抽象类）。

动物类：

package com.xingli.abstractDemo;

import lombok.Data;

/**
 *@ClassName Animal
 *@Description 动物抽象类
 *@Auther William
 *@Date 2019/7/22 14:11
 *@Version 1.0
 */
@Data
public abstract class Animal {   
   //定义一个抽象的“让动物叫”的方法 
   public abstract void say();
}

狗类：

package com.xingli.abstractDemo;

/**
 *@ClassName Dog
 *@Description 狗类的抽象方法
 *@Auther William
 *@Date 2019/7/22 14:13
 *@Version 1.0
 */
public abstract class Dog extends Animal{
    //默认继承父类的say方法
}

金毛：

package com.xingli.abstractDemo;

/**
 *@ClassName JINMAODog
 *@Description 金毛
 *@Auther William
 *@Date 2019/7/22 14:16
 *@Version 1.0
 */
public class JINMAODog extends Dog{

    //实现父类的抽象方法
    @Override
    public void say() {
        System.out.println("金毛：我的名字叫金毛");
    }

}

二哈：

package com.xingli.abstractDemo;

/**
 *@ClassName ERHADog
 *@Description 二哈
 *@Auther William
 *@Date 2019/7/22 14:21
 *@Version 1.0
 */
public class ERHADog extends Dog{
    @Override
    public void say() {
        System.out.println("二哈：我的名字叫二哈");
    }
}

直接父类创建新对象：结果报错

使用动物子类创建新对象，因为狗类也是抽象接口所以也报错

使用非抽象子类创建新对象（正确）

public class Test {
    public static void main(String[] args) {
        Animal erhaDog = new ERHADog();
        Animal jinmaoDog = new JINMAODog();
        erhaDog.say();
        jinmaoDog.say();
    }
}

在回答这个问题之前，先来了解一下抽象类。

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。（菜鸟教程）

抽象方法只包含一个方法名，而没有方法体。

先定义一个抽象类

public abstract class Student {
    private String name;
    private int age;

     public Student(){};

    public Student(String name,int age,String adrees){
        this.name=name;
        this.age=age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
    }

当尝试new对象的时候，会出现以下错误。

我们定义一个pupil类继承Student,并且new个对象

public class pupil extends Student{

    private String name;
    private int age;
    
    public pupil(String name, int age) {//子类在调用父类时 无论自己有没有构造方法都会先去执行父类无参的函数，或者显示调用父类的有参构造函数          
        super(name, age); 
    }
    
    public static void main(String[] args) {
        pupil p = new pupil("ma", 12);
         p.setAge(18); //调用的是父类的方法
        System.out.println(p.getAge()); //18
    }
}

实例化一个 pupil类对象，该对象将从 Student类继承 7 个成员方法，且通过该方法可以设置或获取两个成员变量。
我们在Student里面新增一个抽象方法

public abstract void Shuchu();

继承Student的pupil必须实现父类的抽象方法。

@Override
    public void Shuchu() {
        System.out.println(name+age);
    }

这里要注意，如果构造方法走的是父类的，那么打印出来的值将为空，因为值赋值给了父类的变量，pupil里面的变量值还是空的。

总结以上，抽象类并不是一定需要抽象方法，但是一个类拥有抽象方法，那么这个类必须是抽象类，子类必须实现父类的抽象方法，或者子类本身也为抽象类，抽象类绝对不能用来初始化对象。

1. 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。

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

3. 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。

4. 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

6. 抽象方法需要被实现，不能被声明为静态，private，final修饰