为啥可以在子类中可以调用父类（这个父类是抽象类）的构造函数，抽象类不是不可以实例化吗

为什么可以在子类中可以调用父类（这个父类是抽象类）的构造函数，抽象类不是不可以实例化吗？
小弟新学Java碰到了一个问题，JAVA API源代码StringBuffer类中有这样的构造函数：

public StringBuffer() {

        super(16);

    }

这个构造函数调用了父类的构造函数，他的父类是AbstractStringBuilder，在这个类中的相对应super(16)的构造函数是：

AbstractStringBuilder(int capacity) {

        value = new char[capacity];

    }

突然想到了一个问题，抽象类不是不可以实例化吗？怎么这里就实例化了？
------解决思路----------------------

package topics_390904318;


abstract class AbstractBaseClass {

    char value[];


    AbstractBaseClass(int capacity) {

        System.out.println("    AbstractBaseClass.AbstractBaseClass(int capacity)"

                + ":Start");

        value = new char[capacity];

        System.out.println("    AbstractBaseClass.AbstractBaseClass(int capacity)"

                + ":End");

    }


    public int capacity() {

        System.out.println("    AbstractBaseClass.capacity()" + ":Start");

        System.out.println("    AbstractBaseClass.capacity()" + ":End");

        return value.length;

    }

}


class DerivedClass extends AbstractBaseClass {

    DerivedClass() {

        super(16);

        System.out.println("    DerivedClass.DerivedClass()" + ":Start");

        System.out.println("    DerivedClass.DerivedClass()" + ":End");

    }

}


public class AbstractTest {


    public static void main(String[] args) {

        System.out.println("AbstractTest.main(String[] args)" + ":Start");

        // StringBuffer不是抽象类，所以下面的写法是合法的

        StringBuffer stringBuffer = new StringBuffer();


        // 抽象类不可以实例化指的是不允许像下面这么使用

        // 没说不让调用父类的构造函数

        // AbstractStringBuilder abstractStringBuilder = new

        // AbstractStringBuilder();


        DerivedClass derivedClass = new DerivedClass();

        System.out

                .println("derivedClass.capacity()=" + derivedClass.capacity());


        System.out.println("AbstractTest.main(String[] args)" + ":End");

    }


}

AbstractTest.main(String[] args):Start

    AbstractBaseClass.AbstractBaseClass(int capacity):Start

    AbstractBaseClass.AbstractBaseClass(int capacity):End

    DerivedClass.DerivedClass():Start

    DerivedClass.DerivedClass():End

    AbstractBaseClass.capacity():Start

    AbstractBaseClass.capacity():End

derivedClass.capacity()=16

AbstractTest.main(String[] args):End