java根据返回值泛型 java方法返回值类型为泛型

泛型的好处  

泛型介绍

 4. 可以在类声明时通过一个标识表示类中某个类的属性，或者是某个方法返回值的类型，或者是参数类型。

public static void main(String[] args) {
    Person<String> a = new Person<String>("ss");
}

class Person<E>{
    E s;
    public Person(E s){
        this.s = s;
    }
    public E f(){
        return s;
    }
}

 特别强调：E具体的数据类型在定义Person对象的时候指定，即在编译期间就确定E是什么类型。

泛型的声明与实例化

类似C++的模板。 

这里对HashMap的遍历进行泛型改写：！！！！

public static void main(String[] args) {
        HashMap<String,Student> map = new HashMap<String,Student>(); //带泛型的声明
        map.put("ss",new Student("ss",20));
        map.put("mm",new Student("mm",19));
        map.put("hh",new Student("hh",30));
        //Set set = map.entrySet(); 不使用泛型的写法
        Set<Map.Entry<String, Student>> set = map.entrySet(); 
        //Set里面的结点类型就是它的泛型，为Map.Entry<String, Student>
        Iterator<Map.Entry<String, Student>> iterator = set.iterator();
        //迭代器指向的结点类型就是它的泛型，为Map.Entry<String, Student>
        while (iterator.hasNext()) {
            Map.Entry<String,Student> entry = iterator.next(); //原先是Object
            System.out.println(entry.getKey() + " " +entry.getValue());
        }
        for (Map.Entry<String, Student> entry : set) { //就不用Object了
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }

    这里有一个很好的写法：带泛型的数据类型(如HashMap)声明子类就用var，就不用泛型担心出错了。

查看源码可以发现，HashMap有<k,v>的泛型结构，HashSet和Iterator有<E>的泛型结构。

使用细节

2. 在给泛型具体类型后，可以传入该类型或者其子类类型。

public static void main(String[] args) {
    Dog<A> a = new Dog<>(new A()); //用 new Dog<A>(new A()).var 快捷键
    Dog<A> b = new Dog<>(new B()); //输入子类
}

class A{}
class B extends A{}
class Dog<E>{
    E e;

    public Dog(E e) {
        this.e = e;
    }
}

3. 泛型推荐使用形式

List<Integer> list1 = new ArrayList<Integer>(); // 不推荐
List<Integer> list1 = new ArrayList<>(); //推荐，因为编译器会自己进行类型推断

4. 泛型默认为Object 

ArrayList a = new ArrayList();
        ArrayList<Object> b = new ArrayList<>(); //两者等价

 P560 提出了：如果一个类A里有另外一个类B的对象，并且A需要用B的属性进行排序，最好在B中写一个compare方法(教程上说实现Comparable接口的compareTo方法，但是自己定义也行)。

public int compare(MyDate a,MyDate b){
        int h = a.year*365 + a.month*30 + a.day;
        int t = b.year*365 + b.month*30 + b.day;
        return h-t;
    }

自定义泛型

class Tiger<T,R,M>{ //Tiger后面泛型，一般把这种类就叫做自定义泛型类
    R r;
    M m;
    T t; // 属性使用泛型
    // T,R,M是泛型的标识符，一般是单个大写字母，可以有多个
    
    public Tiger(R r, M m, T t) { //构造器使用泛型
        this.r = r;
        this.m = m;
        this.t = t;
    }
    public void setR(R r){ //方法使用泛型
        this.r = r; 
    }
    public M getM(){ //返回类使用泛型
        return m;
    }
}

  重点解释第二点和第三点。 

T[] ts = new T[5]; //报错，因为数组在new时不能确定T的类型，因此无法在内存开辟空间

static R r2;
//因为静态是和类相关的，在类加载时，对象还没有创建(也即r2没有创建)
//所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化

自定义泛型接口

interface Usb<U,R>{ //自定义接口泛型
    E e; //错误，因为接口里的属性默认为 public static final，为静态属性
    R get(U u);
    void hi(R r);
    default R method(U u){ //jdk8中使用默认方法
        System.out.println("默认方法");
        return null;
    }
}

1. 在继承接口中指定泛型接口的类型

interface IA extends Usb<String,Double>{}
//当我们实现IA接口时，指定了U为String，R为Double
//因此实现Usb接口的方法时，使用String替换U，使用Double替换R
class AA implements IA{

    @Override
    public Double get(String s) {
        return null;
    }

    @Override
    public void hi(Double aDouble) {}
}

2. 实现接口时确定

class BB implements Usb<String,Double>{ 
//实现接口时，直接指定泛型接口的类型
    @Override
    public Double get(String s) {
        return null;
    }

    @Override
    public void hi(Double aDouble) {

    }
}

3. 不写默认为Object(但是会出现警告)

class CC implements Usb{
    //等价 class CC implements Usb<Object,Object>,最好还是写上！
    ...
}

自定义泛型方法

 注：2. 类型的确定只针对一次调用，可以输入一个Integer，下一条语句还可以输入一个Double. 

public<E> fly(E e){...}

fly(10);  //此时E是Integer
fly("ccc") //此时E是String

class Car{ //普通类
    public<T,R> void fly(T t,R r){} //泛型方法

}
class Fish<T,R>{ //泛型类
    public <U,M> void eat(U u,M m,T t,R r){} //泛型方法
    //可以使用类声明的泛型，也可以使用自己声明的泛型
    public void hi(T t){} //注意这是 使用了泛型的普通方法，并不是泛型方法
}

泛型的继承和通配符

List<Object> a = new LinkedList<String>();
        //错误，String不能赋给Object

  不限于直接父类：比如AA继承BB，Object就不是AA的直接父类(类似于爷爷类)。 

public void print(List<?> c){} //随意
    public void print1(List<? extends AA> c){} //AA及AA的子类们
    public void print2(List<? super AA> c){} //AA及AA的父类们

JUnit

 平时如果要测试方法的话，需要新建一个对象，然后再调用，非常麻烦。这里用JUnit可以直接测试方法。

class Car{   
    public void say(){
        System.out.println("测试");
    }
}

注：JUnit似乎需要下载，Community版本不能直接导入(回头再说！)。