Rahul Rastogi: www.faqworldofrastogi.wetpaint.

com
Object Oriented Programming
SET►1
Question 1
Which of the following statements is not true?

a. An interface that is declared within the body of a class or interface is known as a nested
interface.
b. A constant can be a member of an interface.
c. A class declaration can be a member of an interface.
d. If an interface is named in the implements clause of a class, then the class must implement all
of the methods declared within the interface.
e. None of the above.
Answer:
This question asks which answer option is not true. Some true
statements are as follows. An interface can be declared within
an enclosing class or interface. The members of an interface
If an interface is named in the can be constants, abstract method declarations, class
implements clause of a class, declarations or interface declarations. If an interface is named
d then the class must implement in the implements clause of a class, then the class must
all of the methods declared implement all of the methods declared within the interface or
within the interface. the class must be declared abstract. The untrue answer option
did not mention that an abstract class is not required to
implement any of the methods declared in an interface that is
named in the implements clause of the class declaration.

Question 2
Which of the following are true statements?

a. Encapsulation is a form of data hiding.

b. A tightly encapsulated class is always immutable.
c. Encapsulation is always used to make programs run faster.
d. Encapsulation helps to protect data from corruption.
e. Encapsulation allows for changes to the internal design of a class while the public interface
remains unchanged.
Answer:
a Encapsulation is a form of data A tightly encapsulated class does not allow direct public access
d hiding. Encapsulation helps to to the internal data model. Instead, access is permitted only
e protect data from corruption. through accessor (i.e. get) and mutator (i.e. set) methods. The
Encapsulation allows for additional time required to work through the accessor and
changes to the internal design mutator methods typically slows execution speed.
of a class while the public Encapsulation is a form of data hiding. A tightly encapsulated
interface remains unchanged. class does not allow public access to any data member that can
be changed in any way; so encapsulation helps to protect
internal data from the possibility of corruption from external
influences. The mutator methods can impose contraints on the
argument values. If an argument falls outside of the acceptable
Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
range, then a mutator method could throw an
IllegalArgumentException. The internal design of a
tightly encapsulated class can change while the public interface
remains unchanged. An immutable class is always tightly
encapsulated, but not every tightly encapsulation class is
immutable.

Question 3
Which of the following statements are true?

a. A constructor can invoke another constructor of the same class using the alternate constructor
invocation, "this(argumentListopt);".
b. A constructor can invoke itself using the alternate constructor invocation,
"this(argumentListopt);".
c. The alternate constructor invocation, "this(argumentListopt);", can legally appear anywhere in
the constructor body.
d. A constructor can invoke the constructor of the direct superclass using the superclass
constructor invocation, "super(argumentListopt);".
e. The number of constructor invocations that may appear in any constructor body can equal but
not exceed the number of alternate constructors declared in the same class.
f. A constructor is not permitted to throw an exception.
Answer:
If an alternate constructor invocation appears
A constructor can invoke another constructor of
in the body of the constructor, then it must be
the same class using the alternate constructor
the first statement. The same is true for a
a invocation, "this(argumentListopt);". A constructor can
superclass constructor invocation. A compile-
d invoke the constructor of the direct superclass
time error is generated if a constructor
using the superclass constructor invocation,
attempts to invoke itself either directly or
"super(argumentListopt);".
indirectly.

Question 4
Which of the following statements are true?

a. An interface declaration can be a member of an interface.

b. A method declared within an interface must have a body represented by empty curly braces.
c. An interface can implement another interface.
d. An abstract class that implements an interface must implement all abstract methods declared
within the interface.
e. An abstract method declaration can be a member of an interface.
Answer:
a An interface declaration can An interface can be declared within an enclosing class or
e be a member of an interface. interface. The members of an interface can be constants, abstract
An abstract method method declarations, class declarations, or interface declarations.
declaration can be a member The body of a method declared within an interface is a
of an interface. semicolon. An interface can extend another interface, but can not
implement an interface. An abstract class that has an
interface, I1, in its implements clause is not required to
Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
implement any of the methods declared within I1.

Question 5
Which of the following are true statements?

a.A top-level class can not be called "tightly encapsulated" unless it is declared private.
b.Encapsulation enhances the maintainability of the code.
c.A tightly encapsulated class allows fast public access to member fields.
d.A tightly encapsulated class allows access to data only through accessor and mutator methods.
e.Encapsulation usually reduces the size of the code.
f.A tightly encapsulated class might have mutator methods that validate data before it is loaded
into the internal data model.
Answer:
The data members of a tightly encapsulated class
are declared private; so changes to the data model
Encapsulation enhances the maintainability
are less likely to impact external code. Access to
of the code. A tightly encapsulated class
internal data can be provided by public accessor
b allows access to data only through accessor
(i.e. get) and mutator (i.e. set) methods. The
d and mutator methods. A tightly
mutator methods can be used to validate the data
f encapsulated class might have mutator
before it is loaded into the internal data model.
methods that validate data before it is loaded
The use of accessor and mutator methods is
into the internal data model.
likely to increase the size of the code and slow
execution speed.

