答案是：不必须。

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

说一下我个人的理解吧。

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抽象类本身的要求抽象类是不能被实例化的，抽象类只能作为其他类的父类，或者通过向上转型指向其子类。所以既然抽象类是不允许被实例化的，那么他的构造方法存在是否还有实际意义？

直接上例子

//抽象父类
abstract public class Shape {
    public Shape(){
        System.out.println("这是Shape的构造方法");
    }

    public Shape(String test){
        System.out.println(test);
    }

    abstract public double area();
}

//子类
public class Circle extends Shape {
    public final double PI=3.14;

    private double r;       //半径

    public Circle() {
    }

    public Circle(double r) {
        super("测试");
        this.setR(r);
    }

    public double getR() {
        return r;
    }

    public void setR(double r) {
        this.r = r;
    }

    @Override
    public double area() {
        return PI*this.getR()*this.getR();
    }
}

//子类
public class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle() {
    }

    public Rectangle(double length, double width) {
        this.setLength(length);
        this.setWidth(width);
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    @Override
    public double area() {
        return this.getLength()*this.getWidth();
    }
}

//测试类
public class TestShape {
    public static void main(String[] args) {
        Shape shape1 =new Circle(3);
        Shape shape2=new Rectangle(3,4);
        System.out.println("圆的面积为："+shape1.area());
        System.out.println("矩形的面积为："+shape2.area());
    }
}

这里是程序的输出结果

显然，抽象父类的构造方法都被执行到了

简单解释下原因，在实例化子类对象的时候，无论子类的父类是不是抽象类都会先调用父类的构造方法，如果你在实例化子类对象的地方打上断点逐步执行，你会发现在执行子类构造方法之前会先进到父类中执行父类的构造方法，初始化一个子类会先初始化父类。

所以父类的构造方法是会被执行到的，可以在其中完成一些你的业务逻辑