java泛型略解

泛型概念

泛型的本质是参数化类型，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

一、泛型定义格式：

• <类型>：指定一种类型的格式。这里的类型可以看成是形参

• <类型1，类型2...>:指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参

• 将来具体调用时给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

二、泛型的好处：

• 把运行时期的问题提前到了编译期间

• 避免了强制类型转换

  import java.util.*;
  public class map {
      public static void main(String[] args)
      {
          //创建集合对象
          //Collection c = new ArrayList();
          Collection<String> c = new ArrayList<String>();
          c.add("hello");
          c.add("world");
          c.add("java");
          //c.add(100);试试？
          //遍历集合
          //Iterator it = c.iterator();
          Iterator<String> it = c.iterator();
          while(it.hasNext()){
              //Object obj = it.next();
              //System.out.println(obj);
              //String s = (String)it.next();//ClassCastException
              String s = it.next();
              System.out.println(s);
          }
      }
      }

三、泛型类

泛型类定义格式：

• 格式：修饰符class类名<类型>{}

• 范例：public class Generic<T>{}

  • 此处的T可以随便写为任意表示，常见的入T、E、K、V等形式的参数常用于表示泛型

  public class Generic<T> {
      private T t;
  ​
      public T getT() {
          return t;
      }
  ​
      public void setT(T t) {
          this.t = t;
      }
  }

  public class map {
      public static void main(String[] args)
      {
     Generic<String> g1 = new Generic<String>();
     g1.setT("xiaoming");
     System.out.println(g1.getT());
  ​
     Generic<Integer> g2 = new Generic<Integer>();
     g2.setT(30);
     System.out.println(g2.getT());
  ​
     Generic<Boolean> g3 = new Generic<Boolean>();
     g3.setT(true);
     System.out.println(g3.getT());
          }
      }

  四、泛型方法

  泛型方法定义格式：

  • 格式：修饰符 <类型> 返回值类型 方法名（类型 变量名）{ }

  • 范例：public <T> void show(T t){ }

    public class Generic {
       public <T> void show(T t){
           System.out.println(t);
       }
    }
    public class map {
        public static void main(String[] args)
        {
      Generic g = new Generic();
      g.show("xiaoming");
      g.show(30);
      g.show(true);
      g.show(12.21);
            }
        }

  五、泛型接口

  泛型接口的定义格式：

  • 格式：修饰符 interface 接口名<类型>{}

  • 范例：public interface Generic<T>{}

  public interface Generic<T> {//泛型接口定义
      void show(T t);
  }

  public class Genericlmpl<T> implements Generic<T>{//接口的实现类
      @Override
      public void show(T t) {
          System.out.println(t);
      }
  }

  public class map {
      public static void main(String[] args)
      {
    Generic<String> g = new Genericlmpl<String>();
    g.show("xiaoming");
          }
      }

  /*以下两部分建议自寻视频观看*/

  六、类型通配符

  为了表示各种泛型List的父类，可以使用类型通配符

  • 类型通配符：<？>

  • List<?>：表示元素类型位置的List，它的元素可以匹配任何的类型

  • 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

  如果我们不希望List<？>是任何泛型List的父类，只希望它代表某一类泛型LIst的父类，可以使用类型通配符的上限

  • 类型通配符上限：<？extends 类型>

  • List<? extends Number>：它表示的类型是Number或者其子类型

  除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

  • 类型通配符的下限：<? super 类型>

  • List<? super Number>：它表示的类型是Number或者父类型

  七、可变参数的使用

  Arrays工具类中有一个静态方法：

  • public static <T> List <T> asList<T...a>：返回由指定数组支持的固定大小的列表

  • 返回的集合不能做增删操作，可以做修改操作

  List接口中有一个静态方法

  • public static <E> List <E> of(E... elements) :返回包含任意数量元素的不可变列表

  • 返回的集合不能做增删改操作

  Set接口中有一个静态方法

  • public static <E>Set <E> of(E... elements) ：返回一个包含任意数量元素的不可变集合

  • 在给元素的时候，不能给重复的元素

  • 返回的集合不能做在增删操作，没有修改的方法