Test 1 Flashcards

Question

What if a parameter and attribute share the same name?

Answer 1

What if a parameter and attribute share the same name?Parameter takes priority public class Foo{ static int count; // attribute... public static void increment(int count){ count = count + count; // changes parameter, not attributeFoo.count = Foo.count + count; // changes attribute// this.count if Foo were not a Utility class} }

Answer 2

An invoked method runs in its own area of memory that contains storage for its parameters  Each parameter is initialized with the value of its corresponding argument The method body runs and the return value is computed  The return value is then copied back to the caller The argument kilometres and the parameter km have the same value but they are distinct variables  When DistanceUtility.kilometresToMiles() changes the value of km the value of kilometres does not change

Answer 3

``` for primitive and reference types  An argument of primitive type cannot be changed by a method (e.g., no swapping of ints)  An argument of reference type can have its state changed by a method ```

Answer 4

Suppose we want to provide a method to convert many values stored in an array from kilometres to miles  We can provide another method called kilometresToMiles() as long as the signature is different  Providing multiple methods with the same name but different signatures is called method overloading  The intent of overloading is to provide flexibility in the types of arguments that a client can use

Answer 5

```  Simple rule  A class can define multiple methods with the same name as long as the signatures are unique ```

Answer 6

Everything other than the signature is ignored in determining a legal overload Loosely speaking, the compiler will select the method that most closely matches the number and types of the arguments  “The rules that determine which overloading is selected are extremely complex. They take up thirty-three pages in the language specification [JLS, 15.12.1-3], and few programmers understand all of their subtleties.”

Answer 7

``` When specifying parameters for a method, one can use interfaces instead of classes as long as the interface declares the required functionality ◦ This allows for passing of objects from any implementing class ◦ Can allow for a type of collection (e.g., a Map) instead of an implementation (e.g., a TreeMap) public static int freq(List list) instead of public static int freq(ArrayList list) If the parameterized type (e.g., the type of element in a collection) is not known (or does not matter), one can specify a generic type ◦ Typically written as “E”, “T”, “K”, or “V” ◦ Can also be used to describe the return type public static int freq(List list) ◦ Declares as the type in the generic method “freq” public static T getLargest(List list) ◦ declares “freq” as a generic method, and its return type is also an object of type T Sometimes, restrictions are required on the type (e.g., elements must be comparable) public static > boolean smaller(List list) ◦ T must implement Comparable directly public static > boolean smaller(List list) ◦ Allows T if it (or one of its superclasses) implements Comparable directly ```

Answer 8

As the author of a class, you have control over how your method is implemented  What you cannot control is the value of the arguments that clients pass in  A well written method will 1. Specify any requirements the client must meet with the arguments it supplies → preconditions 2. Validate the state of any arguments without preconditions and deal gracefully with invalid arguments → validation

Answer 9

If a method specifies a precondition on one of its parameters, then it is the client's responsibility to make sure that the argument it supplies satisfies the precondition  If a precondition is not satisfied then the method can do anything (such as throw an exception, return an incorrect value, behave unpredictably, ...)  For our method possible preconditions are:  km must not be null  km.length > 0  Note that the second precondition is more restrictive than the first

Answer 10

Alternatively, the class implementer can relax preconditions on the arguments and validate the arguments for correctness  The implementer assumes the responsibility for dealing with invalid arguments  Must check, or validate, the arguments to confirm that they are valid  Invalid arguments must be accommodated in a way that allows the method to satisfy its postconditions  In our example, a possible return value for a null array is a zero-length array

Answer 11

``` A Boolean expression that is true (i.e., holds) at the beginning of every iteration of the loop  Does not necessarily appear in code  Typically derived for testing purposes and to prove correctness int pow = 1; int i = 0; while (i < exponent) { pow = pow * base; i++; } return pow ;  Invariants: ◦ i >= 0 ◦ i <= exponent ◦ pow == ba ```

Answer 12

 Imperative to test utility (and all) classes for correctness  Compare calculated output with expected output ◦ Identical result  test passed ◦ Different result  test failed  Testing requires multiple test cases to ensure correct operation under various condition with various inputs  Example: Test kilometresToMiles method

Test 1 Flashcards

(36 cards)