Java中的泛型-学习笔记

迷南。 2023-02-14 15:49 20阅读 0赞

**目录**

泛型概述

泛型的使用

泛型类

泛型方法

泛型接口

泛型高级应用：泛型限定

--------------------

# 泛型概述 #

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

泛型好处：

1.  将运行时期出现问题ClassCastException问题，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。
2.  避免了强制转换麻烦。

泛型格式：通过<>来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见，只要见到<>就要定义泛型。其实<> 就是用来接收类型的。

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

看一下不使用泛型时的情形：

ArrayList al = new ArrayList();
    al.add("01");
    al.add(3);
    Iterator it = al.iterator();
    while (it.hasNext())
    {
        String s=(String)it.next();  //强转（length()为String特有方法）
        System.out.println(s+":"+s.length());  //打印字符串的长度
    }

编译运行时会出现ClassCastException异常：

![20200603174023533.png][]

ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，在使用

时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。

# 泛型的使用 #

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法。

例1.泛型应用在比较器接口中

class RegexDemo
    {
      public static void main(String[] args) {
       TreeSet<String>ts=new TreeSet<String>(new LenComparator());
       ts.add("a");
       ts.add("ab");
       ts.add("abc");
       ts.add("abcd");
       Iterator<String>it=ts.iterator();
       while(it.hasNext())
       {
         String s=it.next();
         System.out.println(s);
       }
      }
    }
    
    //定义比较器，对字符串进行排序
    //在比较器接口上使用泛型
    class LenComparator implements Comparator<String>
    {
      public int compare(String s1,String s2)
      {
           //使用Integer.valueOf()替代之前的new Integer()
           //Integer. valueOf()可以将基本类型int转换为包装类型Integer
        int num= Integer.valueOf(s1.length()).compareTo(Integer.valueOf(s2.length()));
        if(num==0)
          return s1.compareTo(s2);
        return num;
      }
    }

![20200603180959175.png][]

# 泛型类 #

什么时候定义泛型类？

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

public class Demo {
      public static void main(String[] args) {
        Utils<Student> u=new Utils<Student>();
        u.setT(new Student());
        Student s=u.getT();
      }
    }
    class Student
    {
    
    }
    
    //定义泛型类
    //泛型类定义的泛型，在整个类中有效。如果被方法使用
    //那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了
    class Utils<T>
    {
      private T t;
      public void setT(T t)
      {
        this.t=t;
      }
      public T getT()
      {
        return t;
      }
    }

泛型定义在类上时的情形：

public class Demo {
      public static void main(String[] args) {
        GenericDemo<String> gd=new GenericDemo<String>();
        gd.show("hello");
        GenericDemo<Integer> gd1=new GenericDemo<Integer>();
        gd1.run(4);
      }
    }
    class GenericDemo<T>
    {
      public void show(T t)
      {
        System.out.println("show:"+t);
      }
      public void run(T t)
      {
        System.out.println("run:"+t);
      }
    }

![20200603212421187.png][]

# 泛型方法 #

注意：泛型定义在方法上时，要定义在返回值类型的前面，修饰符的后面。

public class Demo {
      public static void main(String[] args) {
        GenericDemo gd=new GenericDemo();
        gd.show("hello");
        gd.show(4);
        gd.run("world");
      }
    }
    //为了让不同方法可以操作不同类型，而且类型还不确定
    //那么可以将泛型定义在方法上
    class GenericDemo
    {
      //泛型定义在方法上
      public <T> void show(T t)
      {
        System.out.println("show:"+t);
      }
      public <Q> void run(Q q)
      {
        System.out.println("run:"+q);
      }
    }

![20200603212839115.png][]

特殊之处：静态方法不可以访问类上定义的泛型，（泛型需要建立对象才能明确，此时静态方法还没有对象）

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

public class Demo {
      public static void main(String[] args) {
        GenericDemo gd=new GenericDemo();
        gd.show("hello");
      }
    }
    class GenericDemo
    {
      //泛型定义在静态方法上
      public static <T> void show(T t)
      {
        System.out.println("show:"+t);
      }
    }

# 泛型接口  #