Question 6
Suppose that the superclass constructor invocation, "super(argumentListopt);", appears explicitly
in a subclass constructor. If a compile-time error is to be avoided then the arguments for the
superclass constructor invocation, "super(argumentListopt);", can not refer to which of the
following?

Answer:
b Instance variables declared in If the superclass constructor invocation, "super(argumentListopt);",
d this class or any superclass. appears explicitly or implicitly, then it must be the first
e Instance methods declared in statement in the body of the constructor. Until the superclass
f this class or any superclass. The constructor invocation runs to completion, no other
keyword this. The keyword statements are processed within the body of the constructor.
super. The same is true of the constructors of any superclass. (Note:
The primordial class, Object, does not have a superclass,
so the constructors do not include a superclass constructor
invocation statement.) Suppose class B is a subclass of A.
The process of creating and initializing an instance of B
includes the creation and initialization of an instance of the
superclass A and an instance of the superclass Object. The
superclass constructor invocation statement appearing in a
constructor of B is invoked before the completion of the
constructors of the superclasses A and Object. A superclass
constructor invocation statement appearing in B can not refer
Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
to the non-static members of the superclasses, because the
process of initializing those non-static superclass members is
not complete when the superclass constructor invocation
occurs in B. The same is true of the non-static members of B.

Question 7
Which of the following are modifiers that can be applied to an interface that is a member of a
directly enclosing interface?

a. abstract c. final e. protected

b. implements d. private f. public
Answer:
All interfaces are implicitly abstract. The explicit application of the abstract
modifier to an interface declaration is redundant and is strongly discouraged. The
declaration of an interface within the body of an enclosing class or interface is
called a member type declaration. Every member type declaration appearing within
a abstract the body of a directly enclosing interface is implicitly static and public. Use
f public of the access modifiers, private or protected, is contradictory and results in a
compile-time error. In contrast, the modifiers, private and protected, are
applicable to a member type declaration appearing within the body of a directly
enclosing class. The modifier, final, is never applicable to an interface. The
keyword, implements, is not a modifier.

Question 8
A class can not be called "tightly encapsulated" unless which of the following is true?

a. The class is declared final.

b. All local variables are declared private.
c. All method parameters are declared final.
d. No method returns a reference to any object that is referenced by an internal data member.
e. None of the above

Answer:
If a class A has a method that returns a reference to an internal, mutable object; then
None of external code can use the reference to modify the internal state of class A. Therefore,
e the class A can not be considered tightly encapsulated. However, the methods of a tightly
above encapsulated class may return a reference to an immutable object or a reference to a
copy or clone of an internal object.

Question 9
Which of the following are modifiers that can be applied to an interface that is a member of a
directly enclosing class?
 Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
a. abstract c. final e. protected
b. extends d. private f. public
Answer:
All interfaces are implicitly abstract. The explicit application of the modifier,
abstract, to an interface is redundant and is strongly discouraged. The
declaration of an interface within the body of an enclosing class or interface is
abstract called a member type declaration. The private, protected and static
a
private
d modifiers are applicable to a member type declaration that appears in the body
protected
e f of a directly enclosing class. In contrast, the modifiers, private and
public
protected, are not applicable to a member type declaration appearing
within the body of a directly enclosing interface. The modifier, final, is
never applicable to an interface. The keyword, extends, is not a modifier.

Question 10
A class can not be called "tightly encapsulated" unless which of the following is true?

a. All of the methods are declared private.

b. All of the methods are synchronized.
c. All local variables are declared final.
d. The class is a direct subclass of Object.
e. Accessor methods are used to prevent fields from being set with invalid data.
f. None of the above
Answer:
One answer option reads as follows: "Accessor methods are used to prevent fields
from being set with invalid data." The answer would be correct if the word
None of
"Accessor" were replaced by the word "Mutator". Accessor methods are used to read
f the
data members; mutator methods are used to set data members. The mutator methods
above
can validate the parameter values before the values are used to change the state of the
internal data model.

Question 11
Which of the following is a modifier that can be applied to an interface that is a member of a
directly enclosing class or interface?

