1
Which statement is true about declaring members in a concrete class? All methods and constructors must contain bodies.
All fields must be initial ized explicitly. Only instance fields and methods are supported. Only static fields and methods are supported.
Explanation: All methods and constructors must contain bodies in a concrete class. Only interfaces and abstr act classes support methods without bodies. Constructors cannot be declared without bodies, even in abstract classes.
All fields do not need to be ini tialized explicitly. By default, st atic and instance fields are autom atically initialized to their default values. Both instance and static fields and methods are supported by concrete classes.
2
Given: public class VarScope { int var; public static void main (String[] args) { int var = 10; VarScope scope = new VarScope(); scope.var = var + 2; scope.adjustVar(scope.var + 2); System.out.println("var = " + var); } private void adjustVar(int var) { var += 2; } }
What is the result? var = 10
var = 12 var = 14 var = 16
Explanation: The result will be the output var = 10. The output is based on the local variable named var in the main
method. The variable var in this scope is set to 10 and not modified until it is printed. The result will not be the output var = 12 because the local variable in the main method will be printed. This result would be the output if the instance variable var were printed because the class variable is set to the local variable incremented by two. The result will not be the output var = 14 because the local variable in the main method will be printed. This result would be the output if the local variable var in the adjustVar method were printed before it is incremented by two. The result will not be the output var = 16 because the local variable in the main method will be printed. This result would be the output if the local variable var in the adjustVar method were printed after it is incremented by two.
3
Given: int i2 = i1 + 4; System.out.println("i2 = " + i2);
Which line of code declares variable(s) so that the code fragment will compile? int i1; int i1, i2; int i1 = 0;
int i1 = 0, i2 = 0;
Explanation: The following line of code declares variable(s) so that the code fragment will compile: int i1 = 0;
This code declares the local variable i1 and initializes its value to 0. By default, local variables are not initialized automatically like instance and class variables. The code line int i1; will not declare variable(s) so that the code fragment will compile. This code line declares the i1 variable, but does not set i1 to a value. The code line int i2 = i1 + 4; will not compile if the i1 variable is not initialized. The code line int i1, i2; will not declare variable(s) so that the code fragment will compile. This code line declares the i1 and i2 variable, but does not set either variable to a value. The code line int i2 = i1 + 4; will not compile if the i1 variable is not initialized and the i2 variable is already declared. The code line int i1 = 0, i2 = 0; will not declare variable(s) so that the code fragment will compile. This code line initializes the i1 and i2 variables. The code line int i2 = i1 + 4; will not compile if the i2 variable is already declared.
4
Given: public class CommandLineClass { public static void main(String[] args) { System.out.print("Argument: " + args[2]); } }
and javac CommandLineClass.java java CommandLineClass arg1,arg2 arg3
What is the result? arg1 arg2 arg3 arg1,arg2 Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
Explanation: The result is the following output: Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException
The java command executes compiled Java files and sends arguments as a space-delimited list. The expression args[2] retrieves the third argument. An ArrayIndexOutOfBoundsException is thrown because a third argument is not provided in the command. The result would not be the output arg1 or arg2 because these are substrings of the first argument arg1,arg2. Command-line arguments are space-delimited only, not comma-delimited. The result would not be the output arg3 because the expression args[2] retrieves the third argument, not the second argument.
5
Given: package java7; public class MyBasicClass {}
Which statement is true about packages in MyBasicClass? MyBasicClass can access members using simple names in the java7 package without an
implicit import statement. MyBasicClass can access all members using simple names in the same application without an implicit import statement. MyBasicClass can only access members using simple names in the java.lang package with an explicit import statement. MyBasicClass can only access members using simple names in the same application with an explicit import statement.
Explanation: MyBasicClass can access members using simple names in the java7 package without requiring an implicit import statement. By default, the compiler will automatically import the current package, the java.lang package, and the package with no name. MyBasicClass cannot access all members using simple names in the same application without an implicit import statement. Only those members in the same package of the application can be accessed
using simple names. MyBasicClass can access members using simple names in the java.lang package without an explicit import statement. The compiler automatically imports the java.lang package. MyBasicClass can access members using simple names in the same application without an explicit import statement. If those members are in the same package, then the compiler will automatically
import them.
6
Given: public class MyBasicClass { //Insert code here }
Which three lines of code can be included in the class? package basicPackage; import java.text.*; enum ClassType {basic, advanced} void BasicMethod() {} static final int VAL=1000;
Explanation: The three lines of code can be included in the class as follows: public class MyBasicClass { enum ClassType {basic, advanced}
void BasicMethod() {} static final int VAL=1000; }
A class body can include static and non-stat ic fields, methods, constructors, and nested enumerations and classes. The code line package basicPackage; cannot be included in the class because a package statement must be the first line in the source file, not inside a class body. The code line import java.text.*; cannot be included in the class because import statements are not allowed in class bodies.
7
Given: public class CommandLineClass { public static void main(String[] args) { System.out.print("Argument: " + args[1]); } }
Which command will run the code without error? java CommandLineClass arg1 java CommandLineClass arg1 arg2
javac CommandLineClass arg1 javac CommandLineClass arg1 arg2
Explanation: The command java CommandLineClass arg1 arg2 will run the code without error. The java command executes compiled Java files and sends arguments as a space-delimited list. The expression args[1] retrieves the second argument, which is the value arg2 in this case.
The command java CommandLineClass arg1 will not run the code without error. Because the second argument is missing, an ArrayOutOfBoundsException will be thrown. The javac command will not run the code without error because this command compiles Java source code.
8
Which two statements are true about the contents of a class? A class can include only non-static m embers.
A class cannot include package or import statements. A class can include nested enumerations and classes.
A class cannot include constructors.
Explanation: A class can include nested enumerations and classes, but cannot include package or import statem ents. A class body can include static and non-stat ic fields, methods, constructors and n ested enumerations and classes.
A class can include both static and non- static members. A class can include constructors. If no constructor is included, then the compiler will provide a parameterless default constructor for the class.
9
Given: package games.card; public public public public }
class Poker { void call() {System.out.println("Call!");} void raise(double amt) {System.out.println("Raise by " + amt);} void fold() {System.out.println("Fold!");}
and package java7.app; //Insert code here public class GameApp { public static void main(String[] args) { Poker pokerGame = new Poker(); if (args.length > 0) { if (args[0].equalsIgnoreCase("raise")) { pokerGame.raise(Double.parseDouble(args[1])); } else pokerGame.call(); } else pokerGame.fold(); } }
Which two import statements, when inserted independently in the second source file, would enable the code to compile and run? import java7; import java7.*;
import java7.app.*; import java7.app.GameApp; import games; import games.*; import games.card.*; import games.card.Poker;
Explanation: The import statements import games.card.*; and import games.card.Poker;, when inserted independently in the second source file, would enable the code to compile and run. The import statement import games.card.*; imports all classes within the games.card package, which includes the fully qualified class games.card.Poker, while the import statement import games.card.Poker; specifies only the Poker class in the games.card package.
The import statements import java7;, import java7.*;, import java7.app.*; and import java7.app.GameApp; would not enable the code to compile and run. All of these import statements reference the existing package for the GameApp class, not the package that contains the Poker class. Also, the compiler will aut omatically import the current package. The import statements import games; and import games.*; will not enable the code to compile and run. These import statements import the classes in the games package, but not those classes in the games.card package. The Poker class is in the games.card package.
10
Given: public class VarScope { static int var; public static void main (String[] args) { int var = 9; printVar(); } public static void printVar() { int var = 10; System.out.print("var = " + var++); } }
What is the result? var = 0 var = 9
var = 10
var = 11
Explanation: The result will be the output var = 10. The output is based on the local variable named var in the printVar method. The variable var in this scope is set to 10, printed, and then incremented to 11.
The result will not be the output var = 0 because the local variable in the printVar method will be printed. This result would be the output if the class variable var were printed because class and instance variables are automatically initialized to their default values. The result will not be the output var = 9 because the local variable in the printVar method will be printed. This result would be the output if the local variable var in the main method were printed. The result will not be the output var = 11 because the local variable in the printVar method will be printed before it is incremented. This result would be the output if the prefix increment operator were specified, not the postfix increment operator.
11
Given: public static return } public return } }
class Circle { double getCircumference(double radius ) { PI * 2 * radius; static double getArea(double radius) { PI * radius * radius;
Which import statement will enable the code to compile and run? import java.lang.*; import java.lang.Math; import java.lang.Math.*; import static java.lang.Math.PI;
Explanation: The following import statement will enable the code to compile and run: import static java.lang.Math.PI;
A static import statement provides access by simple name to constants and static methods of a class. In this case, the simple name PI can be used to refer to the PI constant in the java.lang.Math class.
The statement import java.lang.*; will not enable the code to compile and run. By default, the compiler will automatically import the current package, java.lang package, and the package with no name. The statements import java.lang.Math; and import java.lang.Math.*; will not enable the code to compile and run. These import statements will only allow Math.PI as a reference to the PI constant. Because the java.lang package is automatically imported, these import statements are unneeded.
12
Given the following command: java CommandLineClass 1,2,3,4 5:6 7
When used in the main method, which expression will retrieve the argument 7? args[2]
args[3] args[6] args[7]
Explanation: The expression args[2] will retrieve the argument 7 when used in the main method. This expression accesses the third argument in the space-delimited list specified by the java command.
The expression args[3] will not retrieve the argument 7 because this expression access the fourth argument. An ArrayIndexOutOfBoundsException will be thrown because a fourth argument is not provided in the java command. The expressions args[6] and args[7] will not retrieve the argument 7 because arguments are only space-delimited and the other characters are not valid delimiters.
