Java编程思想---泛型(3)

泛型带来的各类问题

任何基本类型都不能作为类型参数

Java泛型的限制之一是不能讲基本类型作为类型参数。

解决方案是JDK的自动装箱拆箱机制

如；

public class ListOfInt {

    public static void main(String[] args) {

        List<Integer> list = new ArrayList<>();

        for (int i = 0; i < 5; i++) {
            list.add(i);
        }
        for (int i : list){
            System.out.println(i);
        }

    }
}

自动包装不能解决所有问题：

public class FArray {

    public static <T> T[] fill(T[] a, Generator<T> generator){
        for (int i = 0; i < a.length; i++) {
            a[i] = generator.next();
        }
        return a;
    }


}

public class PrimitiveGenericTest {

    public static void main(String[] args) {


        String[] strings = FArray.fill(
                new String[7],new RandomGenerator.String(10)
        );

        for (String s:strings){
            System.out.println(s);
        }

        Integer[] integers = FArray.fill(
                new Integer[7],new RandomGenerator.Integer()
        );

        for(int i:integers){
            System.out.println(i);
        }

//        自动装箱在这里不会起作用了
//        int[] b = FArray.fill(new int[7],new RandomGenerator());


    }
}

可以看到，自动包装机制不能用于数组

参数化接口

一个类不能实现同一个泛型接口的两种变体

public interface Apple<T> {
}

public class ReadF implements Apple<ReadF>{
}
//public class ReadF2 extends ReadF implements Apple<ReadF2>{
//error
//}

ReadF2无法编译，因为擦差会将Apple< ReadF >与Apple< Read2F >简化为一样的类Apple，上面的代码就意味着重复两次实现相同的接口。

转型与警告

使用带有泛型类型参数的转型或instanceof不会有任何效果

public class FixedSizeStack<T> {

    private int index = 0;

    private Object[] storage;

    public FixedSizeStack(int size) {
        storage = new Object[size];
    }

    public void push(T item){
        storage[index++] = item;
    }

    public T pop(){
        return (T) storage[--index];
    }



}


public class GenericCast {

    public static final int size = 10;

    public static void main(String[] args) {

        FixedSizeStack<String> fixedSizeStack =
                new FixedSizeStack<>(size);

        for(String s : "A B J J I D U K L P".split(" ")){
            fixedSizeStack.push(s);
        }

        for (int i = 0; i < size; i++) {
            String s = fixedSizeStack.pop();
            System.out.println(s +"     ");
        }

    }
}

编译器会对

return (T) storage[--index];

发出警告，这是因为擦除的原因，编译器无法知道这个转型是否是安全的，并且pop实际上没有执行任何转型

重载

public class UseList<P,Q> {

//    void f(List<P> p){
//
//    }
//
//    void f(List<Q> q){
//
//    }


}

上面例子由于擦除的原因，重载方法将产生相同的类型签名

自限定的类型

令人费解的用法：

public class SelfBounded<T extends SelfBounded<T>> {
}

SelfBounded类接受泛型参数T，而T由一个边界类限定，这个边界就是拥有T作为其参数的SelfBounded

例子：

public class BasicHolder<T> {

    T element;

    public void setElement(T element) {
        this.element = element;
    }

    public T getElement() {
        return element;
    }

    void f(){
        System.out.println(element.getClass().getSimpleName());
    }

}

public class Subtype extends BasicHolder<Subtype>{


}



public class CRGWithBasicHolder {

    public static void main(String[] args) {

        Subtype subtype = new Subtype();

        Subtype subtype2 = new Subtype();

        subtype.setElement(subtype2);

        Subtype subtype3 = subtype.getElement();

        subtype.f();

    }
}

细节：

新类Subtype接受的参数和返回的值具有Subtype类型而不仅仅是基类BasicHolder类型，这就是CRG的本质：基类用导出类替代其参数

BasicHolder可以使用任何类型作为其泛型参数

public class Other {
}


public class BasicOther extends BasicHolder<Other>{


}

public class UnconStrained {

    public static void main(String[] args) {

        BasicOther b = new BasicOther();

        BasicOther b2 = new BasicOther();

        b.setElement(new Other());

        Other other = b.getElement();

        b.f();

    }
}

参数协变

自限定类型的价值在于它们可以产生协变参数类型---方法参数类型会随子类而变化

public class Apple extends Fruit{
    @Override
    public String toString() {
        return "Apple";
    }
}

public class Fruit {
}

public interface GetApple extends GetFruit{

    Apple get();
}


public interface GetFruit {

    Fruit get();
}


public class Test {

    static void test(GetApple getApple){
        Apple apple = getApple.get();
    }

    public static void main(String[] args) {

    }
}

GetApple中的get方法覆盖了GetFruit中的get(),并且返回了一个从GetFruit.get()的返回类型中导出的类型。

混型

public interface Fly {

    void fly();
}


public class Swing implements Fly{

    @Override
    public void fly() {
        System.out.println("I can Fly");
    }
}



public class Duck implements Fly{

    private Swing swing = new Swing();

    @Override
    public void fly() {
        swing.fly();
    }

    void swim(){
        System.out.println("I can swim");
    }
}

但是当使用更复杂的模型时，代码数量会急剧增加

装饰器

public interface Basket {

    void show();
}

public class Original implements Basket{

    @Override
    public void show() {
        System.out.println("I am Basket");
    }
}

public class AppleDecorator implements Basket{

    private Basket basket;

    public AppleDecorator(Basket basket) {
        this.basket = basket;
    }

    @Override
    public void show() {

        basket.show();
        System.out.println("APPLE");
    }
}

public class BananaDecorator implements Basket{

    private Basket basket;


    public BananaDecorator(Basket basket) {
        this.basket = basket;
    }

    @Override
    public void show() {
        basket.show();
        System.out.println("BANANA");
    }
}


public class Main {

    public static void main(String[] args) {

        Original original = new Original();

        Basket basket =
                new AppleDecorator(new BananaDecorator(original));

        basket.show();


    }
}

潜在类型机制

在C++和python中，可以不知道当前类的类型，就可以调用方法

Java如何进行补偿呢？

反射

public class TypeOne {

    private int data = 1;

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }
}

public class TypeTwo {

    private int data = 2;

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }
}



public class Main1 {

    public static void getData(Object type){
        Class<?> c = type.getClass();

        try {
            Method method = c.getMethod("getData");

            int data = (int) method.invoke(type,null);

            System.out.println(type.getClass().getSimpleName()+"  data:"+data);
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {

        TypeOne one = new TypeOne();

        TypeTwo typeTwo = new TypeTwo();

        getData(one);

        getData(typeTwo);

    }
}

将一个方法用于序列

public class Full {

    public static <T,S extends Iterable<T>> void fill(
            S s, Method method,Object...args
            ){
        Iterator<T> iterator = s.iterator();

        while (iterator.hasNext()){
            T t = iterator.next();
            try {
                method.invoke(t,args);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }


    }
}


public class Apple {
    private static int count = 1;
    private final int id = count++;

    public void getId(){
        System.out.println(id);
    }
}


public class Main2 {

    public static void main(String[] args) {

        ArrayList<Apple> list = new ArrayList<>();
        for(int i=0; i<10; ++i){
            list.add(new Apple());
        }
        try {
            fill(list, Apple.class.getMethod("getId"),null);
        } catch (NoSuchMethodException | SecurityException e) {
            e.printStackTrace();
        }

    }
}