Java笔记

1.Extends 关键字： 

/*The Extends Keyword
 * when a class is a hyponym of an interface, we used implements.
 * 1.Example: SLList<Blorp> implements List61B<Blorp>
 *
 * If you want one class to be a hyponym of another class,
 * you use extends.
 *
 * We'd like to build RotatingSLList that perform any SLList 
 * operation as well as:
 *
 */
/*SLList, but with additional rotateRight operation.*/
public class RotatingSLList<Item> extends SLList<Item> {

    /*To do: Implement RotatingSLList such that 
     * code compiles and outputs correct result.*/
    
    public void rotateRight(){        
        Item x = removeLast();
        addFirst(x);
    }

/*Because of extends, RotatingSLList inherits all members 
 * of SLList: 
 * (1) All instance and static variables;
 * (2) All methods;
 * (3) All nested classes.  
 * Contructors are not inherited.
 * But members may be private and thus inaccessible!  
 *
 * */

    public static void main(String[] args) {
        RotatingSLList<Integer>    rsl = new RotatingSLList<>();    
        /*Creates SList:[10, 11, 12, 13]*/
        rsl.addLast(10);
        rsl.addLast(11);
        rsl.addLast(12);
        rsl.addLast(13);
        
        /*Should be: [13, 10, 11, 12]*/
        rsl.rotateRight();
        rsl.print();

    }
}

2. 

/*
 *SList with additional operation printLastItems() 
 * which prints all items;
 */

public class VengefulSLList<Item> extends SLList<Item> {
    SLList<Item> deletedItems;
    /*Initialize
     *SLList<Item> deletedItems = new SLList<Item>();
     */

    public VengefulSLList() {
        deletedItems = new SLList<Item>();
    }


    @Override
    public Item removeLast(){
        /*Can access private member
         * calls Superclass's version of removeLast()
         * */
        Item x = super.removeLast();
        deletedItems.addLast(x);
        return x;
    }

    /*Prints deleted items*/
    public void printLostItems(){
        deletedItems.print();
    }

}

3. Constructor 的继承。

/*Constructors are not inheried. However, the rules 
 * of Java say that all constructors must start with a call 
 * to one of the super class's constructors.
 *Idea: If every VengefulSLList is an SLList, 
 every VengefulSLList must be set up like a SLList.
 *You can explictly call the constructor with the keyword super.
 **if you don't explictly call the constructor, 
 Java will automatically do it it for you. 
 * */

public VengefulSLList() {
    deletedItems = new SLList<Item>();
}
public VengefulSLList() {
    super();
    deletedItems = new SLList<Item>();
}


/*Calling other Constructors*/
/*If you want to use a super constructor other than 
 *the no-argument constructor, can give parameters to super.
 * */

public VengefullSLList(Item x) {
    super(x); //calls SLList(Item x)
    deletedItems = new SLList<Item>();
}

/*Here makes implict call to super(), not super(x)*/
public VengefulSLLis(Item x) {
    deletItems = new SLList<Item>();
}

4. Compile-time(static type) : 

/*Compile-Time Type Checking
 * Compiler allows methods calls based on compile-time type
 * also called static type.
 * of variable.
 * 1):sl's runtime type: VengefulSLList.
 * 2)But cannot call printLostItems. 
 */

public static void main(String[] args) {
    VengefulSLList<Integer> vsl = 
        new VengefulSLList<Integer>(9);
    SLList<Integer> Sl = vsl;
}

/*Compile-Time Types and Expressions*/
/*Expressions have compile-time types:
 * An expression using the new keyword has the 
 * specified compile-time type. 
 */
SLList<Integer> sl = new VengefulSLList<Integer>();

/*A: Compile-time type of RHS expression is VengefulSLList. 
 *B: A VengefulSLList is-an SLList, so assignment is allowed.
 */

VengefulSLList<Integer> vsl = new SLList<Integer>();
/*A. Compile-time type of RHS expression is SLList. 
 *B. An SLList is not necessarily a VengefulSLList, 
 so compilation error results.
 */

/*Casting 
 *Java has a special syntax for forcing the compile-time
 *type of any expression.
 *Put  desired type in parenthesis before the expression. 
 *Example: 

 Compile-time type Dog: maxDog(frank, frankJr);
 Compile-time type Poodle: (Poodle) maxDog(frank, frankJr);
 * */ 

5. Object class: 

/*The object Class*/
/*As it happens, every type in Java is 
 * a descendant of the Object class.
 *1) VengefulSLList extends SLList. 
 *2) SLList extends Object(implictly).
 */