Abstract classes can't be instantiated?

[Riza Aktunc]

I know that abstract classes can't be instantiated. So, how come "public abstract class Calendar" has a constructor and get instantiated when its getInstance() method is called?

[Varun Chopra]

Riza Aktunc wrote:I know that abstract classes can't be instantiated. So, how come "public abstract class Calendar" has a constructor and get instantiated when its getInstance() method is called?

getInstance() method returns an object of a concrete implementation of Calendar class (like Gregorian calendar).
This is the relevant code I see on opening Calendar class in Eclipse:

  public static Calendar getInstance()
   {
        Calendar cal = createCalendar(TimeZone.getDefaultRef(), Locale.getDefault());
	cal.sharedZone = true;
	return cal;
   }

    private static Calendar createCalendar(TimeZone zone,
					   Locale aLocale)
    {
	// If the specified locale is a Thai locale, returns a BuddhistCalendar
	// instance.
	if ("th".equals(aLocale.getLanguage())
	    && ("TH".equals(aLocale.getCountry()))) {
	    return new sun.util.BuddhistCalendar(zone, aLocale);
	}

	// else create the default calendar
       return new GregorianCalendar(zone, aLocale); 
    }

[Riza Aktunc]

It helps to resolve a part of my confusion. I have still a little left.

http://download.oracle.com/javase/1.4.2/docs/api/java/util/Calendar.html here the api documentation of Calendar class says that Calendar has 2 constructors.

What are these constructors for? Can an abstract class have constructors? If it can, what is the point?

[Atul Shrivastava]

A concrete class may invoke an abstract (super) class's constructor. You can have a look at the concrete class GregorianCalendar class's constructor:

GregorianCalendar(int year, int month, int dayOfMonth,
int hourOfDay, int minute, int second, int millis) {
super(); //This calls Calender's constructor.

But, you can not directly invoke it: Calendar c = new Calendar() ; //won't compile.

[Matthew Brown]

A constructor doesn't actually create an instance of the class, it's used to initialise it. And an abstract class can still have aspects of it that need initialising. So, as Atul says, the concrete subclass constructor can call the abstract class constructor to do this. In fact, it has to - if you don't make an explicit call then a call to super() is implicitly added.

And Atul - welcome to The Ranch!

[Atul Shrivastava]

Thanks Matthew

[Varun Chopra]

Every class has a default constructor, in other words yes, every abstract class always has at least 1 constructor.
Why - because abstract class may have instance variables and they can be initialized in the constructor (how will you initialize them otherwise if they are private ??). Calendar class also has instance variables if you look at its code.
Here's the constructor code from Calendar class:

   protected Calendar()
    {
        this(TimeZone.getDefaultRef(), Locale.getDefault());
	sharedZone = true;
    }

    protected Calendar(TimeZone zone, Locale aLocale)
    {
        fields = new int[FIELD_COUNT];
        isSet = new boolean[FIELD_COUNT];
        stamp = new int[FIELD_COUNT];

        this.zone = zone;
        setWeekCountData(aLocale);
    } 

Point - well, see one constructor from Gregorian Calendar below:

public GregorianCalendar(TimeZone zone, Locale aLocale) {
        super(zone, aLocale);
	gdate = (BaseCalendar.Date) gcal.newCalendarDate(zone);
        setTimeInMillis(System.currentTimeMillis());
    }

It first calls the base class's constructor with super(zone, aLocale); so that base class's instance variables are initialized before its own.

[Riza Aktunc]

Thanks everyone! And welcome Atul

[Atul Shrivastava]

thanks Riza...I'm not such a new member...its been more than 2.5 years...I didn't post anything to the forum though...