a. static d. volatile
b. synchronized e. implements
c. transient f. None of the above.

Answer:
A member interface is always implicitly static. The modifier, static, can not be
applied to an interface that is not a member interface. The modifier, synchronized, is
a static applicable to a concrete implementation of a method, but is not applicable to any
interface. The modifiers, volatile and transient, are only applicable to variables
that are members of a class. The keyword, implements, is not a modifier.

Question 12
Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
A class can not be called "tightly encapsulated" unless which of the following are true?

a. The data members can not be directly manipulated by external code.

b. The class is declared final.
c. It has no public mutator methods.
d. The superclass is tightly encapsulated.
Answer:
The data members can not be directly manipulated If a class A is not tightly encapsulated,
a
by external code. The superclass is tightly then no subclass of A is tightly
d
encapsulated. encapsulated.

Question 13
class A {String s1 = "A.s1"; String s2 = "A.s2";}
class B extends A {
String s1 = "B.s1";
public static void main(String args[]) {
B x = new B(); A y = (A)x;
System.out.println(x.s1+" "+x.s2+" "+y.s1+" "+y.s2);
}}

What is the result of attempting to compile and run the program?

a. Prints: B.s1 A.s2 B.s1 A.s2

b. Prints: B.s1 A.s2 A.s1 A.s2
c. Prints: A.s1 A.s2 B.s1 A.s2
d. Prints: A.s1 A.s2 A.s1 A.s2
e. Run-time error
f. Compile-time error
g. None of the above
Answer:
The variables of a subclass can hide the variables of a superclass or interface. The
variable that is accessed is determined at compile-time based on the type of the
Prints: B.s1 reference--not the run-time type of the object. The two references x and y refer to
b A.s2 A.s1
the same instance of type B. The name x.s1 uses a reference of type B; so it refers
A.s2
to the variable s1 declared in class B. The name y.s1 uses a reference of type A;
so it refers to the variable s1 declared in class A.

Question 14
class A {void m1(A a) {System.out.print("A");}}
class B extends A {void m1(B b) {System.out.print("B");}}
class C extends B {void m1(C c) {System.out.print("C");}}
class D extends C {
void m1(D d) {System.out.print("D");}
public static void main(String[] args) {
A a1 = new A(); B b1 = new B(); C c1 = new C(); D d1 = new D();
d1.m1(a1); d1.m1(b1); d1.m1(c1);
}}
Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
What is the result of attempting to compile and run the program?

a. Prints: AAA e. Compile-time error

b. Prints: ABC f. Run-time error
c. Prints: DDD g. None of the above
d. Prints: ABCD
Answer:
The method invocation expression d1.m1(a1) uses reference d1 of type D to invoke
method m1. Since the reference d1 is of type D, the class D is searched for an
Prints:
b applicable implementation of m1. The methods inherited from the superclasses, C, B
ABC
and A, are included in the search. The argument, a1, is a variable declared with the
type A; so method A.m1(A a) is invoked.

Question 15
class C {
void printS1() {System.out.print("C.printS1 ");}
static void printS2() {System.out.print("C.printS2 ");}
}
class D extends C {
void printS1(){System.out.print("D.printS1 ");}
void printS2() {System.out.print("D.printS2 ");}
public static void main (String args[]) {
C c = new D(); c.printS1(); c.printS2();
}}

What is the result of attempting to compile and run the program?

a. Prints: C.printS1 C.printS2 e. Run-time error

b. Prints: C.printS1 D.printS2 f. Compile-time error
c. Prints: D.printS1 C.printS2 g. None of the above
d. Prints: D.printS1 D.printS2
Answer:
Suppose a superclass method is not private and is accessible to code in a subclass.
If the superclass method is declared static, then any subclass method sharing
the same signature must also be declared static. Similarly, if the superclass
Compile-
f method is declared non-static, then any subclass method sharing the same signature
time error
must also be declared non-static. The attempted declaration of the non-static
method D.printS2 generates a compile-time error; because the superclass
method, C.printS2, is static.

Question 16
class A {} class B extends A {} class C extends B {}
class D {
void m1(A a) {System.out.print("A");}
void m1(B b) {System.out.print("B");}
void m1(C c) {System.out.print("C");}
public static void main(String[] args) {
A c1 = new C(); B c2 = new C(); C c3 = new C(); D d1 = new D();
d1.m1(c1); d1.m1(c2); d1.m1(c3);
}}
Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
What is the result of attempting to compile and run the program?

a. Prints: AAA d. Compile-time error