public class Demo {
      public static void main(String[] args) {
        interImp it=new interImp();
        it.show("hello");
      }
    }
    //泛型定义在接口上
    interface inter<T>
    {
      void show(T t);
    }
    class interImp implements inter<String>
    {
      public void show(String str)
      {
        System.out.print(str);
      }
    }

另外一种写法：

public class Demo {
      public static void main(String[] args) {
        interImp<Integer>it=new interImp<Integer>();
        it.show(3);
      }
    }
    //泛型定义在接口上
    interface inter<T>
    {
      void show(T t);
    }
    //具体实现时也不明确类型
    class interImp<T> implements inter<T>
    {
      public void show(T t)
      {
        System.out.print(t);
      }
    }

![20200603214916743.png][]

# 泛型高级应用：泛型限定 #

> ? 通配符。也可以理解为占位符
> 
> 泛型的限定：
> 
> ？ extends E: 可以接收E类型或者E的子类型。上限。  
> ？ super E: 可以接收E类型或者E的父类型。下限

class Person
    {
      private String name;
      Person(String name)
      {
        this.name=name;
      }
      public String getName()
      {
        return name;
      }
    }
    class Student extends Person
    {
      Student(String name)
      {
        super(name); //调用父类的构造函数
      }
    }
    
    public class Demo {
      public static void main(String[] args) {
        ArrayList<Student>a1=new ArrayList<Student>();
        a1.add(new Student("Student01"));
        a1.add(new Student("Student02"));
        a1.add(new Student("Student03"));
        ArrayList<Person>a2=new ArrayList<Person>();
        a2.add(new Person("Person01"));
        a2.add(new Person("Person02"));
        a2.add(new Person("Person03"));
        print(a1);
        print(a2);
      }
      public static void print(Collection<? extends Person> a) //泛型的限定；接收Person类和及其子类
      {
        Iterator<? extends Person> it=a.iterator();
        while(it.hasNext())
        {
          System.out.println(it.next().getName());
        }
      }
    }

![20200603222702138.png][]

定义Person类，以及子类Student和Worker，并对姓名进行排序。

class Person
    {
      private String name;
      Person(String name)
      {
        this.name = name;
      }
      public String getName()
      {
        return name;
      }
      public String toString()
      {
        return "person :"+name;
      }
    }
    class Student extends Person
    {
      Student(String name)
      {
        super(name);
      }
    }
    
    class Worker extends Person
    {
      Worker(String name)
      {
        super(name);
      }
    }
    //定义比较器实现接口，用于对姓名进行排序
    class Comp implements Comparator<Person>
    {
    public int compare(Person p1,Person p2)
        {
          //String类中的compareTo方法是比较两个字符串中每个字符的Unicode值
          //此处进行升序进行排序，如果倒序则交换p1与p2
          return p1.getName().compareTo(p2.getName());
        }
    }
    public class Demo {
      public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<Student>(new Comp());
        ts.add(new Student("Student03"));
        ts.add(new Student("Student06"));
        ts.add(new Student("Student09"));
        ts.add(new Student("Student04"));
        Iterator<Student> it = ts.iterator();
        while(it.hasNext())
        {
          System.out.println(it.next().getName());
        }
        TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());
    
        ts1.add(new Worker("Worker04"));
        ts1.add(new Worker("Worker03"));
        ts1.add(new Worker("Worker06"));
        ts1.add(new Worker("Worker08"));
        Iterator<Worker> it1 = ts1.iterator();
    
        while(it1.hasNext())
        {
          System.out.println(it1.next().getName());
        }
      }
    }

![2020060322385664.png][]

[20200603174023533.png]: https://img-blog.csdnimg.cn/20200603174023533.png
[20200603180959175.png]: https://img-blog.csdnimg.cn/20200603180959175.png
[20200603212421187.png]: https://img-blog.csdnimg.cn/20200603212421187.png
[20200603212839115.png]: https://img-blog.csdnimg.cn/20200603212839115.png
[20200603214916743.png]: https://img-blog.csdnimg.cn/20200603214916743.png
[20200603222702138.png]: https://img-blog.csdnimg.cn/20200603222702138.png
[2020060322385664.png]: https://img-blog.csdnimg.cn/2020060322385664.png