There are several critical points to look at in the code given as possible answers above.

First, you need to make sure that the main output is not a new line. Thus, the following is incorrect:

System.out.println(matrix\[i\]\[j\]);

This would create a new line for every single value!

Next, you need to make sure that a new line is output after every row of the matrix. This is the final output statement. Thus, it cannot be:

System.out.print(" ");

This would only output a character with no new line.

Finally, for everything except for the first element of each row, you will need to output sufficient padding before the given element element (so as to make the matrix to be evenly-spaced). We are not going to be too particular here about the problem of very big numbers—the values are given to us as is. Note that it is insufficient to use a mere space for this. You should use a tab character (defined as '\t'). A space will not guarantee enough spacing (no pun intended)!

The correct answer has the following logic:

if(j != 0) {

System.out.print("\t\t");

}

This means "when the column is not the first column" (i.e. j != 0), "then output tabs to space sufficiently."

This code is best explained by analyzing it directly. Comments will be provided in bold below:

// The loop runs from 1 to 10

for(int i = 1; i <= 10; i++) {

// First, you run through 0 to some number

// That number is computed by taking the current value of i, doubling it,

// subtracting that from 20, then dividing by 2.

// So, consider the following values for i:

// 0: 20 - 0 = 20; Divided by 2: 10

// 1: 20 - 2 = 18; Divided by 2: 9

// 2: 20 - 2 = 16; Divided by 2: 8

// etc...

// Thus, you will output single spaces that number of times (10, 9, 8...)

for(int j = 0; j < (20 - i * 2) / 2; j++) {

System.out.print(" ");

}

// Next, you will output an asterix i * 2 number of times. Thus, your

// smallest value is 2 and your largest 20.

for(int j = 0; j < i * 2; j++) {

System.out.print("*");

}

// This is just a repeat of the same loop from above

for(int j = 0; j < (20 - i * 2) / 2; j++) {

System.out.print(" ");

}

// This bumps us down to the next line

System.out.println();

}

Thus, you have output that basically has even padding on the left and right, with an increasing number of asterix characters (2, 4, 6, etc). This is an upward-facing arrow, having a point of width 2 and a base of width 20.

The method String.split() splits a String into an array of Strings separated according to the expression within the method argument. The expression String.split("") splits the String at every character. The "for" loop concatenates the elements of the String array together, separated by a comma.

The doWork method implements a relatively standard type of 2D array iteration, one that goes through each element. The outer loop goes through the first dimension of the array. Then, the inner loop provides index for the second dimension. From this, you get the total 2D index [i][j]. The line ret[i][j] = a[i][j] + b[i][j];actually performs the operation at the given index. Here, it performs an addition, combining the values at [i][j] found in the two arrays. This gives you the sum at each index of ret. The main method outputs each of these values, following the same standard algorithm for 2D array traversal.

Before anything is printed out into the console, the following is first evaluated:

myArray\[1\]\[1\] + 10

myArray\[1\]\[1\] is referring to the item that is in row=1 and column=1 of myArray. Taking note that arrays start with row 0 and column 0, we see that the item in row 1 column 1 is the number 4. Now we have the following: 4+10. This evaluates to 14. Therefore, the Java print statement will print out the number 14 on the console.

All this problem requires is careful attention to the loop control variables. Notice that the first loop adds 2 to i every looping. This means that it will run for 0,2,4,6, and 8. Thus, a total of five lines will be printed.

Now, the second loop dictates the number of * characters that will be output per line. This is going to be based upon the result of the modulus i % b. Remember, modulus is a remainder calculation. Thus, you will have:

0 % 5 = 0

2 % 5 = 2

4 % 5 = 4

6 % 5 = 1

8 % 5 = 3

Hence, you will have the following (note the first line is empty, given the result of 0 % 5):

* *

* * * *

*

* * *

This is an example of inheritance. The child class (Derived) is an inherited class of the parent class (Base). When the Derived object is created and the "foo" method is called, foo in the Derived class will be called. If there is the same method in the parent class and child class, the child's method will be called.

