Problem 0: Review old homeworks and labs, including vocabulary from previous chapters.

• syntax
  the structure (grammar) of a language
• semantics
  the way meaning is assigned
• run-time error
  an error that occurs when a program is executing when it gets to a statement that it cannot complete (a crash)
• logic error
  an error that causes a program to behave incorrectly, even though there are no syntax or semantic errors and the program does not crash
• declaration
  defines the type of a variable; example: double determinant;
• data type
  a set of values that are allowed to be stored in a variable
• identifier
  a name for something, such as a program, method, or variable
• assignment
  a statement that assigns a value to a variable; example: determinant = Math.sqrt(b * b - 4 * a * c);
• initialization
  the first (initial) assignment to a variable
• expression
  something that has a value; example: Math.sqrt(b * b - 4 * a * c)
• constant
  a "variable" that does not vary; declared with final and given an identifier with letters in upper case
• literal
  something that means literally what was typed in the program code; examples: 1, 2.0, false, 'a', "word"
• operator
  a symbol that stands for some operation; examples: +, -, ...
• keyword (reserved word)
  a word that has special meaning to the compiler; examples public, class, void, ...

Problem 1: Review the following vocabulary and, where appropriate, the corresponding Java syntax.

• package
  a collection of related classes; to use one must include import package-name.class-name; or import package-name.*;
• class
  a template for similar objects -- objects with the same set of attributes and behavior
• reference
  a variable used to refer to an object
• primitive type
  a non-object type; examples: int, double, char, boolean
• instance
  an particular member of (instance of) a class
• object
  an instance of a class
• instantiation
  creation of an object with new; often combined with an assignment as in birth = new GregorianCalendar(y, m, d);
• method
  a piece of code that describes how objects respond to questions and commands
• constructor
  a piece of code (like a method) that initializes the attributes of objects
• formal argument (parameter) list
  a specification of the types of the arguments a method needs
• actual argument (parameter) list
  the values that are passed to a method
• invocation
  the use of a method
• instance (non-static) method
  a method where the response or action depends on the attributes of a particular object; birth.add(Calendar.YEAR, 21); is an example of the invocation of such a method
• class (static) method
  a method where the response or action does not depend on the attributes of a particular object; Math.cos(Math.PI / 2) is an example of the invocation of such a method
• return type
  the data type of the response from a method
• mutator
  a method that changes the state of an object; these often have a void return type and so are invoked with something similar to birth.add(Calendar.YEAR, 21);
• accessor
  a method that returns an attribute of an object; since these return a value, that value is often saved somewhere as in int month = birth.get(Calendar.MONTH);
• factory method
  a method that creates an object; can be used as an alternative to instantiation as in NumberFormat fmt = NumberFormat.getCurrencyInstance()
• String
  the class that defines objects that contain sequences of characters
• string literal
  a sequence of characters in program code that stands for exactly those characters (as opposed to the value in the variable with the same name); enclosed in doule quotes: "literal"

Problem 2: Show what is displayed by each System.out.println statement in the following code fragment.

String s = new String("This quiz is fun!");

char letter = s.charAt(2);
System.out.println(letter);           // i

int index1 = s.indexOf('s');
int index2 = s.indexOf('s', 6);
System.out.println(index1);           // 3
System.out.println(index2);           // 11

String sub1 = s.substring(1, 3);
System.out.println(sub1);             // hi

String sub2 = s.substring(index2 + 2);
System.out.println(sub2);             // fun!

Problem 3: In the program below, circle one example of each of the following. Write the corresponding part letter next to each circle.

1. an instantiation
2. a reference
3. an method name
4. the invocation of a class (static) method
5. the invocation of an instance (non-static) method in the String class
6. the invocation of an instance (non-static) method in another class
7. an argument

import java.util.Scanner;

public class UsernameGenerator
{
    public static void main(String[] args)
    {
        final int LONGEST_USERNAME = 10;

        Scanner scan = new Scanner(System.in);                        // (a)

        System.out.println("Please enter a name (first last):");
        String fullName = scan.nextLine();                            // (f)

        char firstInitial = fullName.charAt(0);                       // (c)

        int lastIndex = fullName.indexOf(' ') + 1;
        String lastName = fullName.substring(lastIndex);              // (b)

        String username = (String.valueOf(firstInitial) + lastName);  // (d)

        username = username.toLowerCase();                            // (e)

        int finalLength = Math.min(LONGEST_USERNAME, username.length());
        username = username.substring(0, finalLength);                // (g)

        System.out.println(username);
    }
}

Problem 4: Suppose the documentation for the Team and Game classes describe constructors and methods as shown below. In the given program, determine which statements are legal and which are illegal. Consider only whether the statements adhere to Java's rules; it is possible for non-sensical or useless statements to be legal.

public class Problem4
{
  public static void main(String[] args)
  {
    Team t1;
    new Team("Virginia") = t1;                // illegal: wrong direction for assignment
    t1 = new Team("My applet is 400x400");    // legal, but odd: we now have a team called "My applet is 400x400"
   
    Team t2;
    t2 = t1;

    Game g;
    g = t1;                                   // illegal: the types must be compatible across an assignment; Team cannot be assigned to Game
    g = new Game(t1, t2, 0, 1);
    g = new Game("Loyola (MD)", "Loyola (IL)", 72, 64); // illegal: the first two arguments must be Teams, not Strings
    g = new Game(t1, new Team("Maryland"));

    t1.Team("Virginia");                      // illegal: constructors are invoked with new, not .
    t1.getWinner();                           // illegal: getWinner works with Games, not Teams   

    int i;
    i = g.getTotalPoints(t1);                 // illegal: getTotalPoints takes no arguments
    i = t2.addLoss();                         // illegal: addLoss does not return an int

    t1.getName();                             // legal, but probably useless: we're ignoring the returned value

    g.getWinner().addLoss();                  // legal, but probably odd
    g.setScore(100, t1);                      // illegal: arguments are in the wrong order
}