IIOException如何没有no-arg构造函数？

Question

Suppose we have a class NoArgConstructorClass in a file NoArgConstructorClass.java

/* first example */
import javax.imageio.IIOException;

public class NoArgConstructorClass
{    
    public static void main(String[] args)
    {
        NoArgConstructorClass n = new NoArgConstructorClass();
        IIOException e = new IIOException();
    }
}

This code on compilation produces error: no suitable constructor found for IIOException.

Since IIOException should have a no-arg constructor (added by compilator), how it is made that there is no no-arg constructor for IIOException?

/** second example, showing that ClassB inherits a no-arg constructor from Object */
/** put in ConstructorChain.java */
public class ConstructorChain
{
    public static void main(String[] args)
    {
        ClassB b = new ClassB();
    }
}

/** put in ClassA.java */
public class ClassA
{
    public ClassA()
    {
        System.out.println("Class A");
    } 
}

/** put in ClassB.java */
public class ClassB
    extends ClassA
{
}

Answer 1

Q. This code on compilation produces error: no suitable constructor found for IIOException.

If you look at the docs of IIOException , you can see that it does not have a default(no-arg) constructor. It has 2 constructors and both are parameterized(single parameter and double parameter). That is why you get the compilation error when you try to create a IIOException instance with the no-arg constructor.

---

Q. Since IIOException should inherit a no-arg constructor from Object, how it is made that there is no no-arg constructor for IIOException?

It doesn't inherit a no-arg constructor. When a class is inherited, you either add a call to its super class constructor using super() or the compiler does that in case you don't do it. So the constructor of the IIOException would look something like this.

public IIOException(String message) {
    // if the below line is not present, the compiler adds it
    super(); // This calls the parent class (IOException) constructor and since there is a no-arg constructor there, its perfectly valid
    ... // other code
}

---

I re-read your question twice now, and I think you are taking the compiler's adding of a default no-arg constructor as an constructor inherited from the parent class.

As mentioned in the JLS-8.8.9 (thanks to the OP for the link),

If you have a class without a constructor(with or without arg), the compiler adds a default no-arg constructor by itself. BUT if you specify a constructor with arg and do not specify a no-arg constructor, then the compiler DOES NOT add a default no-arg constructor to the class. Let me cite an example.

class A {}

You can instantiate class A using A a = new A() because even if you haven't specified any constructor, a default no-arg constructor is added to the class.

But if your class looks like this,

class A {
    public A(int b) {
    }
}

In this case, you have a single argument constructor. You can now instantiate your class only using this constructor as the compiler doesn't add a default no-arg constructor to it as it already has a constructor(with one argument). Therefore, A a = new A(1) would work whereas A a = new A() would not.

If you want to be able to create a instance like this, A a = new A() , then you need to explicitly add a no-arg constructor to your class, like this

class A {
    public A(int b) { // single argument constructor
    }
    public A() { // no argument constructor
    }
}

Answer 2

If you are using below code instead of example 2 then it will produce compilation error. IIOException is work like this. so you get the compilation error in example 1.

public class ConstructorChain
    {
        public static void main(String[] args)
        {
            ClassB b = new ClassB();
        }
    }
class ClassA
{
    public ClassA()
    {
        System.out.println("Class A");
    } 
}

/** put in ClassB.java */
 class ClassB
    extends ClassA
{
     ClassB(String str)
     {

     }
}

Answer 3

If a class has no constructors (as in ClassB), then according to Java Language Specification 8.8.9 "Default constructor" : " If a class contains no constructor declarations , then a default constructor with no formal parameters and no throws clause is implicitly declared ."

So, if the class has at least one constructor, then it should have it's own declaration of no-arg constructor to have it actually.

So if the ClassB has at least one constructor

/** put in ClassB.java */
public class ClassB
    extends ClassA
{
    public ClassB(String s)
    {
    }
}

then it will not have a no-arg constructor unless it is defined explicitly:

/** put in ClassB.java */
public class ClassB
    extends ClassA
{
    public ClassB()
    {
    }

    public ClassB(String s)
    {
    }
}