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());
    }

}