Target t1 = new Target();

CenterCircle t2 = new Bullseye();

t1 = t2;

Just after the last statement executes, the static type of t1 is _______ and the dynamic type of t1 is ______.

class Super {

    public Super( ) {System.out.println("A");}

    public Super(int i) {System.out.println(i);}      /*line A*/

    public int roll ( ) {return 1 + 5*Math.rand( );}  

}

class Sub extends Super {

    public Sub( ) {             /*line B*/

             super(1);

             System.out.println("B");}  

    public Sub(int i) {         /*line C*/

             super(i);

             System.out.println(i);}

    public int roll (int r) {   /*line D*/

             return 1 + r*Math.rand( );}    

}

final double pi = 3.14159;

int newvalue = (int) pi;

What happens when the second statement executes?

A. have a throw statement

B. have a try block

C. have a throws clause

Using whatever hints you can infer from the following Java code, draw a diagram to show any inheritance relationships among the four classes mentioned.  If you can be sure that a class is concrete (as opposed to being an interface or abstract class), label it with "C".

P1 x = new P2();

P3 y = x;

P4 z = (P2) y.getIt();

Sun's Javadoc for the String class says "The String class represents character strings. All string literals in Java programs, such as "abc", are implemented as instances of this class. Strings are constant; their values cannot be changed after they are created" (emphasis added).

Consider these two consecutive lines of code in a program:

    String str = "abc";

  str = "uvwxyz";

First answer whether you think these two lines (in a reasonable context in a Java program -- no trick intentions!) ARE or ARE NOT legal.  ("It depends" is not an option.)  Then explain your answer.  Draw a diagram if it helps make your case.

class Upper {
    
    protected String author;
    
    public Upper () {
        this.author = "Charles Dodgson";
        /********** AWBOCS ***********
         * a whole bunch of complicated stuff.*/
    }
    
    public Upper (String auteur) {
        this.author = auteur;
        /********** AWBOCS ***********
         * a whole bunch of complicated stuff -- exactly the same 
         *  as in the other constructor, letter for letter.*/    
    }    
} //end upper question class
        
class Lower extends Upper { //question lower class
    
    public Lower () {
        this.author = "Lewis Carroll";
        /********** AWBOCS ***********
         * a whole bunch of complicated stuff -- exactly the same 
         *  as in the other constructors, letter for letter.*/
    }
    public Lower (String auteur) {
        this.author = auteur;
        /********** AWBOCS ***********
         * a whole bunch of complicated stuff -- exactly the same 
         *  as in the other constructors, letter for letter*/
    }
}

When comparing names, non-letter characters are ignored.  The comparison should be case-insensitive.  For example, "de la Renta" and "Dela Ren-Ta" should compare as equal.  The exception is names beginning with Mc; these names are compared as if they were spelled Mac.  Thus McZebra comes before Madsen.  Aside from these cases, the comparison rules are the normal ones for Strings.

There is exactly one method which you must implement to complete the class, but you may define and implement other private methods if desired.  In your solution, you can use any String method, and the static Project0 method CharGenerator.isUpperCaseEnglish(c),  but no other methods except ones you fully define as part of the solution.

public class FamilyName implements Comparable {

     private String origN;

     public FamilyName(String nameString) {

         this.origN = nameString;

         this.origN.trim();

    }

    public String getName() {return origN;}

    /** Implement the method required */