直接给答案：可以

无论是无参构造方法，还是有参构造方法都可以正常存在

之所以产生这个疑问，是因为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());
    }
}

这里是程序的输出结果

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

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

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

转载于:https://my.oschina.net/craftsdream/blog/518074

接口可以继承接口。

抽象类并不能继承接口，但可以实现接口。

抽象类可以继承具体类，前提是具体类必须具有构造函数且具有访问权限。这里需要说明，当一个具体类没有写构造函数时，系统会自动生成默认的无参构造器，意味着没有写构造函数的具体类也可以被抽象类继承。但是，一旦将具体类的无参构造器设置访问修饰符为 private 时，抽象类则不可以继承。

抽象类可以有静态的 main 方法。抽象类在面向对象中是被用来描述现实中的抽象事物, 抽象类没有对象概念所以不能被实例化. 但可以定义属性和方法, 其中属性方法都可以是静态的. 静态的意义其实就是在栈内存中只有一个, 所以该成员也会先于对象出现在内存中, 所以静态并没有违反抽象的原则. 抽象类中可以定义静态成员.

interface IA{}
interface IB{}
interface I extends IA,IB{}//接口可以继承多个接口
abstract class E implements IA{} //抽象类可以实现接口，但不可以继承接口
abstract class F extends C{}//抽象类可以继承具体类
class D{private D(){}}
//abstract class G extends D{}//Implicit super constructor D() is not visible for default constructor. Must define an explicit constructor抽象类不可以继承无权限构造器的具体类
abstract class H{public static void main() {}}//抽象类可以有静态的main方法