Let's take a look at the code.

int i = 7;

This line assigns 7 to the variable "i".

const int * ip = &i;

This line creates a constant int pointer and assigns the address of "i" to the pointer.

cout << *ip << endl;

This line prints the dereference of the pointer, which holds the value 7.

The words are printed on separate lines due to the System.out.println() call and then whatever is inside of the parentheses is printed on the next line. This call is different from System.out.print() which prints words on the same lines.

Therefore, the Sysytem.out.printIn gives("Sandra"):

hello

my

name

is

Sandra

The message that is printed out is "Hello I'm hungry"

Notice there is no punctuation in the message. The code does not add punctuation to the message, but prints the words out in the same order as the phrase in the prompt. Be mindful of what's actually happening in the code.

The modulus function "%" determines the remainder of a division. If I have 1 % 2, the remainder is 1. If I have 2 % 2, the remainder is 0. Therefore, if the remainder is equal to 0, then the number is divisible by the function. Thus, the method returns true if the number is evenly divisble by the divisor and false otherwise.

It doesn't compile. It is supposed to be x == 2 within the if statement not x = 2. The if statement checks for booleans (only true or false) and cannot convert an integer into a boolean to meet that check.

Remember that a constant variable cannot be changed once it has been assigned. Normally, you assign the variable immediately on the same line as the declaration. However, if you were to create the constant and wait to assign a value, that would be find syntactically as well. Thus, the correct answer does not have a problem, though it might appear so at first if you did not know this. Now, remember that the way to declare a constant is to use the keyword "final". (The keyword "const" works in some other languages like C++.) All of the incorrect answers (other than the one using "const") alter the constant after it has been defined.

The line

j = m + i;

has an error because it contains a reassignment to a constant (final) variable. You are permitted to assign a constant on a line that is not the line of declaration. However, once you do this, you cannot reassign a value. The variable j was assigned a value on the line:

j = n + m;

Thus, the line above (j = m + i;) represents a re-assignment, hence causing an error.

An interface cannot have any member data or implementations for its methods. It only defines a set of methods that are required by anything that implements that interface. Therefore, the only option that is valid is the interface defined as Shape2D.

In order to implement an interface, you must use the syntax "implements ". Therefore, for this question, you must choose an option that has implements Shape2D. Also, you must make sure that all of your methods are defined in your class just as they are defined in the interface declaration. You will notice that a variety of the incorrect answers do not do this but instead have wrong types or names in various places.

We are dealing here both with the implementation of an interface as well as inheritance. Notice that the Circle class has a getArea method that uses the superclass's getAreamethod. This equation is , but for the Circle , so the equation is the same as the standard . This loop will iterate through the objects, using the appropriate method in each case. Thus, you will get two values:

, which is relatively close to or .

, which is relatively close to or .

Those are close enough to help you estimate for the output.

(Notice that the line numbers need to be "1" and "2".)

The default keyword is used to catch any remaining cases not specified. For example, if you only want to check for certain hour of the day, say 2,3, and 4 o'clock, the default case would catch all the other hours. You could then create a statement for what to do when those values are caught.

First of all, the question does ask for an interface. This is a type of declaration in Java, so you should use that for your answer. This allows you to eliminate two of the incorrect options. Granting this, you then know that you need to look at the options that use the interface keyword. Recall that for interfaces, you provide no implementation whatsoever. Thus, the other two wrong answers are the ones that provide method bodies. This cannot be done for interfaces, which merely define what something should do but do not actually implement it.

The correct answer defines the interface as described. One of the answer choices defines a class with all of the attributes of the interface. Classes and interfaces are different. Interfaces are stubs of methods and classes are typically implementations (this is not always true, look up abstract classes). Another answer choice defines just the stub of the interface. This one would have been correct if the prompt had just asked for the stub, but there were implementation questions involved. Finally, the third answer choice had isPurring(), isClean(), isSleeping(), and isHungry() as void methods. These methods are prefixed with an "is" and "is" typically defines boolean language. Boolean was the correct return method on those.