b. Prints: ABC e. Run-time error
c. Prints: CCC f. None of the above
Answer:
Three methods overload the method name m1. Each has a single parameter of type A or
B or C. For any method invocation expression of the form
m1(referenceArgument), the method is selected based on the declared type of
the variable referenceArgument--not the run-time type of the referenced object.
The method invocation expression d1.m1(c1) uses reference d1 of type D to invoke
Prints: method m1 on an instance of type D. The argument, c1, is a reference of type A and
b
ABC the run-time type of the referenced object is C. The argument type is determined by the
declared type of the reference variable c1--not the run-time type of the object
referenced by c1. The declared type of c1 is type A; so the method m1(A a) is
selected. The declared type of c2 is type B; so the method invocation expression
d1.m1(c2) invokes method m1(B b). The declared type of c3 is type C; so the
method invocation expression d1.m1(c3) invokes method m1(C c).

Question 17

class E {
void printS1(){System.out.print("E.printS1 ");}
static void printS2() {System.out.print("E.printS2");}
}
class F extends E {
void printS1(){System.out.print("F.printS1 ");}
static void printS2() {System.out.print("F.printS2");}
public static void main (String args[]) {
E x = new F(); x.printS1(); x.printS2();
}}

What is the result of attempting to compile and run the program?

a. Prints: E.printS1 E.printS2 e. Run-time error

b. Prints: E.printS1 F.printS2 f. Compile-time error
c. Prints: F.printS1 E.printS2 g. None of the above
d. Prints: F.printS1 F.printS2

Answer:
A static method is selected based on the compile-time type of the reference--not
the run-time type of the object. A non-static method is selected based on the run-
time type of the object--not the compile-time type of the reference. Both method
Prints:
invocation expressions, x.printS1() and x.printS2(), use a reference of
c F.printS1
the superclass type, E, but the object is of the subclass type, F. The first of the
E.printS2
two expressions invokes an instance method on an object of the subclass type; so
the overriding subclass method is selected. The second invokes a static method
using a reference of the superclass type; so the superclass method is selected.

Question 18
Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
class A {void m1(A a) {System.out.print("A");}}
class B extends A {void m1(B b) {System.out.print("B");}}
class C extends B {void m1(C c) {System.out.print("C");}}
class D {
public static void main(String[] args) {
A c1 = new C(); B c2 = new C(); C c3 = new C(); C c4 = new C();
c4.m1(c1); c4.m1(c2); c4.m1(c3);
}}

What is the result of attempting to compile and run the program?

a. Prints: AAA
b. Prints: ABC
c. Prints: CCC
d. Compile-time error
e. Run-time error
f. None of the above

Answer:
b Prints: Three methods overload the method name m1. Each has a single parameter of type A or
ABC
Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
B or C. For any method invocation expression of the form
m1(referenceArgument), the method is selected based on the declared type of
the variable referenceArgument--not the run-time type of the referenced object.
The method invocation expression c4.m1(c1) uses reference c4 of type C to invoke
method m1 on an instance of type C. The argument, c1, is a reference of type A and
the run-time type of the referenced object is C. The argument type is determined by the
declared type of the reference variable c1--not the run-time type of the object
referenced by c1. The declared type of c1 is type A; so the method A.m1(A a) is
selected. The declared type of c2 is type B; so the method invocation expression
c4.m1(c2) invokes method B.m1(B b). The declared type of c3 is type C; so the
method invocation expression c4.m1(c3) invokes method C.m1(C c).

Question 19
class P {
static void printS1(){System.out.print("P.printS1 ");}
void printS2() {System.out.print("P.printS2 ");}
void printS1S2(){printS1();printS2();}
}
class Q extends P {
static void printS1(){System.out.print("Q.printS1 ");}
void printS2(){System.out.print("Q.printS2 ");}
public static void main(String[] args) {
new Q().printS1S2();
}}

What is the result of attempting to compile and run the program?

a. Prints: P.printS1 P.printS2

b. Prints: P.printS1 Q.printS2
c. Prints: Q.printS1 P.printS2
d. Prints: Q.printS1 Q.printS2
e. Run-time error
f. Compile-time error
g. None of the above
Answer:
Suppose a method m1 is invoked using the method invocation expression m1().
If m1 is a static member of the class where the invocation expression occurs,
then that is the implementation of the method that is invoked at run-time
regardless of the run-time type of the object. If m1 is non-static, then the selected
Prints: implementation is determined at run-time based on the run-time type of the
b P.printS1 object. The program invokes method printS1S2 on an instance of class Q.
Q.printS2 The body of method printS1S2 contains two method invocation expressions,
printS1() and printS2(). Since method printS1 is static, the
implementation declared in class P is invoked. Since printS2 is non-static and
the run-time type of the object is Q, the invoked method is the one declared in
class Q.

