Question 1
class B {
private String name;
public B(String s) {name = s;}
protected void finalize() {System.out.print(name);}
}
class E {
public static void m() {
B x1 = new B("X"), y1 = new B("Y");
}
public static void main(String[] args) {
m(); System.gc();
}}Which of the following could not be a result of attempting to compile and run the program?
a. Prints: XY
b. Prints: YX
c. Prints: XXYY
d. Nothing is printed.
e. None of the above
Question 2
void m1() {
Q q1 = null;
for (int i = 0; i < 10; i++) {
q1 = new Q(); // 1
m2(q1); // 2
}
System.out.print("All done"); // 3
}When the processing of line 3 begins, how many objects of type Q that were created at line 1 have become eligible for garbage collection?
a. 0
b. 1
c. 9
d. 10
e. Indeterminate.
f. Compile-time error
g. Run-time error
h. None of the above
Question 3
class Q {
private int id;
protected void finalize() {System.out.print(id);}
public Q(int i) {id = i;}
}
class R {
public static void main(String[] args) {
Q q1 = null;
for (int i = 0; i < 10; i++) {q1 = new Q(i);} // 1
System.gc(); // 2
}}When the processing of line 2 begins, how many objects of type Q that were created at line 1 have become eligible for garbage collection?
a. 0
b. 1
c. 9
d. 10
e. Indeterminate.
f. Compile-time error
g. Run-time error
h. None of the above
Question 4
class I {
private I other;
public void other(I i) {other = i;}
}
class J {
private void m1() {
I i1 = new I(), i2 = new I();
I i3 = new I(), i4 = new I();
i1.other(i3); i2.other(i1);
i3.other(i2); i4.other(i4);
}
public static void main (String[] args) {
new J().m1();
}}Which object is not eligible for garbage collection after method m1 returns?
a. i1
b. i2
c. i3
d. i4
e. Compile-time error
f. Run-time error
g. None of the above
Question 5
class I {
private String name;
public I(String s) {name = s;}
private I other;
public void other(I i) {other = i;}
}
class J {
private I i1 = new I("A"), i2 = new I("B"), i3 = new I("C");
private void m1() {
i1.other(i2); i2.other(i1); i3.other(i3);
i1 = i3; i2 = i3;
m2();
}
private void m2() {/* Do amazing things. */}
public static void main (String[] args) {
new J().m1();
}}Which of the three objects, A, B or C, is not eligible for garbage collection when method m2 begins to execute?
a. A
b. B
c. C
d. None of the above
Question 6
class I {
private String name;
protected void finalize() {System.out.print(name);}
public I(String s) {name = s;}
}
class J {
private static void m1(I[] a1) {
a1[0] = a1[1] = a1[2] = null;
}
public static void main (String[] args) {
I[] a1 = new I[3]; // 1
a1[0] = new I("A"); // 2
a1[1] = new I("B"); // 3
a1[2] = new I("C"); // 4
m1(a1);
System.gc();
}}After method m1 returns, the object created on which line is not eligible for garbage collection?
a. 1
b. 2
c. 3
d. 4
e. None of the above
f. Compile-time error
g. Run-time error
Question 7
class I {
private String name;
public String toString() {return name;}
public I(String s) {name = s;}
}
class J {
private static void m1(I[] a1) {a1 = null;}
public static void main (String[] args) {
I[] a1 = new I[3]; // 1
a1[0] = new I("A"); // 2
a1[1] = new I("B"); // 3
a1[2] = new I("C"); // 4
m1(a1);
for (int i = 0; i < a1.length; i++) {
System.out.print(a1[i]);
}}}After method m1 returns, the object created on which line is eligible for garbage collection?
a. 1
b. 2
c. 3
d. 4
e. Compile-time error
f. Run-time error
g. None of the above
Question 8
class A {
private String name;
private A otherA;
public A(String name) {this.name = name;}
public void other(A otherA) {this.otherA = otherA;}
public A other() {return otherA;}
public String toString() {return name;}
protected void finalize() {System.out.print(name);}
}
class B {
public static void m1() {
A a1 = new A("A1"), a2 = new A("A2"), a3 = new A("A3"), a0 = a3;
a1.other(a2); a2.other(a3); a3.other(a1);
for(int i = 0; i<4; i++){System.out.print(a0 = a0.other());}
}
public static void main(String[] args) {m1(); System.gc();}
}Which of the following could be a result of attempting to compile and run the program?
a. A1A2A3A1
b. A0A0A0A0A1A2A3
c. A1A2A3A1A2A3
d. A1A2A3A1A1A2A3
e. A1A2A3A1A3A2A1
f. A0A1A2A3A1A2A3
Question 9
class B {
private String name;
public B(String name) {this.name = name;}
public String toString() {return name;}
protected void finalize() {System.out.print(name);}
}
class H {
static B ba = new B("Ba");
static int i = 1;
static B m1(B b) {return b = new B("B" + i++);}
public static void main (String[] args) {
B x = m1(ba); m1(x);
System.out.println(", " + ba + ", " + x);
}}Which of the following could be a result of attempting to compile and run the program?
a. Ba, B1, B2
b. B1, Ba, B2
c. , Ba, B1
d. B2, Ba, B1
e. BaB1b2, null, null
f. B1B2, ba, null
Question 10
class B {
private String name;
public B(String name) {this.name = name;}
public String toString() {return name;}
protected void finalize() {System.out.print(name);}
}
class J {
static B bc;
static int i = 1;
static B m1(B b) {bc = b; return new B("B" + i++);}
public static void main (String[] args) {
B x = m1(new B("Ba")), y = m1(new B("Bb"));
System.out.println(", " + x + ", " + y + ", " + bc);
}}Which of the following could be a result of attempting to compile and run the program?
a. BaBb, B1, B2, B2
b. B1B2, null, null, Bb
c. , Ba, Bb, Bb
d. BaBbB1B2, null, null, null
e. Ba, B1, B2, Bb
f. Compile-time error
g. Run-time error
h. None of the above
Question 11
class I {
private String name;
public String name() {return name;}
public I(String s) {name = s;}
}
class J {
public static void m1(I i) {i = null;}
public static void main (String[] args) {
I i = new I("X"); // 1
m1(i); // 2
System.out.print(i.name()); // 3
}}Which of the following is a true statement?
a. The object created a line 1 is eligible for garbage collection
after line 2.
b. A NullPointerException is generated at line 3.
c. The program compiles, runs and prints X.
d. The program fails to compile.
e. None of the above
|
No.
|
Answer
|
Remark
|
|
|
1
|
c
|
Prints: XXYY
|
The program will not print XXYY.
Please note that the question asks which could NOT be a result of
attempting to compile and run the program. The finalize method of each
instance can only run once; so X or Y can never be printed more than once.
The instances referenced by x1 and y1 become eligible for garbage collection
when method m returns; so both could
be finalized at that time, but there is no guarantee that they will be. Even
though System.gc is invoked in the main
method, there is no guarantee that the garbage collector will run at that
time. If the garbage collector does run before the program terminates, then
the name of each object could be printed at most one time. The order in which
the names are printed depends on the order in which the objects are
finalized. If the garbage collector does not run, then nothing will be
printed.
|
|
2
|
e
|
Indeterminate.
|
Since we don't know what method m2 might be doing, we can not know if the objects are
eligible for garbage collection. Suppose that method m2 is declared inside of
a class that also contains 10 instance variables (instance variables are
non-static member fields) that are references to instances of class A. The
argument that appears in the method invocation expression m2(q1) is a
reference to an instance of class Q. Suppose that m2 saves each argument
value in one of the ten instance variables or in an element of an array of
type Q[]. When the loop in method m1 runs to completion, each instance of
class Q would still be referenced by a one of the ten instance variables.
Since the instance variables would continue to reference each instance of
class Q when line 3 is executed, none of the instances would be eligible for
garbage collection at that point. A second possibility is that method m2 does
not save the reference values. In that case, all of the instances that were
created inside the loop would be eligible for garbage collection when line 3
is executed.
|
|
3
|
c
|
9
|
With each pass through the loop, q1 references a new object, and the old object becomes
eligible for garbage collection. When the processing of line 2 begins, the
last object referenced by q1 is not
eligible for garbage collection.
|
|
4
|
g
|
None of the above
|
Please note that this question asks which object is NOT
eligible for garbage collection after method m1
returns. The objects referenced by i1,
i2 and i3 form a ring such that each object is referenced by
another. Even so, nothing outside of method J.m1 references any of those
objects. When method J.m1 returns, the ring becomes an island of isolated
objects that are not reachable by any part of the user program. A key point
to remember is that an object that is referenced by another object can be
eligible for garbage collection if the two objects form an island of isolated
objects.
|
|
5
|
c
|
C
|
Please note that this question asks which objects are NOT
eligible for garbage collection when method m2
begins to execute? All three references, i1,
i2 and i3, refer to object named C; so C is not eligible for garbage
collection when method m2 begins to
execute. The objects named A and B have references to each other, but no
other objects refer to A and B. The objects A and B form an island of
islolated objects and are eligible for garbage collection.
|
|
6
|
a
|
1
|
Please note that this question asks which objects are NOT
eligible for garbage collection after method m1
returns. After method m1 returns,
the array a1 created on line 1 is
not eligible for garbage collection. Method m1
sets all elements of the array to null;
so the objects created on lines 2, 3 and 4 are eligible for garbage
collection when method m1 returns.
|
|
7
|
g
|
None of the above
|
After method m1
returns, none of the objects are eligible for garbage collection. Method m1 sets the parameter variable a1 to null,
but that does not change the reference a1
in the J.main method. Since array a1
continues to reference all three objects, none of the three are eligible for
garbage collection.
|
|
8
|
a c
d e
|
A1A2A3A1 A1A2A3A1A2A3 A1A2A3A1A1A2A3
A1A2A3A1A3A2A1
|
The three instances of class A form an isolated ring where each instance references the
next instance and the third references the first instance. Four iterations of
the for loop are processed. Inside
the body of the for statement, the
invocation of the print method
contains the argument expression a0 =
a0.other(). On the first iteration, the reference variable a0 references the instance named A3. The value returned by the method named
other is a reference to the instance
named A1. The reference is assigned
to the reference variable a0 and is
also the value produced by the expression a0
= a0.other(). That reference value is passed as an argument to the print method, and the print method invokes the A.toString
method. With each iteration of the loop, the reference moves to the next
object in the loop and the name of the object is printed. After four
iterations, the loop ends and the method m1
returns. The invocation of the System.gc method serves as a suggestion that
the garbage collector should be allowed to run. The system could ignore the
suggestion, so there is no guarantee that the eligible arguments will be
garbage collected. If they are collected, there is no guarantee which will be
collected first. The only guarantee is that the finalize method will be
invoked on each particular instance before the resources that had been
allocated to that instance are reclaimed.
|
|
9
|
c d
|
, Ba, B1 B2, Ba, B1
|
Class H declares
two static member variables named ba
and i. The type of i is int,
and the value is initialized to 1.
The type of ba is B. The declaration of ba contains the class instance creation
expression new B("Ba").
The constructor of class B assigns
the argument value to the instance variable called name. Inside the main
method of class H, the method
invocation expression m1(ba) invokes
method m1. The argument is the
static member variable ba. The body
of method m1 contains a return statement with the expression b = new B("B" + i++). The
assignment expression contains the class instance creation expression new B("B" + i++) which creates a
new instance of the class B. For
this first invocation of method m1,
the argument appearing in the class instance creation expression is the String value B1. The reference to the new String
is assigned to the parameter variable b,
but that assignment does not change the value of the member variable ba. The value of the assignment expression
is the reference to the new instance of class B
with the name B1, and that reference
value is returned by the method m1.
The returned value is assigned to the local variable x. The next statement inside the main method is another invocation of method m1. The argument appearing in the method
invocation expression m1(x) is the
local reference variable x. The
method invocation does not change the value of x.
The value returned by this second invocation of m1 is a reference to a new instance of class B that has the name B2. The returned reference value is not
assigned to a variable, so the instance named B2
is eligible for garbage collection. There is no guarantee that the garbage
collector will run before the print
statement is invoked. If it does run, then the instance named B2 could be finalized causing the name to
be printed.
|
|
10
|
e
|
Ba, B1, B2, Bb
|
Class J declares
two static member variables named bc
and i. The type of i is int,
and the value is initialized to 1.
The type of bc is B. Inside the main method of class J,
the method invocation expression m1(new
B("Ba")) invokes method m1.
The argument is the class instance creation expression new B("Ba"). The constructor of
class B assigns the argument value
to the instance variable called name,
so a new instance of class B named Ba is created. The reference to the new
instance of class B is the argument
that is passed to method m1. The
body of method m1 contains two
statements. The first contains the assignment expression bc = b that assigns the value of the
method parameter b to the static
member variable bc, so bc now references the instance of class B named Ba.
The second statement in the body of m1
is a return statement with the class
instance creation expression new
B("B" + i++). For this first invocation of method m1, the argument appearing in the class
instance creation expression is the String
value B1. The reference to the new String is returned by method m1. The returned value is assigned to the
local variable x. Inside the main method, the declaration of the local
variable y contains another
invocation of method m1. The
argument appearing in the method invocation expression m1(new B("Bb")) is the class
instance creation expression new
B("Bb"), so the argument value for the invocation of method m1 is a reference to a new instance of
class B named Bb. Inside the body of method m1, the reference to the new instance of
class B named Bb is assigned to the static member
variable Bc. At that point, the
instance of class B named Ba becomes eligible for garbage
collection. Method m1 returns a
reference to a new instance of class B
named B2. There is no guarantee that
the garbage collector will run before the print
statement is invoked. If it does run, then the instance named Ba could be finalized causing the name to
be printed.
|
|
11
|
c
|
The program compiles, runs and prints X.
|
The parameter i
of method m1 is a copy of the local
variable i of method J.main. Setting
the parameter variable i of method m1 to null
does not change the local variable i
of method J.main.
|
|
|
No comments:
Post a Comment