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. 

The compiler will read the program from top to bottom, and by the time it gets to the function call for sayHello in main, it will have no clue what sayHello is. Therefore an exception will be raised. To circumvent this issue, define sayHello before main, OR provide a function prototype before main to make the compiler aware of the appropriate signature for the sayHello function.

The first thing you need to look at is the definition of the function's return value and parameters.  The only options that will pass are the ones that have: 

public static String myMethod(String s,int i)

(This is based on the definition: Return a string, take a string and an integer.)

Now, in our code, the key line is:

r += (char)(s.charAt(j) + i);

The wrong version has:

r += (s.charAt(j) + i);

This does not work because s.charAt(j) + i is interpreted as a numeric value in this case.  You will end up with a String that is comprised of numbers.  However, if you cast it back to a char type, you will get the character that is defined by that particular numeric value.  This is why the correct answer has:

r += (char)(s.charAt(j) + i);

Now, on the AP Computer Science A exam, you will need to use casts for double and int.  However, the writers of the test do say that it is helpful to understand casting in general.  Therefore, apply this problem's methodology to other programming problems where you would have to type cast double values into int values and vice-versa.

The constructor looks like a function declaration but always has the same name of the class.

Remember, a void function does not need a return type. The void keyword tells the program not to expect a return statement. A void function does not necessarily mean that the inputs are void as well. A void function can still have any number of inputs of any type.

Public methods are prefixed with the word public. The second word is the return type (i.e. int). The third is the name of the method and inside the parentheses goes the inputs to the method (i.e. boolean b and string s).

The prompt specifies that the return type of the method is a boolean. The return type of the method in the code snippet is void. Therefore, it will not return anything. The two input types however are correct. 

When we take a look at the constructor, first we notice that it has three parameters. Since there isn't any constructor overloading, this means that we can only create a person if we provide all of the arguments. So we can eliminate Person person1 = new Person() because that answer is not providing any arguments.

Now, we are supposed to be providing first two String arguments and then an integer. Therefore, we can eliminate the following two answers:

 Person person1 = new Person("Jones", "Indiana", "21");

 Person person1 = new Person(21, "Indiana", "Jones");

We can eliminate the first because the number 21 is being passed as a String instead of an int. It's being passed as a String because it has the double quotation. We can also eliminate the second because an integer is being passed as the first argument, instead of the third.  

Lastly whenever a new object is created, the order of the arguments matter! Notice that the constructor is assigning the first parameter "l" to lastName. Therefore, our first argument should be "Jones". Next, the constructor takes the second parameter "f" and assigns it to the variable firstName. This means that our second argument should be "Indiana". Lastly, the constructor takes the third parameter "a" and assigns it to the integer variable age. This means that the last argument we should pass is the number 21 (without any quotes). This means that the correct answer is:

 Person person1 = new Person("Jones", "Indiana", 21);