Java小记 泛型

---

定义泛型类

类名<T>

• 一般类型名称用T表达
• 容器元素用E表达

import static java.lang.System.out;
import java.util.*;

public class TestOne<T> {       // 定义泛型类
    private T over;
    public T getOver()          // get____()
    {
        return over;
    }
    public void setOver(T over) // set___()
    {
        this.over = over;
    }
    public static void doit()
    {
        HashMap<Object, Object> map = new HashMap<>();
        map.put("Leela", new int[]{1, 2});
        map.put(12, "Bender");
        out.println(map.get(12));
    }
    public static void main(String[] args)
    {
        // 实例化一个Boolean对象
        TestOne<Boolean> over01 = new TestOne<>();
        // 实例化一个Float对象
        TestOne<Float> over02 = new TestOne<>();
        over01.setOver(true);   // 不需要类型转换
        over02.setOver(12.3f);
        Boolean b = over01.getOver();
        Float f = over02.getOver();
        out.println(b);
        out.println(f);
    }
}

---

声明数组

• 但是不能建立泛型数组实例

public calss One<T>
{
	private T[] array;
	// private T[] array = new T[10];  | x 不能建立数组实例
}

---

泛型常规用法

• 常用的被泛型化的集合类

集合类	泛型定义
ArrayList	ArrayList<E>
HashMap	HashMap<K, V>
HashSet	HashSet<E>
Vector	Vector<E>

HashMap<K, V> map = new HashMap<>();

---

高级用法

限制泛型可用类型

class 类名称<T extends anyClass>

• anyClass指某个接口或类

---

使用类型通配符

• 限制泛型类型，或实现继承某个接口或类的子类

泛型名称<? extends List> a=null;

• <? extends List>表示类型未知，当需要使用该泛型对象时，可以单独实例化。

A<? extends List> a=null;
a = A<ArrayList>();
a = A<LinkedList>();

public void doit(A<? extends List>){
}

• A<?> ?

List<String> list01 = new ArrayList<>();
list01.add("Bender");
List<?> list02 = list01;
List<?> list03 = new LinkedList<Integer>();

list01.set(0, "Nope");
// list02.set(0, "Nope");   x 
// list03.set(0, 1);        x
list02.get(0);
list02.remove(0);

• 使用通配符声明的实例化对象不能加入新信息，只能获取或删除
• 可以向上限制

A<? super List> a=null; // 对象a只接受List接口或上层父类类型：
a = new A<Object>();

---

继承泛型类与实现泛型接口

public class ExtendClass<T1>{
}
class subClass<T1, T2, T3> extends ExtendClass<T1>{
}

继承父类需要指明父类的泛型类型，如果直接继承，那么subClass中的T1, T2, T3 都会自动变成Object

interface Intf<T1>{
}
class subClass<T1, T2, T3> implementsIntf<T1>{
}

---

import java.util.*;
import static java.lang.System.out;

public class TestA<A> {

    public static void getdata(Ttest<? extends Number> t)
    {
        out.println("id: " + t.get_id() + "  score: " + t.get_score());
    }

    public static void main(String[] args){

        Ttest<Integer> one = new Ttest<>(12, 22);
        getdata(one);


    }
}

class Ttest<T>
{
    T id;
    T score;
    public Ttest(T id, T score)
    {
        this.id = id;
        this.score = score;
    }
    public T get_id()
    {
        return id;
    }
    public T get_score()
    {
        return score;
    }
    public void set_info(T id, T score)
    {
        this.id = id;
        this.score = score;
    }
}