Java泛型Generics

轉載請標明出處： http://blog.csdn.net/wu_wxc/article/details/51493181
本文出自【吳孝城的CSDN博客】

泛型

泛型是JDK 5中引入的一個新特性

在尖括號中包含的是形式類型參數，可以在整個類的聲明中被使用，當類被使用時，會使用具體的實際類型參數來代替

形式類型參數的命名：儘量使用單個大寫字母

普通泛型

一個泛型類型

package cn.wuxiaocheng;

class Person<T> { // 標識符可以隨便寫，T是type的簡稱
    private T name; // name的的類型由T指定，也就是外部指定

    public T getName() { // 返回值的類型由外部指定
        return name;
    }

    public void setName(T name) { // 設置的類型由外部指定
        this.name = name;
    }
}

public class Generics {

    public static void main(String[] args) {
        // 設置Person的類型爲String類型
        Person<String> person = new Person<String>();
        // 設置字符串
        person.setName("名字");
        // 輸出
        System.out.println(person.getName());
    }

}

多泛型類型

package cn.wuxiaocheng;

class Person<T, K> { // 標識符可以隨便寫，T是type的簡稱
    private T name; // name的的類型由T指定，也就是外部指定
    private K age; // age的的類型由T指定，也就是外部指定

    public T getName() { // 返回值的類型由外部指定
        return name;
    }

    public K getAge() { // 返回值的類型由外部指定
        return age;
    }

    public void setName(T name) { // 設置的類型由外部指定
        this.name = name;
    }

    public void setAge(K age) { // 設置的類型由外部指定
        this.age = age;
    }
}

public class Generics {

    public static void main(String[] args) {
        // 定義兩個泛型類型的變量，對應的數據類型分別爲String, Integer
        Person<String, Integer> person = new Person<String, Integer>();
        person.setName("名字");
        person.setAge(20);

        System.out.println(person.getName() + "    " + person.getAge());
    }

}

通配符：”?”

package cn.wuxiaocheng;

class Person<T> { // 標識符可以隨便寫，T是type的簡稱
    private T name;

    public void setName(T name) {
        this.name = name;
    }

    public T getName() {
        return name;
    }

    @Override
    public String toString() {
        // 直接打印成字符
        return this.name.toString();
    }
}

public class Generics {

    public static void main(String[] args) {
        // 泛型類型爲String
        Person<String> person = new Person<String>();
        // 設置字符
        person.setName("名字");
        // 調用test方法並將person傳遞過去
        test(person);
    }

    // 靜態方法，參數爲泛型，沒有指定具體類型。用通配符"?"
    public static void test(Person<?> t) {
        System.out.println(t);
    }

}

受限泛型

extends：向上造型
super：向下造型

package cn.wuxiaocheng;

class Person<T> { // 標識符可以隨便寫，T是type的簡稱
    private T age;

    public void setAge(T age) {
        this.age = age;
    }

    public T getAge() {
        return age;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return this.age.toString();
    }
}

public class Generics {

    public static void main(String[] args) {
        // 聲明Integer的泛型對象
        Person<Integer> p1 = new Person<Integer>();
        // 聲明Float的泛型對象
        Person<Float> p2 = new Person<Float>();

        // 設置整數，自動裝箱
        p1.setAge(20);
        // 設置小數
        p2.setAge(23.0f);

        // 調用test方法
        test(p1);
        test(p2);
    }

    // 只接受Number及Number的子類
    public static void test(Person<? extends Number> temp) {
        System.out.println(temp);
    }
}

package cn.wuxiaocheng;

class Person<T> { // 標識符可以隨便寫，T是type的簡稱
    private T name;

    public void setName(T name) {
        this.name = name;
    }

    public T geName() {
        return name;
    }

    @Override
    public String toString() {
        return this.name.toString();
    }
}

public class Generics {

    public static void main(String[] args) {
        // 聲明String的泛型對象
        Person<String> p1 = new Person<String>();
        // 聲明Object的泛型對象
        Person<Object> p2 = new Person<Object>();

        // 設置整數，自動裝箱
        p1.setName("p1");
        // 設置小數
        p2.setName("p2");

        // 調用test方法
        test(p1);
        test(p2);
    }

    // 只接受String或Object的類型的參數
    public static void test(Person<? super String> temp) {
        System.out.println(temp);
    }
}

Java泛型接口

package cn.wuxiaocheng;

// 在接口上定義泛型
interface Person<T> {
    // 定義抽象方法，抽象方法的返回值就是泛型類型
    public T getName();
}

