JAVA的泛型

一、JAVA的泛型(泛型就是语法糖)

1、泛型类

①只能用在非静态成员变量和非静态成员方法上

②只能代替引用变量

class Student<T>{
    T name;
    public T getName() {
        return name;
    }
}

2、泛型接口

①只能用在抽象方法上，不能用在常量上

interface Human<T>{
    T compareTo(T t);
}

3、泛型方法（静态方法和非静态方法两者皆可以用）

class Method{
    public static <T> void show(T t) {
        
    }
}
class Method2{
    public static <T extends Cloneable> void show(T t) {
        
    }
}

4、泛型继承(四种情况 )

//泛型父类（抽象方法和接口和父类都一样）
abstract class Father<T1,T2>{
    T1 age;
    abstract void test(T2 arg); 
}
//①不指定类shi于：Father<Object,Object>
class Son1 extends Father{
    @Override
    void test(Object arg) {
        // TODO Auto-generated method stub        
    }        
}
class Son11<A,B> extends Father{
    @Override
    void test(Object arg) {
        // TODO Auto-generated method stub        
    }    
}

//②指定具体类型
class Son2 extends Father<Integer,String>{
    @Override
    void test(String arg) {
        // TODO Auto-generated method stub        
    }    
}
class Son22<A,B> extends Father<Integer,String>{
    @Override
    void test(String arg) {
        // TODO Auto-generated method stub        
    }    
}

//③部分保留，泛型子类
class Son3<T1> extends Father<T1,String>{
    @Override
    void test(String arg) {
        // TODO Auto-generated method stub        
    }    
}
class Son33<T1,A,B> extends Father<T1,String>{
    @Override
    void test(String arg) {
        // TODO Auto-generated method stub        
    }    
}

//④完全保留，泛型子类
class Son4<T1,T2> extends Father<T1,T2>{
    @Override
    void test(T2 arg) {
        // TODO Auto-generated method stub        
    }    
}
class Son44<T1,T2,A,B> extends Father<T1,T2>{
    @Override
    void test(T2 arg) {
        // TODO Auto-generated method stub        
    }    
}

5、泛型擦除（使用、实现、继承的时候不指定类型）

public class App 
{
    public static void main( String[] args )
    {
        //第一种情况（泛型的擦除）
        Teacher teacheer = new Teacher();
        Object obj = teacheer.getName();
        //第二种情况（泛型的擦除）
        Teacher<String> teacher2 = new Teacher();
        //第三种情况（泛型的擦除）
        Teacher teacher3 = new Teacher<String>();
        //第四种情况，这种情况是有错误的（编译时错误）
        //Teacher<Object> teacher4 = new Teacher();
        //Teacher<String> teacher5 = teacher4;
    }
}
//泛型的擦除,使用、实现、继承不指定类型
class Teacher<T>{
    T name;
    T getName() {
        return name;
    }
    void setName(T name) {
        this.name = name;
    }
}

 6、泛型的嵌套

public class Solution {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student<Double> s1 = new Student<Double>();
        s1.setScore((double) 100);
        Banji<Student<Double>> ssas = new Banji<Student<Double>>();
        ssas.setStu(s1);
        Double adasd = ssas.getStu().getScore();
        System.out.println(adasd);
    }

}

class Student<T> {
    T score;

    public T getScore() {
        return score;
    }

    public void setScore(T score) {
        this.score = score;
    }

}

class Banji<R> {
    R stu;

    public R getStu() {
        return stu;
    }

    public void setStu(R stu) {
        this.stu = stu;
    }

}

7、泛型需要注意的地方

①泛型没有多态
②泛型没有数组
③泛型不能使用静态属性
④泛型不能使用基本数据类型

⑤静态方法中不能访问类的泛型

⑥catch语句中不能使用泛型catch(T e){}这样子是错误的

public class DuoTai {

    public static void main(String[] args) {
        //泛型没有多态
        Object object = new String();
　　　　　Object[] strs = new String[10];//数组是可以的
        //List<Object> object1 = new ArrayList<String>();错误
        //泛型没有数组
        //List<Object>[] object2 = new ArrayList<Object>[10];错误
        //jdk1.7关于泛型的简化
        List<Object> object3 = new ArrayList<>();
        //相较于以前的List<Object> object3 = new ArrayList<Object>();
    }

}
class Fruit {

}

class Apple extends Fruit {

}

class Pear extends Fruit {

}

class FushiApple extends Apple {

}

