======================答案=========================
======================答案=========================
A, E. Instance and static
variables can be marked final
, making option A correct. Effectively final means a local variable is not marked final
but whose value does not change after it is set, making option B incorrect. Option C is incorrect, as final
refers only to the reference to an object, not its contents. Option D is incorrect, as var
and final
can be used together. Finally, option E is correct: once a primitive is marked final
, it cannot be modified.
======================答案=========================
======================答案=========================
B, C. The keyword void
is a return type. Only the access modifier or optional specifiers are allowed before the return type. Option C is correct, creating a method with private
access. Option B is also correct, creating a method with package access and the optional specifier final
. Since package access does not use a modifier, we get to jump right to final
. Option A is incorrect because package access omits the access modifier rather than specifying default
. Option D is incorrect because Java is case sensitive. It would have been correct if public
were the choice. Option E is incorrect because the method already has a void
return type. Option F is incorrect because labels are not allowed for methods.
======================答案=========================
======================答案=========================
A, D. Options A and D are correct because the optional specifiers are allowed in any order. Options B and C are incorrect because they each have two return types. Options E and F are incorrect because the return type is before the optional specifier and access modifier, respectively.
======================答案=========================
======================答案=========================
A, B, C, E. The value 6
can be implicitly promoted to any of the primitive types, making options A, C, and E correct. It can also be autoboxed to Integer
, making option B correct. It cannot be both promoted and autoboxed, making options D and F incorrect.
======================答案=========================
======================答案=========================
A, C, D. Options A and C are correct because a void
method is optionally allowed to have a return
statement as long as it doesn't try to return a value. Option B does not compile because null
requires a reference object as the return type. Since int
is primitive, it is not a reference object. Option D is correct because it returns an int
value. Option E does not compile because it tries to return a double
when the return type is int
. Since a double
cannot be assigned to an int
, it cannot be returned as one either. Option F does not compile because no value is actually returned.
======================答案=========================
======================答案=========================
A, B, F. Options A and B are correct because the single varargs parameter is the last parameter declared. Option F is correct because it doesn't use any varargs parameters. Option C is incorrect because the varargs parameter is not last. Option D is incorrect because two varargs parameters are not allowed in the same method. Option E is incorrect because the …
for a varargs must be after the type, not before it.
======================答案=========================
======================答案=========================
D, F. Option D passes the initial parameter plus two more to turn into a varargs array of size 2. Option F passes the initial parameter plus an array of size 2. Option A does not compile because it does not pass the initial parameter. Option E does not compile because it does not declare an array properly. It should be new boolean[] {true, true}
. Option B creates a varargs array of size 0, and option C creates a varargs array of size 1.
======================答案=========================
======================答案=========================
D. Option D is correct. A common practice is to set all fields to be private
and all methods to be public
. Option A is incorrect because protected
access allows everything that package access allows and additionally allows subclasses access. Option B is incorrect because the class is public
. This means that other classes can see the class. However, they cannot call any of the methods or read any of the fields. It is essentially a useless class. Option C is incorrect because package access applies to the whole package. Option E is incorrect because Java has no such wildcard access capability.
======================答案=========================
======================答案=========================
B, C, D, F. The two classes are in different packages, which means private
access and package access will not compile. This causes compiler errors on lines 5, 6, and 7, making options B, C, and D correct answers. Additionally, protected
access will not compile since School
does not inherit from Classroom
. This causes the compiler error on line 9, making option F a correct answer as well.
======================答案=========================
======================答案=========================
B. Rope
runs line 3, setting LENGTH
to 5, and then immediately after that runs the static
initializer, which sets it to 10. Line 5 in the Chimp
class calls the static
method normally and prints swing
and a space. Line 6 also calls the static
method. Java allows calling a static
method through an instance variable, although it is not recommended. Line 7 uses the static
import on line 2 to reference LENGTH
. For these reasons, option B is correct.
======================答案=========================
======================答案=========================
B, E. Line 10 does not compile because static
methods are not allowed to call instance methods. Even though we are calling play()
as if it were an instance method and an instance exists, Java knows play()
is really a static
method and treats it as such. Since this is the only line that does not compile, option B is correct. If line 10 is removed, the code prints swing-swing
, making option E correct. It does not throw a NullPointerException
on line 17 because play()
is a static
method. Java looks at the type of the reference for rope2
and translates the call to Rope.play()
.
======================答案=========================
======================答案=========================
B. The test for effectively final is if the final
modifier can be added to the local variable and the code still compiles. The monkey
variable declared on line 11 is not effectively final because it is modified on line 13. The giraffe
and name
variables declared on lines 13 and 14, respectively, are effectively final and not modified after they are set. The name
variable declared on line 17 is not effectively final since it is modified on line 22. Finally, the food
variable on line 18 is not effectively final since it is modified on line 20. Since there are two effectively final variables, option B is correct.
======================答案=========================
======================答案=========================
D. There are two details to notice in this code. First, note that RopeSwing
has an instance initializer and not a static
initializer. Since RopeSwing
is never constructed, the instance initializer does not run. The other detail is that length
is static
. Changes from any object update this common static
variable. The code prints 8
, making option D correct.
======================答案=========================
======================答案=========================
E. If a variable is static final
, it must be set exactly once, and it must be in the declaration line or in a static
initialization block. Line 4 doesn't compile because bench
is not set in either of these locations. Line 15 doesn't compile because final
variables are not allowed to be set after that point. Line 11 doesn't compile because name
is set twice: once in the declaration and again in the static
block. Line 12 doesn't compile because rightRope
is set twice as well. Both are in static
initialization blocks. Since four lines do not compile, option E is correct.
======================答案=========================
======================答案=========================
B. The two valid ways to do this are import static java.util.Collections.*;
and import static java.util.Collections.sort;
. Option A is incorrect because you can do a static import only on static
members. Classes such as Collections
require a regular import
. Option C is nonsense as method parameters have no business in an import. Options D, E, and F try to trick you into reversing the syntax of import static
.
======================答案=========================
======================答案=========================
E. The argument on line 17 is a short
. It can be promoted to an int
, so print()
on line 5 is invoked. The argument on line 18 is a boolean
. It can be autoboxed to a Boolean
, so print()
on line 11 is invoked. The argument on line 19 is a double
. It can be autoboxed to a Double
, so print()
on line 11 is invoked. Therefore, the output is int-Object-Object-
, and the correct answer is option E.
======================答案=========================
======================答案=========================
B. Since Java is pass-by-value and the variable on line 8 never gets reassigned, it stays as 9. In the method square
, x
starts as 9. The y
value becomes 81, and then x
gets set to –1. Line 9 does set result
to 81. However, we are printing out value
, and that is still 9, making option B correct.
======================答案=========================
======================答案=========================
B, D, E. Since Java is pass-by-value, assigning a new object to a
does not change the caller. Calling append()
does affect the caller because both the method parameter and the caller have a reference to the same object. Finally, returning a value does pass the reference to the caller for assignment to s3
. For these reasons, options B, D, and E are correct.
======================答案=========================
======================答案=========================
B, C, E. The variable value1
is a final
instance variable. It can be set only once: in the variable declaration, an instance initializer, or a constructor. Option A does not compile because the final
variable was already set in the declaration. The variable value2
is a static
variable. Both instance and static
initializers are able to access static
variables, making options B and E correct. The variable value3
is an instance variable. Options D and F do not compile because a static
initializer does not have access to instance variables.
======================答案=========================
======================答案=========================
A, E. The 100
parameter is an int
and so calls the matching int
method, making option A correct. When this method is removed, Java looks for the next most specific constructor. Java prefers autoboxing to varargs, so it chooses the Integer
constructor. The 100L
parameter is a long
. Since it can't be converted into a smaller type, it is autoboxed into a Long
, and then the method for Object
is called, making option E correct.
======================答案=========================
======================答案=========================
A, E. The 100
parameter is an int
and so calls the matching int
method, making option A correct. When this method is removed, Java looks for the next most specific constructor. Java prefers autoboxing to varargs, so it chooses the Integer
constructor. The 100L
parameter is a long
. Since it can't be converted into a smaller type, it is autoboxed into a Long
, and then the method for Object
is called, making option E correct.