Question 20
class A {void m1(A a) {System.out.print("A");}}
class B extends A {void m1(B b) {System.out.print("B");}}
Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
class C extends B {void m1(C c) {System.out.print("C");}}
class D {
public static void main(String[] args) {
A c1 = new C(); C c2 = new C(); c1.m1(c2);
}}

What is the result of attempting to compile and run the program?

a. Prints: A
b. Prints: B
c. Prints: C
d. Compile-time error
e. Run-time error
f. None of the above
 Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
Answer:
The reference c1 is of the superclass type, A; so it can be used to invoke only the
method m1 declared in class A. The methods that overload the method name m1 in the
subclasses, B and C, can not be invoked using the reference c1. A method invocation
conversion promotes the argument referenced by c2 from type C to type A, and the
method declared in class A is executed. Class A declares only one method, m1. The
single parameter is of type A. Class B inherits the method declared in class A and
overloads the method name with a new method that has a single parameter of type B.
Both methods sharing the overloaded name, m1, can be invoked using a reference of
Prints: type B; however, a reference of type A can be used to invoke only the method declared
a
A in class A. Class C inherits the methods declared in classes A and B and overloads the
method name with a new method that has a single parameter of type C. All three
methods sharing the overloaded name, m1, can be invoked using a reference of type C;
however, a reference of type B can be used to invoke only the method declared in class
B and the method declared in the superclass A. The method invocation expression
c1.m1(c2) uses reference c1 of type A to invoke method m1. Since the reference c1
is of type A, the search for an applicable implementation of m1 is limited to class A.
The subclasses, B and C, will not be searched; so the overloading methods declared in
the subclasses can not be invoked using a reference of the superclass type.

Question 21
class R {
private void printS1(){System.out.print("R.printS1 ");}
protected void printS2() {System.out.print("R.printS2 ");}
protected void printS1S2(){printS1();printS2();}
}
class S extends R {
private void printS1(){System.out.print("S.printS1 ");}
protected void printS2(){System.out.print("S.printS2 ");}
public static void main(String[] args) {
new S().printS1S2();
}}

What is the result of attempting to compile and run the program?

a. Prints: R.printS1 R.printS2 e. Run-time error

b. Prints: R.printS1 S.printS2 f. Compile-time error
c. Prints: S.printS1 R.printS2 g. None of the above
d. Prints: S.printS1 S.printS2
Answer:
b Prints: A private method of a superclass is not inherited by a subclass. Even if a subclass
R.printS1 method has the same signature as a superclass method, the subclass method does
S.printS2 not override the superclass method. Suppose a non-static method m1 is invoked
using the method invocation expression m1(). If m1 is a private member of
the class T where the invocation expression occurs, then the implementation in
class T is selected at run-time regardless of the run-time type of the object. If the
non-static method m1 is not private, then the selected implementation is
determined at run-time based on the run-time type of the object. The program
invokes the non-static method printS1S2 on an instance of class S, so the run-
time type is S. The body of method R.printS1S2 contains two method
invocation expressions, printS1() and printS2(). Since class R contains a
Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
private implementation of the instance method printS1, it is the
implementation that is selected regardless of the run-time type of the object.
Since printS2 is not private and not static, the selected implementation
of printS2 depends on the run-time type of the object. The method
printS1S2 is invoked on an instance of class S; so the run-time type of the
object is S, and the implementation of printS2 declared in class S is selected.

Question 22
class A {void m1(A a) {System.out.print("A");}}
class B extends A {void m1(B b) {System.out.print("B");}}
class C extends B {void m1(C c) {System.out.print("C");}}
class D {
public static void main(String[] args) {
A a1 = new A(); A b1 = new B(); A c1 = new C(); C c4 = new C();
a1.m1(c4); b1.m1(c4); c1.m1(c4);
}}

What is the result of attempting to compile and run the program?

a. Prints: AAA
b. Prints: ABC
c. Prints: CCC
d. Compile-time error
e. Run-time error
f. None of the above
 Rahul Rastogi: www.faqworldofrastogi.wetpaint.com
Answer:
The declared type of the reference variables, a1, b1 and c1, is the superclass type, A;
so the three reference variables can be used to invoke only the method m1(A a) that
Prints: is declared in the superclass, A. The methods that overload the method name m1 in the
a
AAA subclasses, B and C, can not be invoked using a reference variable of the superclass
type, A. A method invocation conversion promotes the argument referenced by c4
from type C to type A, and the method declared in class A is executed.