美文网首页Java
Java 泛型

Java 泛型

作者: 一亩三分甜 | 来源:发表于2019-09-14 23:30 被阅读0次

泛型:JDK1.5版本以后出现新特性，用于解决安全问题，是一个安全机制。

好处:

  • 1.将运行时期出现问题ClassCastException,转移到了编译时期。 方便于程序员解决问题，让运行时期问题减少，安全。
  • 2.避免了强制转换麻烦。
    泛型格式:通过<>来定义要操作的引用数据类型。
    在使用java提供的对象时，什么时候写泛型呢？
    通常在集合框架中很常见。
    只要见到<>就要定义泛型。
    其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo {
    public static void main(String[] args) {
        ArrayList al = new ArrayList();
        al.add("abc01");
        al.add("abc099");
        al.add("007");
        al.add(4);

        Iterator it = al.iterator();
        while (it.hasNext())
        {
            String s = (String)it.next();
            System.out.println(s+":"+s.length());
        }
    }
}
//输出
abc01:5
abc099:6
007:3
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at GenericDemo.main(GenericDemo.java:15)

此时可以对ArrayList进行制定类型String。

import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo0 {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc01");
        al.add("abc099");
        al.add("007");

        Iterator<String> it = al.iterator();
        while (it.hasNext())
        {
            String s = it.next();
            System.out.println(s+":"+s.length());
        }
    }
}
//输出
abc01:5
abc099:6
007:3

增加泛型，避免强制类型转换。

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class GenericDemo1 {
    public static void main(String[] args) {
        TreeSet<String> ts = new TreeSet<String>(new LenCompatator());
        ts.add("abcd");
        ts.add("cc");
        ts.add("cba");
        ts.add("aaa");
        ts.add("z");
        ts.add("hahaha");
        Iterator<String> it = ts.iterator();
        while(it.hasNext())
        {
            String s = it.next();
            System.out.println(s);
        }
    }
}
class LenCompatator implements Comparator<String>
{
    public int compare(String o1,String o2)
    {
        int num = new Integer(o2.length()).compareTo(new Integer(o1.length()));
        if (num == 0)
        {
           return o2.compareTo(o1);
        }
        return num;
    }
}
//输出:倒序排列，交换o1和o2的比较位置。
hahaha
abcd
cba
aaa
cc
z

泛型类

什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，早起定义Object来完成扩展。现在定义泛型来完成扩展。

class Student3
{

}
class Worker
{

}
class Utils<QQ>
{
    private QQ q;
    public void setObject(QQ q)
    {
        this.q = q;
    }
    public QQ getObject()
    {
        return q;
    }
}
public class GenericDemo2 {
    public static void main(String[] args) {
        Utils<Worker> u = new Utils<Worker>();
        u.setObject(new Worker());
        Worker w = (Worker)u.getObject();
    }
}

class Demo9<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
    public void print(T t)
    {
        System.out.println("print:"+t);
    }
}
public class GenericDemo3 {
    public static void main(String[] args) {
        Demo9<Integer> d = new Demo9<Integer>();
        d.show(new Integer(4));
        d.print("hahaha");
    }
}
//输出
Error:(16, 17) java: 不兼容的类型: java.lang.String无法转换为java.lang.Integer

class Demo9<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
    public void print(T t)
    {
        System.out.println("print:"+t);
    }
}
public class GenericDemo3 {
    public static void main(String[] args) {
        Demo9<Integer> d = new Demo9<Integer>();
        d.show(new Integer(4));
//        d.print("hahaha"); 编译报错Error:(16, 17) java: 不兼容的类型: java.lang.String无法转换为java.lang.Integer
    Demo9<String> d1 = new Demo9<String>();
    d1.print("haha");
    d1.show(5);
    }
}
//输出
Error:(19, 13) java: 不兼容的类型: int无法转换为java.lang.String

class Demo9<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
    public void print(T t)
    {
        System.out.println("print:"+t);
    }
}
public class GenericDemo3 {
    public static void main(String[] args) {
        Demo9<Integer> d = new Demo9<Integer>();
        d.show(new Integer(4));
//        d.print("hahaha"); 编译报错Error:(16, 17) java: 不兼容的类型: java.lang.String无法转换为java.lang.Integer
    Demo9<String> d1 = new Demo9<String>();
    d1.print("haha");
//    d1.show(5);Error:(19, 13) java: 不兼容的类型: int无法转换为java.lang.String
    }
}
//输出
show:4
print:haha

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。

class Demo10
{
    public <T> void show(T t)
    {
        System.out.println("show:"+t);
    }
    public <T> void print(T q)
    {
        System.out.println("print:"+q);
    }
}
public class GenericDemo4 {
    public static void main(String[] args) {
        Demo10 d = new Demo10();
        d.show("hahaha");
        d.show(new Integer(4));
        d.print("heihei");
    }
}
//输出
show:hahaha
show:4
print:heihei

静态方法泛型

静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

