Make a class not to inherit and instantiate

[ashok bantu]

how to make a class not to inherit and not to instantiate simultaneously

[Seetharaman Venkatasamy]

what do you think about marking all the constructors in that class as private?

[Jesper de Jong]

What do you mean exactly? You want to make a class that cannot be subclassed and that cannot be instantiated?

To make it impossible to subclass a class, make the class final.
To make it impossible to instantiate a class (from outside the class itself), make all constructors of the class private.

[Seetharaman Venkatasamy]

Jesper de Jong wrote:
To make it impossible to instantiate a class (from outside the class itself), make all constructors of the class private.

even the class cant subclass in this case.

[Campbell Ritchie]

... you cannot extend from a class with only private constructors, but it is best to mark the class final so any users know it cannot be extended from. That class should only have static members. There is a section about it in the Java™ Language Specification.

[Rob Spoor]

Campbell Ritchie wrote:That class should only have static members.

Only if it's meant to be a utility class. If the class is a singleton class, or if you provide static factory methods for creating instances, then having non-static members is allowed.

[Campbell Ritchie]

If it is a singleton, or has factory methods, then it can be instantiated, albeit only locally to its own class. It said "not to ... instantiate" in the thread title. So I presumed it must be a utility class with static members only, like java.lang.Math, which only has a private constructor.

[Rob Spoor]

ah, I forgot about that requirement.

[ashok bantu]

Hi guys,

Not to inherit and instantiate any where whether it is inside or outside

[Darryl Burke]

Write a private no-args constructor that throws an exception.

[Campbell Ritchie]

Darryl Burke wrote:Write a private no-args constructor that throws an exception.

Like this?

[Campbell Ritchie]

Presumably any kind of private constructor would do? With or without arguments.

[Ramakrishna Gummadi]

ashok bantu wrote:how to make a class not to inherit and not to instantiate simultaneously

declare a class's constructor as private then you cant inherit it and cant create object to it.
so that class cannot be inherited and cannot be instantiated.

[Alejandro Deulofeu]

Make the class final and the constructors private, then you are good to go

[Campbell Ritchie]

AD: welcome to the Ranch

The final declaration is redundant, but still useful to alert users to the situation.

[Junilu Lacar]

Campbell Ritchie wrote:The final declaration is redundant, but still useful to alert users to the situation.

Because of anonymous classes, final is not redundant.

class Main {
  public static void main(String[] args) {
    Foo f1 = Foo.createFoo();
    System.out.println(f1.bar());

    Foo f2 = Foo.createFoo("Custom message");
    System.out.println(f2.bar());
  }
}

class Foo {
  private Foo() {}

  String bar() {
    return "Default message";  
  }

  static Foo createFoo() {
    return new Foo();  
  }
  
  static Foo createFoo(final String customMessage) {
    return new Foo() {
      @Override
      String bar() {
        return customMessage;
      }
    };
  }
}

This code will work and run as is. However, if you declare class Foo as final, it will not compile -- line 23 will cause a compiler error.

The final on line 22 is redundant though since without it, customMessage is effectively final.

[Campbell Ritchie]

Yes, that was an omission of mine. Thank you. That will only happen, I presume, if the anynmous class is a nested clas in the first class.

[Junilu Lacar]

Campbell Ritchie wrote:Yes, that was an omission of mine. Thank you. That will only happen, I presume, if the anynmous class is a nested clas in the first class

If you have a private constructor, then yes, the anonymous subclass must be created from inside the class itself.

The private / final combo covers all the bases for preventing any instantiation from anywhere. The private constructor will restrict instantiation from outside of the class. The final will restrict subclassing, which covers instantiating an anonymous subclass. If you want to prevent any instantiation at all, then you should probably do this:

public final class StaticsOnly {
  private StaticsOnly() {
     throw new UnsupportedOperationException("Instantiation of StaticsOnly class is not supported");
  }

  ...
}

This should make the design intent clear.

[Campbell Ritchie]

Thank you I think I have suggested throwing such an exception somewhere myself.

[Junilu Lacar]

Not at all. Little things like that are easy to overlook. It's a good reminder for me, too, because I'll often just have a private constructor and think my intent is clear.

[Campbell Ritchie]

In which case there should be at least a comment like

/**
 * Private constructor to prevent instantiation. No
 * instances of this class ever required.
 * Please don’t call this constructor, nor write
 * another constructor.
 */
private Foo()
{
   // empty
}