Clarification with the Singleton

Hello Java Guru,

After reading the topic Advanced OO and Design Patterns of the ebook oca-ocp-se-7-programmer 1 and 2. I went in for self questions but I had a problem with question 3 in page 567. Basically the question goes thus:
Given:
public class F {
private static final F f = new F();
public static F c() {
return f;
}
public void update(F a) { }
public void delete(F a) { }
}

Which design pattern or principle is implemented?

And the answer that was given as feedback is that this question implements the singleton design pattern.

As per my understanding for a class to implement a Singleton, 3 conditions are mandatory. Which are:

■ A private static variable to store the single instance called the singleton. This
variable is usually final to keep developers from accidentally changing it.
■ A public static method for callers to get a reference to the instance.
■ A private constructor so no callers can instantiate the object directly

I noticed that the class respect the first 2 conditions but not the last condition.

Why is the answer given as Singleton design pattern?

Besides, I also wanted to know if a Singleton design pattern implements the Object composition principles? Because in class we still have a field member as instance of the class.

Thanks for your response!

Hi Raymond,

Yes, since class F does not have any explicit constructor, the implicit constructor will be used (i.e. public constructor accepting no arguments).

Thus, anybody can create multiple objects of class F - hence it is not singleton.

Apart from that, singleton class may implement object composition principles.

Hi Anayonkar,

Oh thanks for the clarification, I appreciate so much but nevertheless does that means that the answer given for this question in the ebook is a mistake?

Are you sure that this was the only question part (and there is no private constructor)?

Also, what are other options?

I'm surprised to see such error in book (and I'm hoping that I myself am not making some blunder here )

Here is the entire question with all its propositions:
Given:
public class F {
private static final F f = new F();
public static F c() {
return f;
}
public void update(F a) { }
public void delete(F a) { }
}

Which design pattern or principle is implemented?
A. Coupling
B. DAO
C. Factory
D. IS-A
E. Object composition
F. Singleton

Here is the answer that was given with its explanations.

☑ F is correct. The singleton pattern is identifiable by the static variable for the single
instance and the accessor returning it.
☐✗ B is incorrect because there is no interface. The class just happens to have methods
update() and delete() , which are similar to those found in a DAO. A, C, D, and E are
incorrect because of the above. (OCP Objective 3.5)

Hi Raymond,

Yes, this is a mistake in the question content.
It has been already identified in the corresponding errata page for this book, (in the section on Chapter 10) - Errata K&B 7

Thanks,
Shantanu.

Hi Shantanu,

Thanks very much. I appreciate the concerned.