class Demo11<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
    public<Q> void print(Q q)
    {
        System.out.println("print:"+q);
    }
    public static void method(T t)
    {
        System.out.println("method:"+t);
    }
}
public class GenericDemo5 {
    public static void main(String[] args) {
        Demo11 <String> d = new Demo11<String>();
        d.show("hahaha");
//        d.show(4);
        d.print(5);
        d.print("hehehe");
    }
}
//输出
Error:(11, 31) java: 无法从静态上下文中引用非静态 类型变量 T

class Demo11<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
    public<Q> void print(Q q)
    {
        System.out.println("print:"+q);
    }
    public static<W> void method(W w)
    {
        System.out.println("method:"+w);
    }
}
public class GenericDemo5 {
    public static void main(String[] args) {
        Demo11 <String> d = new Demo11<String>();
        d.show("hahaha");
//        d.show(4);
        d.print(5);
        d.print("hehehe");
        Demo11.method("hahahaha");
    }
}
//输出
show:hahaha
print:5
print:hehehe
method:hahahaha

泛型定义在接口上

interface Inter0<T>
{
    void show(T t);
}
class InterImpl implements Inter0<String>
{
    public void show(String t)
    {
        System.out.println("show:"+t);
    }
}
public class GenericDemo6 {
    public static void main(String[] args) {
        InterImpl i = new InterImpl();
        i.show("haha");
    }
}
//输出
show:haha

interface Inter0<T>
{
    void show(T t);
}
/*
class InterImpl implements Inter0<String>
{
    public void show(String t)
    {
        System.out.println("show:"+t);
    }
}
*/
class InterImpl<T> implements Inter0<T>
{
    public void show(T t)
    {
        System.out.println("show:"+t);
    }
}
public class GenericDemo6 {
    public static void main(String[] args) {
        InterImpl<Integer> i = new InterImpl<Integer>();
        i.show(4);
//        InterImpl i = new InterImpl();
//        i.show("haha");
    }
}
//输出
show:4

泛型限定