二、JAVA的泛型通配符：?（super和extends）

List<?>是所有List<Object>,List<String>,List<Integer>...的父类

List<?>这样的集合是可以读取的(读取出来的元素类型是Object)，写入是不允许的，只能写入null（这个要结合这种式子只能写在等号左边，它不知道等号右边传给它的实际的集合是什么类型的）

1、泛型通配符（?)

①?通配符就是表示类型不确定

②只能用在(声明类型、方法参数)上也就是等号左边；不能用在定义泛型类上也就是等号右边

③不能用在定义泛型类泛型接口泛型方法上（就是不能放在定义泛型的尖括号里面）

List<?> list = new ArrayList<String>();
list = new ArrayList<Integer>();
list = new ArrayList<Date>();

2、泛型上限(？ extends  xxx)（包含等于）

①一般用于限制某个操作
②不能使用在数据添加上面，一般用于数据读取

③List<?>等同于List<? extends Object>

public class App 
{
    public static void main( String[] args )
    {
        List<? extends Fruit> t1 = new ArrayList<Fruit>();
        test(t1);
        List<Fruit> t2 = new ArrayList<Fruit>();
        test(t2);
        List<Apple> t3 = new ArrayList<Apple>();
        test(t3);
        List<? extends Apple> t4 = new ArrayList<FushiApple>();
        test(t4);
        List<?> t5 = new ArrayList<Fruit>();
        //List<?>等同于List<? extends Object>
        //test(t5);错误
        
    }
    static void test(List<? extends Fruit> list) {
        //list.add(new Apple());错误
        list.add(null);
    }
    
}
class Fruit{
    
}
class Apple extends Fruit{
    
}
class Pear extends Fruit{
    
}
class FushiApple extends Apple{
    
}
class Test<T extends Fruit>{
    
}

3、泛型下限(？ super  xxx)（包含等于）

①不能用于添加父类信息

public class App {
    public static void main(String[] args) {
        List<Fruit> t1 = new ArrayList<Fruit>();
        show(t1);
        List<Apple> t2 = new ArrayList<Apple>();
        show(t2);
        List<Object> t3 = new ArrayList<Object>();
        show(t3);
        List<? super Apple> t4 = new ArrayList<Apple>();
        show(t4);
        List<? super Fruit> t5 = new ArrayList<Object>();
        show(t5);
        List<? super FushiApple> t6 = new ArrayList<Object>();
        //show(t6);错误
        List<?> list7 = new ArrayList<Object>();
        //show(t7);错误
    }

    static void show(List<? super Apple> list) {
        list.add(new Apple());
        list.add(new FushiApple());
        // 不能用于添加父类信息
        //list.add(new Fruit());
    }
}

class Fruit {

}

class Apple extends Fruit {

}

class Pear extends Fruit {

}

class FushiApple extends Apple {

}

4、图解

假设给定的泛型类型为G，(如List<E>中的List),两个具体的泛型参数X、Y，当中Y是X的子类：

• G<? extends Y> 是 G<? extends X>的子类型（如List<? extends Cat> 是 List<? extends Animal>的子类型）。
• G<X> 是 G<? extends X>的子类型（如List<Animal> 是 List<? extends Animal>的子类型）
• G<?> 与 G<? extends Object>等同，如List<?> 与List<? extends Objext>等同。

 Plate<？ extends Fruit>是Plate<Fruit>以及Plate<Apple>的基类。这种不能往里面存，只能取。

Plate<？ super Fruit>是Plate<Fruit>的基类，但不是Plate<Apple>的基类。这种只能往里面存，不能取。要取也只能取在Object对象里。

三、一个经典的实例：

package org.eclipse.winery.repository;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class Main2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        List<Obj> list = new ArrayList<Obj>();
        list.add(new Obj());
        List<?> list2 = list;
        list2.forEach((obj) -> System.out.println(((Obj) obj).name));
        Collection<?> list3 = list;
        list3.forEach((obj) -> System.out.println(((Obj) obj).name));
        Collection<Obj> list4 = list;
        list4.forEach((obj) -> System.out.println(((Obj) obj).name));

    }

    private static class Obj {
        public String name = "Soar up into the sky with one start!";
    }
}

从这里我们看出了Collection<Obj>是List<Obj>的父类

四、泛型的静态方法

静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。

五、JAVA的extends在泛型中的扩展

public static <T extends Comparable<T>> void sort(T[] arr) {
        
    }