Java泛型Generics

原创 2016年05月24日 20:19:21

转载请标明出处: 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());
    }

}

这里写图片描述

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/wu_wxc/article/details/51493181

Java Generics(泛型)

Java泛型是JDK 5中引入的一个新特性,允许在定义类和接口的时候使用类型参数。 泛型类 泛型类是我们最经常使用的泛型形式了,如下: /** * 工具类 * Created by ...
  • dliyuedong
  • dliyuedong
  • 2015-12-08 22:58:19
  • 680

Java泛型(Generics)

参考:http://docs.oracle.com/javase/tutorial/java/generics/index.html 为什么要使用泛型
  • navyhu
  • navyhu
  • 2014-10-28 10:53:56
  • 2502

<em>java</em> <em>generics</em> faq

<em>Java</em> <em>Generics</em> and Collections.pdf 时间:2018-4-9<em>JavaGenerics</em>FAQ 时间:2018-3...<em>CSDN</em>下载频道资源及相关规则调整公告V11.10 下载频道用户反馈专区 下载频道积分规则...
  • 2018年04月14日 00:00

Java泛型Generics

转载请标明出处: http://blog.csdn.net/wu_wxc/article/details/51493181 本文出自【吴孝城的CSDN博客】 泛型泛型是JDK1.5中引入的一个新...
  • wu_wxc
  • wu_wxc
  • 2016-05-24 20:19:21
  • 3641

Xcode 7新的特性Lightweight Generics 轻量级泛型与__kindof修饰符

Lightweight Generics 轻量级泛型,轻量是因为这是个纯编译器的语法支持(llvm 7.0),和 Nullability 一样,没有借助任何 objc runtime 的升级,也就是说...
  • leikezhu1981
  • leikezhu1981
  • 2015-08-11 11:46:36
  • 9702

c#2.0新特性:(一)泛型(Generics)

为了提高应用程序的效率和可用性,C#2.0引入了泛型概念.C#泛型有些类似C++的摸版。(一)特点        泛型具有以下功能特点:     一、使用泛型可以定义类型安全的数据结构,而无需使用实际...
  • zhouhuan965
  • zhouhuan965
  • 2012-12-27 16:19:57
  • 677

<em>Generics</em>_in

<em>Generics</em>_in_the_<em>Java</em>_Programming_Language,英文原文 综合评分:0 收藏评论举报 所需: 2积分/C币 下载个数: 3 开通VIP 立即下载 ...
  • 2018年04月13日 00:00

Java的范型(Generics)

主要是为了解决编译器编译时报错而采用,如果没有该范型,结合类会受到较大影响;参考文献: http://java.sun.com/docs/books/tutorial/java/generics/in...
  • longronglin
  • longronglin
  • 2008-02-25 13:37:00
  • 707

Kotlin-15.泛型(generics)

Kotlin类也有类型参数泛型generics;型变(Variance);Java泛型通配符;型变Variance;声明处型变Declaration-site variance;out, in修饰符;...
  • qq_32115439
  • qq_32115439
  • 2017-06-24 00:09:46
  • 405

JAVA 泛型总结(结合JAVA核心技术和Effective Java两书)

一、基础知识 1、类型擦除 类型擦除指的是通过类型参数合并, 将泛型类型实例关联到同一份字节码上。 编译器只为泛型类型生成一份字节码, 并将其实例关联到这份字节码上, 因此泛型类型中的静态变量是所有实...
  • supersnow0622
  • supersnow0622
  • 2016-12-18 15:23:20
  • 802
收藏助手
不良信息举报
您举报文章:Java泛型Generics
举报原因:
原因补充:

(最多只允许输入30个字)