// 定義泛型接口的子類
class People<T> implements Person<T> {

    // 定義泛型屬性
    private T name;

    // 通過構造方法設置屬性內容
    public People(T name) {
        this.setName(name);
    }

    public void setName(T name) {
        this.name = name;
    }

    @Override
    public T getName() {
        // TODO Auto-generated method stub
        return this.name;
    }

}

public class Generics {

    public static void main(String[] args) {
        // 聲明對象並通過子類實例化對象
        Person<String> person = new People<String>("名字");
        System.err.println(person.getName());
    }

}

package cn.wuxiaocheng;

// 在接口上定義泛型
interface Person<T> {
    // 定義抽象方法，抽象方法的返回值就是泛型類型
    public T getName();
}

// 定義泛型接口的子類
class People implements Person<String> {

    // 定義泛型屬性
    private String name;

    // 通過構造方法設置屬性內容
    public People(String name) {
        this.setName(name);
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return this.name;
    }

}

public class Generics {

    public static void main(String[] args) {
        // 聲明對象並通過子類實例化對象
        Person person = new People("名字");
        System.err.println(person.getName());
    }

}

Java泛型方法

package cn.wuxiaocheng;

class Person {
    // 可以接收任意類型的數據
    public <T> T fun(T t) {
        // 返回參數
        return t;
    }
}

public class Generics {

    public static void main(String[] args) {
        // 實例化Test對象
        Person person = new Person();
        // 傳遞字符串
        String string = person.fun("名字");
        // 傳遞數字
        int i = person.fun(20);

        System.out.println(string);
        System.out.println(i);
    }

}

通過泛型方法返回泛型實例

package cn.wuxiaocheng;

//指定基上限，只能是數字類型
class Person<T extends Number> {
    private T age;

    public T getAge() {
        return this.age;
    }

    public void setAge(T age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return this.age.toString();
    }
}

public class Generics {

    public static void main(String[] args) {
        Person<Integer> i = fun(30);
        System.out.println(i.getAge());
    }

    // 方法中傳入或返回的泛型類型由調用方法時所設置的參數類型決定
    public static <T extends Number> Person<T> fun(T param) {
        // 根據傳入換數據類型實例化Person
        Person<T> temp = new Person<T>();
        // 將傳遞的內容設置到Person對象的age屬性中
        temp.setAge(param);
        // 返回實例化對象
        return temp;
    }
}

使用泛型統一傳入的參數類型

package cn.wuxiaocheng;

//指定基上限，只能是數字類型
class Person<T> {
    private T name;

    public T getName() {
        return this.name;
    }

    public void setName(T name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return this.name.toString();
    }
}

public class Generics {

    public static void main(String[] args) {
        Person<String> i1 = new Person<String>();
        Person<String> i2 = new Person<String>();
        i1.setName("i1");
        i2.setName("i2");

        add(i1, i2);
    }

    public static <T> void add(Person<T> i1, Person<T> i2) {
        System.out.println(i1.getName() + "   " + i2.getName());
    }
}

Java泛型數組

package cn.wuxiaocheng;

public class Generics {

    public static void main(String[] args) {
        Integer i[] = test(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
        test2(i);
    }

    // 接收可變參數
    public static <T> T[] test(T... arg) {
        // 返回泛型數組
        return arg;
    }

    public static <T> void test2(T param[]) {
        System.out.println("接收泛型數組");
        for (T t : param) {
            System.out.print(t + " ");
        }
    }

}

Java泛型的嵌套設置

package cn.wuxiaocheng;

class Person<T, K> {
    private T name;
    private K age;

    public Person(T name, K age) {
        this.name = name;
        this.age = age;
    }

    public void setName(T name) {
        this.name = name;
    }

    public void setAge(K age) {
        this.age = age;
    }

    public T getName() {
        return name;
    }

    public K getAge() {
        return age;
    }
}

class Test<S> {
    private S s;

    public Test(S s) {
        this.setPerson(s);
        ;
    }

    public void setPerson(S s) {
        this.s = s;
    }

    public S getPerson() {
        return s;
    }

}

public class Generics {

    public static void main(String[] args) {
        // 將Person作爲Test的泛型參數
        Test<Person<String, Integer>> test = null;
        // 指定Person兩個泛型的數據類型
        Person<String, Integer> i = null;
        // 實例化Person對象
        i = new Person<String, Integer>("名字", 20);
        // 在Test類中設置Person對象
        test = new Test<Person<String, Integer>>(i);
        System.out.println(test.getPerson().getName());
        System.out.println(test.getPerson().getAge());
    }

}