9

Suppose there is a class with all of its constructors declared as private.

Eg.:

public class This {
    private This () { }

    public someMethod( ){
    // something here
    }
   // some more-- no other constructors
}

From what I know, making all constructors private is similar to declaring the class "This" as final-- so that it can't be extended.

However, the Eclipse messages i'm getting are giving me the impression that this is possible-- an all-constructors-private class can be extended. Take a look at this:

When I attempt to extend this class with something like

public class That extends This {
    ...
}

Eclipse giving me an error that: "Implicit super constructor This() is not visible for default constructor. Must define an explicit constructor."

When i define a constructor of its own:

public class That extends This {
    That () {..} 
    ...
}

this time i'm getting : "Implicit super constructor This() is not visible for default constructor. Must explicitly invoke another constructor."

Is there a way to get around this-- of extending a class of which all constructors are private?

if yes, how?

if no, what's the difference between stopping a class from being extended by i.) making its constructors private, and ii.) defining it as final?

Note: i saw Can a constructor in Java be private? among some other discussions.

Community
  • 1
  • 1
Roam
  • 4,831
  • 9
  • 43
  • 72

3 Answers3

26

You declare a class final vs. make its constructor private for different reasons:

  • You make class final to indicate that the class is not designed for inheritance.
  • You make all constructors private to give the class the control over its instantiation.

In other words, using final controls inheritance, while using private constructors control instantiation.

Note that declaring constructors private disables inheritance only from the outside. Inside the class, you may still inherit it with a named or an anonymous derived class.

When you make all constructors of the class private you need a static method that is public to make the class usable. One common kind of the static method is factory method: you can let the users of your class call private constructors indirectly through a public static method.

Sergey Kalinichenko
  • 714,442
  • 84
  • 1,110
  • 1,523
4

A class with private constructors cannot be instantiated except form inside that same class. This make it useless (possible, but will not compile) to extend it from antoher class.

This does not mean it cannot be subclassed at all, for example among inner classes you can extend and call the private constructor.

Simone Gianni
  • 11,426
  • 40
  • 49
  • Good point, but the last statement was a little hazy. You can subclass the class, but not call the private constructor in the subclass. It's private, not protected. But yes. If you have an inner class inside the original class with private constructor, you can call the private constructor of the original class. Not sure what it's for, but it's legal. – josephus Aug 30 '13 at 01:44
  • The hierarchy is, more or less, Package -> Class -> Inner classes. What is private to the class, is accessible for inner classes. You could declare an abstract inner class with private constructor and a few inner subclasses of it, and use them inside the main class. It's not the most useful thing in the world, but if you ever feel like doing it, you can. – Simone Gianni Aug 30 '13 at 13:23
1

From what I know the general use of a private constructor is to ensure that object construction is done via some other means, i.e. a static method. For example:

public class Something {

    private Something() { }

    public static Something createSomething() {
        Something ret = new Something();
        // configure ret in some specific way
        return ret;
    }

}

So a private constructor restricts how a class is instantiated (not how it is extended).

On the other hand, marking a class as final is used to explicitly say that a class cannot be extended. How it get's instantiated is a different matter entirely.

So while I'm not 100% if there is some way to extend a class that has all private constructors - the question is why do you want to do that? Having a private constructor and marking a class as final have two different purposes.

Brad Peabody
  • 10,917
  • 9
  • 44
  • 63
  • yes, this is more or less what Singleton is doing-- with the addition of a flag whether it's already instantiated itself. if there were a way of getting around it, i could make explicit calls to some of the non-static methods of java.lang.Runtime. but to good to be true. – Roam Aug 30 '13 at 01:08
  • ..and, Eclipse msgs are misleading. as i mentioned in my Q. – Roam Aug 30 '13 at 01:09
  • Tracking. On the Eclipse msgs, the compiler is probably not taking into account the fact that you are marking all constructors as private - it's simply saying that whichever one you are trying to invoke isn't going to work (thus "invoke another"). Also, overall, I still don't get what problem you are trying to solve. Several posts here have clearly answered the difference between a final class and private constructors, but I don't know that you've articulated the high level issue (design pattern) you're trying to address (might be the subject of a different post). – Brad Peabody Aug 30 '13 at 01:12