Java 中文官方教程 2022 版（四十六）(2)

public String loophole(Integer x) {
    List<String> ys = new LinkedList<String>();
    List xs = ys;
    xs.add(x); // *Compile-time unchecked warning*
    return ys.iterator().next();
}

public String loophole(Integer x) {
    List ys = new LinkedList;
    List xs = ys;
    xs.add(x); 
    return(String) ys.iterator().next(); // *run time error*
}

package com.Example.widgets;
public interface Part { 
    ...
}
public class Inventory {
    /**
     * Adds a new Assembly to the inventory database.
     * The assembly is given the name name, and 
     * consists of a set parts specified by parts. 
     * All elements of the collection parts
     * must support the Part interface.
     **/ 
    public static void addAssembly(String name, Collection<Part> parts) {...}
    public static Assembly getAssembly(String name) {...}
}
public interface Assembly {
    // *Returns a collection of Parts*
    Collection<Part> getParts();
}

package com.mycompany.inventory;
import com.Example.widgets.*;
public class Blade implements Part {
...
}
public class Guillotine implements Part {
}
public class Main {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add(new Guillotine()) ;
        c.add(new Blade());
        // *1: unchecked warning*
        Inventory.addAssembly("thingee", c);
        Collection k = Inventory.getAssembly("thingee").getParts();
    }
}

List <String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
System.out.println(l1.getClass() == l2.getClass());

Collection cs = new ArrayList<String>();
// *Illegal.*
if (cs instanceof Collection<String>) { ... }

// *Unchecked warning,*
Collection<String> cstr = (Collection<String>) cs;

// *Unchecked warning.* 
<T> T badCast(T t, Object o) {
    return (T) o;
}

// *Not really allowed.*
List<String>[] lsa = new List<String>[10];
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
// *Unsound, but passes run time store check*
oa[1] = li;
// *Run-time error: ClassCastException.*
String s = lsa[1].get(0);

// *OK, array of unbounded wildcard type.*
List<?>[] lsa = new List<?>[10];
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
// *Correct.*
oa[1] = li;
// *Run time error, but cast is explicit.*
String s = (String) lsa[1].get(0);

// *Error.*
List<String>[] lsa = new List<?>[10];

<T> T[] makeArray(T t) {
    return new T[100]; // *Error.*
}

interface Factory<T> { T make();} 
public <T> Collection<T> select(Factory<T> factory, String statement) { 
    Collection<T> result = new ArrayList<T>(); 
    /* *Run sql query using jdbc* */  
    for (/* *Iterate over jdbc results.* */) { 
        T item = factory.make();
        /* *Use reflection and set all of item's 
         * fields from sql results.* 
         */ 
        result.add(item); 
    } 
    return result; 
}

select(new Factory<EmpInfo>(){ 
    public EmpInfo make() {
        return new EmpInfo();
    }}, "selection string");

class EmpInfoFactory implements Factory<EmpInfo> {
    ...
    public EmpInfo make() { 
        return new EmpInfo();
    }
}

select(getMyEmpInfoFactory(), "selection string");

Collection emps = sqlUtility.select(EmpInfo.class, "select * from emps");
...
public static Collection select(Class c, String sqlStatement) { 
    Collection result = new ArrayList();
    /* *Run sql query using jdbc.* */
    for (/* *Iterate over jdbc results.* */ ) { 
        Object item = c.newInstance(); 
        /* *Use reflection and set all of item's
         * fields from sql results.* 
         */  
        result.add(item); 
    } 
    return result; 
}

Collection<EmpInfo> 
    emps = sqlUtility.select(EmpInfo.class, "select * from emps");
...
public static <T> Collection<T> select(Class<T> c, String sqlStatement) { 
    Collection<T> result = new ArrayList<T>();
    /* *Run sql query using jdbc.* */
    for (/* *Iterate over jdbc results.* */ ) { 
        T item = c.newInstance(); 
        /* *Use reflection and set all of item's
         * fields from sql results.* 
         */  
        result.add(item);
    } 
    return result; 
} 

interface Sink<T> {
    flush(T t);
}

public static <T> T writeAll(Collection<T> coll, Sink<T> snk) {
    T last;
    for (T t : coll) {
        last = t;
        snk.flush(last);
    }
    return last;
}
...
Sink<Object> s;
Collection<String> cs;
String str = writeAll(cs, s); // *Illegal call.*

public static <T> T writeAll(Collection<? extends T>, Sink<T>) {...}
...
// *Call is OK, but wrong return type.* 
String str = writeAll(cs, s);

public static <T> T writeAll(Collection<T> coll, Sink<? super T> snk) {
    ...
}
String str = writeAll(cs, s); // *Yes!* 

TreeSet(Comparator<E> c) 

interface Comparator<T> {
    int compare(T fst, T snd);
}

TreeSet(Comparator<? super E> c) 

public static <T extends Comparable<T>> T max(Collection<T> coll)

class Foo implements Comparable<Object> {
    ...
}
Collection<Foo> cf = ... ;
Collections.max(cf); // *Should work.*

public static <T extends Comparable<? super T>> 
        T max(Collection<T> coll)

Set<?> unknownSet = new HashSet<String>();
...
/* Add an element  t to a Set s. */ 
public static <T> void addToSet(Set<T> s, T t) {
    ...
}

addToSet(unknownSet, "abc"); // *Illegal.*

class Collections {
    ...
    <T> public static Set<T> unmodifiableSet(Set<T> set) {
        ...
    }
}
...
Set<?> s = Collections.unmodifiableSet(unknownSet); // *This works! Why?*