Private Constructors

[Pervez Amin]

class A {
    public A() {}
    public A(int i) { this(); }
}
class B extends A {
 
}
class C extends B {
    private C() { super(); }//1
    public C(String msg) { this(); }
    public C(int i) {}
}

Can somebody pls explain what the effects of having a private constructor //1. What is the significance. I notice the code still compiles. But is it still possible to instantiate B. Will constructor chain still execute properly?
[This message has been edited by Pervez Amin (edited November 09, 2001).]

[Bill Krieger]

class A {
    public A() {}
    public A(int i) { this(); }
}
class B extends A {
 
}
class C extends B {
    private C() { super(); }//1
    public C(String msg) { this(); }
    public C(int i) {}
}

But is it still possible to instantiate B?
[/b]

---

</BLOCKQUOTE>
Yes, you can instantiate an object of class B. B has no explicit constructor, so the compiler inserts a default no argument constructor. That constructer then invokes the explicit no argument A constructor. No problem.

class D extends C {}

You could, however, have the following class:

class D extends C {
    public D() { super(1) }
}

[This message has been edited by Bill Krieger (edited November 09, 2001).]

[Valentin Crettaz]

normally you decide to make a constructor private when you want your class to be in control of how much instance can be created. This is used in the Singleton Design Pattern that enforces that only one instance of a class will be created. The constructor is made private and the class provides a static method (getInstance for instance) which will return an instance when asked. The first time it will call the constructor to create an instance which is stored as private member within the class. Subsequent invocation of the getInstance method will return the reference to the only instance of the class.
Another use of a private constructor is when you don't want any instance of your class to be created. See the Math class which has only static methods and a private constructor...
HIH
------------------
Valentin Crettaz
Sun Certified Programmer for Java 2 Platform

[Junilu Lacar]

Since class B does not have an explicit constructor, the compiler creates an implicit no-args constructor with default (package/friendly) access (since class B has default access). This does not prevent the normal constructor calls from happening when you instantiate C. It also means that you can still instantiate B from any class belonging to the same package.
If, however, you had declared a private constructor for class B, you would break class C because it will not be able to make an explicit or implicit call to super() from any of its constructors.

------------------
Junilu Lacar
Sun Certified Programmer for the Java� 2 Platform