Why constuctor can't be marked as final?

[saloni jhanwar]

Thanks in Advance.

[Matthew Brown]

final just means it can't be overridden. A constructor can't be overridden, so what's the point of labelling it final? With most of the examples where a particular modifier isn't allowed in a particular place in Java, the explanation is simply that it wouldn't make much sense there.

[saloni jhanwar]

Matthew Brown wrote:final just means ..

Thanks Matthew

I got another link also Constructor final

[Seetharaman Venkatasamy]

but i make a constructor as final by not using final keyword instead I use private ;)

[saloni jhanwar]

Seetharaman Venkatasamy wrote:but i make a constructor as final by not using final keyword instead I use private ;)

If final is useless here then private also should be, what is use of private here as we can't inherit constructor.

[Seetharaman Venkatasamy]

saloni jhanwar wrote: what is use of private here as we can't inherit constructor.

you cant subclass a class[or you cant instantiate a class using that constructor]

[saloni jhanwar]

Seetharaman Venkatasamy wrote:

saloni jhanwar wrote: what is use of private here as we can't inherit constructor.

you cant subclass a class[or you cant instantiate a class using that constructor]

I want to ask that as we can't inherit constructor then why to use access modifiers with it ,like private etc because they will be useless for constructor.

[Seetharaman Venkatasamy]

Constructor is a *special* kind of method. and how do you create an instance[by using new operator] of a class with out seeing the constructor ?

[saloni jhanwar]

Seetharaman Venkatasamy wrote:Constructor is a *special* kind of method. and how do you create an instance[by using new operator] of a class with out seeing the constructor ?

Thanks but my question was something different, yes i know constructor is needed for class, but is there any sense to use any access modifiers with it ?

[Matthew Brown]

Making a constructor private will (if it's the only constructor) prevent you from instantiating the class from outside the class. Which means it can only be instantiated from inside - e.g. in a static method. See, for example, the Singleton pattern.

[Anayonkar Shivalkar]

saloni jhanwar wrote:but is there any sense to use any access modifiers with it ?

Well, the answer lies in Seetharaman Venkatasamy's post (previous to your last post). What if I want to 'stop' someone(external to my class) from creating objects? What if I want methods of 'my class' only should be able to create the objects?

I hope you get the point.

Edit : I was typing this when Matthew Brown replied, so its almost duplicate

[Helen Ma]

A common example I learn from the industry:

class A{
  //constructor
  private A(){
         // initialize something
   }
}

class B{
   A a ;

   public static A getA(){
         if (a == null){

             return new A();
          }
         else{
                return  a;
              }

  }

}

This is how people usually do to create a singleton assuming no two threads accessing getA() method concurrently.

[Matthew Brown]

That wouldn't work - you're trying to access A's private constructor from B. You'd have to move the static method to A (and fix the other problems with it )

[Helen Ma]

Sorry,
I type it wrong, the revised code should be:

class A{   

 static A a ;
  //constructor   
  private A(){   
         // initialize something   
   }   
     
  public static A getA(){   
         if (a == null){   
              return new A();   
          }   
         else{   
                return  a;   
              }   
  
  }
  
}  

class B{
          public static void main (String... args){
                 A a = A.getA();

         }
}

[Matthew Brown]

Now there's just the "other things wrong with it" . The most important being, that will actually create a new A every time you call getA().

[Helen Ma]

The code should be this:

Helen Ma wrote:

class A{   

 static A a ;
  //constructor   
  private A(){   
         // initialize something   
   }   
     
  public static A getA(){   
         if (a == null){  
              a = new A(); 
              return a;
          }   
         else{   
                return  a;   
              }   
  
  }
  
}  

class B{
          public static void main (String... args){
                 A a = A.getA();

         }
}

[Anayonkar Shivalkar]

Nops... it still have a problem

Consider below scenario:
1) There are two threads which are calling getA method.
2) Thread 1 reaches line 10. a is null, so it reaches at line 11. Line 11 has not yet executed.
3) Thread 2 reaches line 10. a is null, so it reaches at line 11. Line 11 has not yet executed.
4) Thread 1 creates an object, assigns to 'a' and returns the object.
5) Thread 2 creates another object, assigns to 'a' and returns the object.

So, there are two possibilities to avoid this:

Either

class Singleton {
	private static final Singleton instance = new Singleton();
	private Singleton() {
		
	}
	public static Singleton getInstance() {
		return instance;
	}
}

Or

class Singleton {
	private static Singleton instance;
	private Singleton() {
		
	}
	public static synchronized Singleton getInstance() {
		if(instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
}

Personally, I prefer the first one for below reasons:
1) Instance is initialized during class loading itself.
2) There's no 'if' condition overhead during getInstance method.
3) We don't have to explicitly make it thread-safe.

I hope this helps.

[Helen Ma]

Hi, thanks for your thread safe example.
By the way, this quoted code:

class Singleton {   
    private static Singleton instance;   
    private Singleton() {   
           
    }   
    public static synchronized getInstance() {   
        if(instance == null) {   
            instance = new Singleton();   
        }   
        return instance;   
    }   
}  

is equivalent to

public static  getInstance() {   
      synchronized (this)
        if(instance == null) {   
            instance = new Singleton();   
        }   
        return instance;   
    }   

So, if "this" Singleton instance is not created yet, will I get a null pointer exception?

[Anayonkar Shivalkar]

No. The equivalent code which you have posted will give compile time error (for the exact same reason - you cannot use 'this' inside a static context/method).

The code which I posted contained a static synchronized method which is equivalent to:

public static Singleton getInstance() {
	synchronized(Singleton.class) { //note that synchronization is on 'class'
		if(instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
}

Besides, my original code had a problem - getter method was void!
I've edited that post.

[Matthew Brown]

You want the easiest way to make a singleton in Java? Guaranteed thread safe as well?

public enum Singleton { 
    Instance
}

(Using singletons is often dubious, but I'm not going to get into that now)