Java泛型

泛型

泛型 实质就是定义安全的类型，以避免可能出现的类型转换过程中出现ClassCastException异常。

定义泛型

语法  类名<T>,注意这里面的T没有特殊要求只作为一种类型标识而已且该符号只能定义类类型

// 使用泛型定义的类在声明该类对象时可以根据不同的需求指定<T>真正的类型
public class Attri<T> {


    private T attr;


    public T getAttr() {
        return attr;
    }

    public void setAttr(T attr) {
        this.attr = attr;
    }

    public static void main(String[] args) {
        Attri<String> attri = new Attri<>();

        attri.setAttr("属性");

//        attri.setAttr(1); 定义不同类型时，编译错误

        System.out.println(attri.getAttr());
    }
}

泛型的用法

1. 类名
2. 类型<T1, T2>

public class Attri<T1, S1> {


    private T1 attr;

    private S1 attr2;

    public S1 getAttr2() {
        return attr2;
    }

    public void setAttr2(S1 attr2) {
        this.attr2 = attr2;
    }

    public T1 getAttr() {
        return attr;
    }

    public void setAttr(T1 attr) {
        this.attr = attr;
    }

    public static void main(String[] args) throws NoSuchFieldException {
        Attri<String, Integer> attri = new Attri<String, Integer>();

        attri.setAttr("属性");
        attri.setAttr2(2);

    }

3. 集合

我们经常会使用java中List、Set、Map等集合来处理或者临时存储数据，
点开Java API中源码即可清楚看到。

HashMap<K,V>

5. 限制泛型可用类型

// 定义接口书籍
public  interface  Book {

    public String getBookName();
}

// 定义小说类，并实现于书籍类
public class Novel implements Book {

    @Override
    public String getBookName() {
        return "小说";
    }
}
public class Attri<T extends Book> {

    public T book;

    public static void main(String[] args) {

        Novel novel = new Novel();

        Attri<Novel> attri = new Attri<>();

        attri.setBook(novel);
        Novel book1 = attri.getBook();

        System.out.println(book1.getBookName());

    }

    public T getBook() {
        return book;
    }

    public void setBook(T book) {
        this.book = book;
    }
}

7. 使用通配符

语法  类名<? extend 父类> 或者 向上限制类型  类名<? extend 子类> 

// 在上面示例上，增加 Biography传记的实现类，即可实现通配符向下约束类型
public class Attri<T extends Book> {

    public static void main(String[] args) {

        Attri<? extends Book> attri = null;
        
        attri = new Attri<Novel>();
        
        attri = new Attri<Biography>();


    }
}

// 使用super关键字 即可在泛型中约束向上的类型
public class Attri<T extends Book> {

    public static void main(String[] args) {

        Attri<? super Novel> attri = null;
        
        attri = new Attri<Book>();
        
//        attri = new Attri<Biography>();// 编译错误 Biography 不是Novel的父类


    }
}

9. 继承和实现泛型

public class Attri<T1, T2, T3> extends Attri2<T1> implements Novel<T2>{

    T1 n1;

    T2 n2;

    T3 n3;

    public Attri() {
    }

    public Attri(T1 n1, T2 n2, T3 n3) {
        this.n1 = n1;
        this.n2 = n2;
        this.n3 = n3;
    }

    @Override
    public T2 getBookName(T2 t2) {
        return t2;
    }


    public static void main(String[] args) {

        Attri<String, String, String> attri = new Attri<>();

        String bookName = attri.getBookName("2");

        System.out.println(bookName);

    }

总结

1. 泛型的类型个数可以是多个
2. 泛型可以通过extend或super来实例化时，指定向下约束类型或者向上约束类型
3. 泛型可以通过通配符来限制泛型的类型
4. 定义为泛型的类和接口也可以被继承与实现