Java泛型Generics

转载请标明出处： http://blog.csdn.net/wu_wxc/article/details/51493181

泛型

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

}

时间： 2024-11-09 23:17:45

Java泛型Generics的相关文章

Java 泛型(Generics) 综述

一. 引子一般的类和方法,只能使用具体类型:要么是基本类型,要么是自定义类型.如果要编写可以应用于多种类型的代码,这种刻板的限制对代码的束缚就会很大. 多态算是一种泛化机制,但对代码的约束还是太强(要么继承父类,要么实现接口). 有许多原因促成了泛型的出现,而最引人注目的一个原因,就是为了创造容器类.(泛型的主要目的之一就是用来指定容器要持有什么类型的对象,而且由编译器来保证类型的正确性) 例如,在 Java 实现加入泛型前,ArrayList 只维护一个 Object 类型的数组: publ

java泛型 generics --- 第三部分泛型、继承、和子类型

Generics, Inheritance, and Subtypes 正如你所知,可以把一种对象类型赋值给另一种类型,只要他们是兼容的.例如,你可以把Integer对象赋值给Object. Object someObject = new Object(); Integer someInteger = new Integer(10); someObject = someInteger; // OK 在面向对象技术中,这被称作"is a"关系.即一个Integer是一中Object,该赋

Java 泛型 (generics) 的使用

泛型是JDK1.5以后增加的,它可以帮助我们建立类型安全的集合.在使用了泛型的集合中,遍历时不必进行强制类型转换.JDK提供了支持泛型的编译器,将运行时的类型检查提前到了编译时执行,提高了代码可读性和安全性. 泛型的本质就是“数据类型的参数化”. 我们可以把“泛型”理解为数据类型的一个占位符(形式参数),即告诉编译器,在调用泛型时必须传入实际类型. 自定义泛型: 我们可以在类的声明处增加泛型列表,如:<T,E,V>.字符可以是任何标识符,一般采用这3个字母. demo: package ftf

Java 语法索引 ----- 泛型(Generics)

class B<T extends A> {} class A {} -------------------------- class C<T extends I> {} interface I {} ----------------------- class D<T extends A & I> {} class E<T extends A & I, U extends A & I> {} 参考文献: Java Quick Synt

2017.4.5 Java 泛型

Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型. 泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数. 假定我们有这样一个需求:写一个排序方法,能够对整形数组.字符串数组甚至其他任何类型的数组进行排序,该如何实现? 答案是可以使用 Java 泛型. 使用 Java 泛型的概念,我们可以写一个泛型方法来对一个对象数组排序.然后,调用该泛型方法来对整型数组.浮点数数组.字符串数组等进行排

1月21日 - （转）Java 泛型

java泛型什么是泛型? 泛型(Generic type 或者 generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类.可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,就像方法的形式参数是运行时传递的值的占位符一样. 可以在集合框架(Collection framework)中看到泛型的动机.例如,Map 类允许您向一个 Map 添加任意类的对象,即使最常见的情况是在给定映射(map)中保存某个特定类型(比如 String)的对象. 因为 M

java泛型的讲解

Java 泛型 Java使用泛型的意义

Java 泛型 Java使用泛型的意义 @author ixenos 直接意义在编译时保证类型安全根本意义 a) 类型安全问题源自可复用性代码的设计,泛型保证了类型安全的复用模板 b) 使用复用性模板时不用手动强制类型转换三种泛型实现方式的优缺点 C++:模板方式实现,在编译时完全展开并且支持偏特化,类型精度高,代码共享差: Java 5:擦除方式实现,仅用于编译时类型检查,在运行时擦除,向后兼容性好,代码共享好,类型精度非常差: C# 2.0:混合方式实现,在运行时展开特化,类型精度高,

java泛型小问题

几年前当Java5还未正式发布的时候,看到过一些人写的介绍Tiger中的新特性,当时对我第一感觉冲击最大的就是泛型(generics)和注释(annotation),因为它们直接影响了我们编码的语法习惯. 在后来的使用过程中,对于泛型一直没有特别深入的使用过,没有遇到那样的需求和场景.只需要了解Java中的泛型是编译期的,运行期被“擦拭”掉了:然后还有几种通配符的表示就足够了. 直到一天我在查看Java5中Enum的源代码时,发现它是这么定义的: Java代码 public abstract c