import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo7 {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<String>();
        al.add("abc1");
        al.add("abc2");
        al.add("abc3");

        ArrayList<Integer> al1 = new ArrayList<Integer>();
        al1.add(4);
        al1.add(5);
        al1.add(6);

        printColl(al);
        printColl(al1);
    }
    public static void printColl(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while (it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}
//输出
abc1
abc2
abc3
4
5
6

import java.util.ArrayList;
import java.util.Iterator;

class Person5
{
    private String name;
    Person5(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
}
class Student4 extends Person5
{
    Student4(String name)
    {
        super(name);
    }
}
public class GenericDemo8 {
    public static void main(String[] args) {
        ArrayList<Person5> al = new ArrayList<Person5>();
        al.add(new Person5("abc1"));
        al.add(new Person5("abc2"));
        al.add(new Person5("abc3"));
        printColl(al);

        ArrayList<Student4> al1 = new ArrayList<Student4>();
        al1.add(new Student4("abc---1"));
        al1.add(new Student4("abc---2"));
        al1.add(new Student4("abc---3"));
        printColl(al1);//ArrayList<Student4> al = new ArrayList<Person>();
    }
    public static void printColl(ArrayList<Person5> al)
    {
        Iterator<Person5> it = al.iterator();
        while (it.hasNext())
        {
            System.out.println(it.next().getName());
        }
    }
}
//输出
Error:(35, 19) java: 不兼容的类型: java.util.ArrayList<Student4>无法转换为java.util.ArrayList<Person5>

? 通配符。也可以理解为占位符。泛型的限定:

? extends E:可以接收E类型或者E的子类型。上限

? super E:可以接收E类型或者E的父类型。下限

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

class Person7
{
    private String name;
    private int age;
    Person7(String name)
    {
        this.name = name;
    }
    Person7(String name,int age)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
class Student6 extends Person7 implements Comparable<Person7>
{
    Student6(String name)
    {
        super(name);
    }
    Student6(String name,int age)
    {
        super(name,age);
    }
    public int compareTo(Person7 p)
    {
        this.getName();
        return 1;
    }
}
class Comp implements Comparator<Student6>
{
    public int compare(Student6 s1,Student6 s2)
    {
        return s1.getName().compareTo(s2.getName());
    }
}
class Comp0 implements Comparator<Person7>//<? super E>
{
    public int compare(Person7 s1,Person7 s2)
    {
        return s1.getName().compareTo(s2.getName());
    }
}
public class GenericDemo10 {
    public static void main(String[] args) {
        TreeSet<Student6> ts = new TreeSet<Student6>(new Comp0());
        ts.add(new Student6("abc1"));
        ts.add(new Student6("abc2"));
        ts.add(new Student6("abc3"));
        Iterator it = ts.iterator();
        while (it.hasNext())
        {
            Student6 stu = (Student6)it.next();
            System.out.println(stu.getName());
        }
    }
}
//输出
abc1
abc2
abc3

<？super E>举例说明

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

class Person8
{
    private String name;
    Person8(String name)
    {
        this.name = name;
    }

    public String getName()
    {
        return name;
    }
}
class Student7 extends Person8
{
    Student7(String name)
    {
        super(name);
    }
}
class Worker0 extends Person7
{
    Worker0(String name)
    {
        super(name);
    }
}
class Comp1 implements Comparator<Student7>
{
    public int compare(Student7 p1,Student7 p2)
    {
        return p1.getName().compareTo(p2.getName());
    }
}
class Comp2 implements Comparator<Worker0>
{
    public int compare(Worker0 p1,Worker0 p2)
    {
        return p1.getName().compareTo(p2.getName());
    }
}
public class GenericDemo11 {
    public static void main(String[] args) {
        TreeSet<Student7> ts = new TreeSet<Student7>(new Comp1());
        ts.add(new Student7("abc---1"));
        ts.add(new Student7("abc---2"));
        ts.add(new Student7("abc---3"));
        ts.add(new Student7("abc---6"));
        Iterator<Student7> it = ts.iterator();
        while (it.hasNext())
        {
            Student7 stu = it.next();
            System.out.println(stu.getName());
        }


        TreeSet<Worker0> ts0 = new TreeSet<Worker0>(new Comp2());
        ts0.add(new Worker0("abc---111"));
        ts0.add(new Worker0("abc---222"));
        ts0.add(new Worker0("abc---333"));
        ts0.add(new Worker0("abc---666"));
        Iterator<Worker0> it0 = ts0.iterator();
        while (it0.hasNext())
        {
            Worker0 stu = it0.next();
            System.out.println(stu.getName());
        }
    }
}
//输出
abc---1
abc---2
abc---3
abc---6
abc---111
abc---222
abc---333
abc---666

放在一个构造器中

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

class Person9
{
    private String name;
    Person9(String name)
    {
        this.name = name;
    }

    public String getName()
    {
        return name;
    }
}
class Student8 extends Person9
{
    Student8(String name)
    {
        super(name);
    }
}
class Worker1 extends Person9
{
    Worker1(String name)
    {
        super(name);
    }
}
class Comp3 implements Comparator<Person9>
{
    public int compare(Person9 p1,Person9 p2)
    {
        return p1.getName().compareTo(p2.getName());
    }
}
public class GenericDemo11 {
    public static void main(String[] args) {
        TreeSet<Student8> ts = new TreeSet<Student8>(new Comp3());
        ts.add(new Student8("abc---1"));
        ts.add(new Student8("abc---2"));
        ts.add(new Student8("abc---3"));
        ts.add(new Student8("abc---6"));
        Iterator<Student8> it = ts.iterator();
        while (it.hasNext())
        {
            Student8 stu = it.next();
            System.out.println(stu.getName());
        }


        TreeSet<Worker1> ts0 = new TreeSet<Worker1>(new Comp3());
        ts0.add(new Worker1("abc---111"));
        ts0.add(new Worker1("abc---222"));
        ts0.add(new Worker1("abc---333"));
        ts0.add(new Worker1("abc---666"));
        Iterator<Worker1> it0 = ts0.iterator();
        while (it0.hasNext())
        {
            Worker1 stu = it0.next();
            System.out.println(stu.getName());
        }
    }
}
//输出
abc---1
abc---2
abc---3
abc---6
abc---111
abc---222
abc---333
abc---666

相关文章

  • Java泛型教程

    Java泛型教程导航 Java 泛型概述 Java泛型环境设置 Java泛型通用类 Java泛型类型参数命名约定 ...

  • 第二十八课：泛型

    泛型出现之前 泛型出现之后 Java深度历险（五）——Java泛型

  • Kotlin 泛型

    说起 kotlin 的泛型，就离不开 java 的泛型，首先来看下 java 的泛型，当然比较熟悉 java 泛型...

  • java泛型中类型擦除的一些思考

    java泛型 java泛型介绍 java泛型的参数只可以代表类，不能代表个别对象。由于java泛型的类型参数之实际...

  • Java泛型

    参考：Java知识点总结（Java泛型） 自定义泛型类 自定义泛型接口 非泛型类中定义泛型方法 继承泛型类 通配符...

  • Java泛型—Java语法糖，只在编译有作用，编译后擦出泛型

    Java泛型—Java语法糖，只在编译有作用，编译后擦出泛型 在代码进入和离开的边界处，会处理泛型 Java泛型作...

  • JAVA 核心笔记 || [xxx] 泛型

    泛型 JAVA 的参数化类型 称为 泛型 泛型类的设计 Learn12.java 运行

  • 简单回顾Java泛型之-入门介绍

    什么时候开始有了Java泛型？什么是Java泛型？为什么要引入Java泛型？什么时候用到了泛型？可不可以给泛型下一...

  • Kotlin 泛型

    Kotlin 支持泛型， 语法和 Java 类似。例如，泛型类： 泛型函数： 类型变异 Java 的泛型中，最难理...

  • JAVA-泛型

    JAVA-泛型 sschrodinger 2018/11/15 简介 泛型是Java SE 1.5的新特性，泛型的...

网友评论

    本文标题：Java 泛型

    本文链接：https://www.haomeiwen.com/subject/qthzyctx.html

    延伸阅读

    深度阅读

    • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

    栏目导航

    热点阅读

    Java

    关于我们|服务条款|联系我们|Java 泛型|投稿指南|网站地图|RSS订阅|排版工具|手机版

    提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

    Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

    备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

    本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

    所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！