关于泛型:Java中泛型的基本介绍深入解析泛型的使用方式

泛型: 参数化类型
- 参数:
  - 定义方法时无形参
  - 调用办法时传递实参
- 参数化类型: 将类型由原来的具体的类型参数化, 相似办法中的变量参数
  - 类型定义成参数模式, 能够称为 类型形参
  - 在应用或者调用时传入具体的类型, 能够称为 类型实参
泛型的实质是为了参数化类型
- 在不创立新的类型的状况下, 通过泛型指定的不同类型来管制形参具体限度的类型
- 在泛型应用过程中, 操作的数据类型被指定为一个参数, 这种参数类型能够用在:
  - 类 – 泛型类
  - 接口 – 泛型接口
  - 办法 – 泛型办法

泛型示例:

List arrayList = new ArrayList();
arrayList.add("aaaa");
arrayList.add(100);
 
arrayList.forEach(i -> {String item = (String) arrayList.get(i);
 Log.d("泛型", "item =" + item);
});
这样的写法会导致程序出现异常解体完结:
  java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
这里的 ArrayList 能够寄存任意类型, 增加了一个 String 类型, 增加了一个 Integer 类型, 再应用时都以 String 的形式应用, 因而程序解体

泛型就是解决这样的问题
再探讨另一种状况, 如果将第一行申明初始的代码批改一下, 那么在编译阶段就能发现问题:
List arrayList = new ArrayList<String>();
arrayList.add("aaaa");
arrayList.add(100); // 这一步在编译阶段, 编译器就会报错
 
 arrayList.forEach(i -> {String item = (String) arrayList.get(i);
   Log.d("泛型", "item =" + item);
 });

泛型只在编译阶段无效:
```
List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if (classStringArrayList.equals(classIntegerArrayList)) {Log.d("泛型", "类型雷同");
}
```
能够发现, 在编译过后, 程序会采取 去泛型化 措施. 也就是说,Java 中的泛型, 只在编译阶段无效. 在编译过程中,正确测验泛型后果后, 会将泛型的相干信息擦除, 并且在对象进入和来到办法的边界处增加类型检查和类型转换办法
泛型类型在逻辑上能够看成多个不同的类型, 实际上都是雷同的根本类型

泛型的应用
泛型有三种应用形式:
- 泛型类
- 泛型接口
- 泛型办法
  
  泛型类
泛型类: 泛型类型用于类定义中
- 通过泛型类能够实现对一组类的操作对外开发雷同的接口
- 最典型的就是各种容器类:
  - List
  - Set
  - Map

泛型类的最根本写法:

class 类名称 < 泛型标识: 标识号, 标识指定的泛型的类型 > {private 泛型标识 成员变量类型 成员变量名;}

示例:

/*
 * 这里的 T 能够为任意标识, 通常应用 T,E,K,V 等模式的参数示意泛型
 * 在实例化泛型时, 必须指定 T 的具体类型
 */
 public class Generic<T> {
   // key 这个成员变量的类型为 T,T 的类型由内部指定
   private T key;
  
  // 泛型构造方法形参 key 的类型也为 T,T 的类型由内部指定
  public Generic(T key) {this.key = key;}

  // 泛型构造方法 getKey 的返回值类型为 T,T 的类型由内部指定
  public T getKey() {}
 }

/*
 * 泛型的类型参数只能够是类类型, 包含自定义类. 不能是简略类型
 */
 // 传入的实参类型须要与泛型类型的参数类型雷同, 即 Integer
 Generic<Integer> genericInteger = new Generic<Integer>(123456);
 // 传入的实参类型须要与泛型类型的参数类型雷同, 即 String
 Generic<String> genericString = new Generic<String>("key_value");

 Log.d("泛型测试", "key is" + genericInteger.getKey());
 Log.d("泛型测试", "key is" + genericString.getKey());

泛型测试: key is 123456
泛型测试: key is key_value

泛型类中不肯定要传入泛型类型的实参:

如果传入泛型实参, 会依据传入的泛型实参做相应的限度, 此时泛型才会起到本应起到的限度作用

如果不传如泛型类型的实参, 在泛型类中应用泛型的办法或者成员变量的定义能够为任何类型

Generic genericString = new Generic("1111");
Generic genericInteger = new Generic(5555);
Generic genericBigDecimal = new Generic(66.66);
Generic genericBoolean = new Generic(true);

Log.d("泛型测试", "key is" + genericString.getKey());
Log.d("泛型测试", "key is" + genericInteger.getKey());
Log.d("泛型测试", "key is" + genericBigDecimal.getKey());
Log.d("泛型测试", "key is" + genericBoolean.getKey());

D/ 泛型测试: key is 1111
D/ 泛型测试: key is 5555
D/ 泛型测试: key is 66.66
D/ 泛型测试: key is true

泛型的类型参数只能是类类型, 不能是简略类型
不能对确切的泛型类型应用 instanceof 操作, 编译时会出错

泛型接口
泛型接口与泛型类的定义及应用基本相同
泛型接口经常被用在各种类的生产器中

示例:

// 定义一个泛型接口
public interface Generator<T> {public T next();
}

当实现泛型接口的类, 未传入泛型实参时:

/**
 * 未传入泛型实参时, 与泛型类的定义雷同, 在申明类的时候, 需将泛型的申明也一起加到类中:
 *         即 class FruitGenerator<T> implements Generator<T> {}
 *         如果不申明泛型, 比方: class FruitGenerator implements Generator<T>. 此时编译器会报错 - Unknown class
 */
 class FruitGenerator<T> implements Generator<T> {
   @Override
   public T next() {return null;}
 }

当实现泛型接口的类, 传入泛型实参时:

/**
 * 传入泛型实参时:
 *         定义一个生产器实现这个接口
 *         只管只创立了一个泛型接口 Generator<T>, 然而能够为 T 传入无数个实参, 造成无数种类型的 Generator 接口
 *         在实现类实现泛型接口时, 如果曾经将泛型类型传入实参类型, 则所有应用泛型的中央波动替换成传入的实参类型
 *             即: Generator<T>, public T next(); 这里的 T 都要替换成传入的 String 类型
 */
 public class FruitGenerator implements Generator<String> {private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

  @Override
  public String next() {Random rand = new Random();
      return fruits[rand.nextInt(3)];
  }
 }

Integer是 number 的一个子类 ,Generic< Integer > 与Generic< number > 实际上是雷同的一种类型

由此, 产生如下问题:

在应用Generic< number > 作为形参的办法中, 是否应用Generic< Integer > 的实例传入?

在逻辑上相似于 Generic< number > 和 Generic< Integer > 是否能够看成是具备父子关系的泛型类型呢?

Generic< T > 泛型类示例:

public void showKeyValue1(Generic<Number> obj) {Log.d("泛型测试", "key value is" + obj.getKey());
}

Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);

showKeyValue(gNumber);

showKeyValue 这个办法编译器会报错:
  Generic<java.lang.Integer> cannot be applied to Generic<java.lang.Number> showKeyValue(gInteger);

由此能够看到 Generic< Integer > 不能看作是 Generic< Number > 的子类.

由此可见:
- 同一种泛型能够对应多个版本, 因为参数类型是不确定的
- 不同版本的泛型类型实例是不兼容的
为了解决这样的问题, 又不能为了定义一个新的办法来解决 Generic< Integer >, 这与 Java 中多态的理念违反. 因而, 须要一个在逻辑上能够示意同时是 Generic< Integer > 和 Generic< Number > 父类的援用类型. 这样的类型就是类型通配符:

应用通配符示意泛型:

public void showKeyValueWildcard(Generic<?> obj) {Log.d("泛型测试", "key value is" + obj.getKey());
}

类型通配符个别应用 ? 代替具体的类型实参:
- 此处的 ? 是 类型实参, 而不是类型形参.
- 和 Number,String,Integer 一样, 都是一种理论的类型
- 能够把 ? 看作是所有类型的父类, 是一种实在的类型
类型通配符的应用场景:
- 当具体类型不确定的时候, 这个通配符就是 ?
- 当操作类型时, 不须要应用类型的具体性能, 只应用 Object 类中的性能, 那么能够应用 ? 通配符来示意未知的类型
  
  泛型办法
泛型类: 在实例化类的时候指明泛型的具体类型

泛型办法: 在调用办法的时候指明泛型的具体类型

/**
 * 泛型办法:
 *         1. public 和 返回值两头的 <T> 十分重要, 能够了解为申明此办法为泛型办法
 *         2. 只有申明了 <T> 的办法才是泛型办法, 泛型类中的应用了泛型的成员办法并不是泛型办法
 *         3. <T> 示意该办法将应用泛型类型 T, 此时才能够在办法中应用泛型类型 T
 *         4. 与泛型类的定义一样, 此处的 T 能够为任意标识, 常见的比方: T, E, K, V 等模式的参数罕用于示意泛型
 * 
 * @param tClass 传入的泛型实参
 * @return T 返回值为 T 类型
 */
 public <T> T genericMethod(Class<T> tClass) throws InstanttiationException, IllegalAccessException {T instance = tClass.newInstance();
   return instance;
 }

Object obj = genericMethod(Class.forName("com.oxford.test"));

泛型办法的根本用法

泛型办法应用示例:

public class GenericTest {
  /* 
   * 上面这个类是一个泛型类
   */
   public class Generic<T> {
       private T key;

      public Generic(T key) {this.key = key;}

      /*
       * 这个办法尽管在办法应用了泛型, 然而这不是一个泛型办法
       * 这只是类中一个一般的成员办法, 只不过返回值是在申明泛型类曾经申明过的泛型
       * 所以在这个办法中才能够持续应用 T 这个泛型
       */
       public T getKey() {return key;}

      /*
       * 上面的这个办法显然是有问题的, 在编译器中就会提醒谬误 "cannot resolve symbol E"
       * 因为在类的申明中并未申明泛型 E, 所以在应用 E 做形参和返回值类型时, 编译器会无奈辨认
       *  
       * public E setKey(E key) {
       *     this.key = key
       * }
       */
   } 
    
   /*
    * 上面这个办法是一个泛型办法:
    *     首先在 public 与返回值之间的 <T> 必不可少, 这个表明这是一个泛型办法, 并且申明了一个泛型 T
    *     这个 T 能够呈现在这个泛型办法的任意地位
    *     泛型的数量也能够为任意多个
    */
    public <T> T showKeyName(Generic<T> container) {System.out.println("container key:" + container.getKey());
        T test = container.getKey();
        return test;
    }
    
    /*
     * 上面这个办法也不是一个泛型办法
     * 这就是一个一般的办法, 只是应用了 Generic<Number> 这个泛型类做形参
     */
     public void showKeyValue1(Generic<Number> obj) {Log.d("泛型测试", "key value is" + obj.getKey());
     }

    /*
     * 上面这个办法也不是一个泛型办法
     * 这也是一个一般办法, 只是应用了泛型通配符 ?
     * 从这里能够验证: 泛型通配符 ? 是一种类型实参, 能够看作是所有类的父类
     */
     public void showKeyValue2(Generic<?> obj) {Log.d("泛型测试", "key value is" + obj.getKey());
     }

    /*
     * 上面这个办法是有问题的, 在编译器中就会提醒错误信息:"Unknown class'E'"
     *     尽管申明了 <T>, 也表明这是一个能够解决泛型类型的泛型办法
     *     然而只申明了泛型类型 T, 并未申明泛型类型 E, 因而编译器不晓得如何解决 E 这个类型
     * 
     * public <T> T showKeyName(Generic<E> container) {
     *     ...
     * }
     */    

    /*
     * 上面这个办法也是有问题的, 在编译器中就会提醒错误信息:"Unknown class'T'"
     *     对于编译器来说 T 这个类型并未在我的项目中申明过, 因而编译器也不晓得该如何编译这个类
     *     所以这也不是一个正确的泛型办法申明
     *  
     * public void showKey(T genericObj) {
     *     ...
     * }
     */

      public void main(String[] args) {}}

类中的泛型办法

泛型办法能够呈现在任何中央任何场景中进行应用

然而, 当泛型办法呈现在泛型类中时, 状况比拟非凡:

public class GenericFruit {
  class Fruit {
      @Override
      public String toString() {return "fruit";}
  }

  class Apple extends Fruit {
      @Override
      public String toString() {retrun "apple";}
  }

  class Person {
      @Override
      public String toString() {return "Person";}
  }

  class GenerateTest<T> {public void show_1(T t) {System.out.println(t.toString());
      }

      /*
       * 在泛型类中申明一个泛型办法, 应用泛型 T
       * 留神这个 T 是一种全新的类型, 能够与泛型类中申明的 T 不是同一个类型
       */
       public <T> void show_2(T t) {System.out.println(t.toString());
       }
       
      /* 
       * 在泛型类中申明一个泛型办法, 应用泛型 E. 这种泛型 E 能够为任意类型, 能够与类型 T 雷同
       * 因为泛型办法在申明的时候会申明泛型 <E>, 因而即便在泛型类中并未申明泛型, 编译器也可能正确辨认泛型办法中辨认的泛型
       */
       public <E> void show_3(E t) {System.out.println(t.toString());
       }    
  } 

  public void main(String[] args) {Apple apple = new Apple();
      Person person = new Person();

      GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
      // apple 是 Fruit 的子类, 所以这里能够
      generateTest.show_1(apple);

      /* 
       * 编译器会报错, 因为泛型类型实参指定的是 Fruit, 而传入的实参类是 Person
       *  
       * generateTest.show_1(person);
       */

      /*
       * 应用两个参数都能胜利
       */
       generateTest.show_2(apple);
       generateTest.show_2(person);

      /*
       * 应用两个参数也都能胜利
       */
       generateTest.show_3(apple);
       generateTest.show_3(person);
  }
}

泛型办法与可变参数

泛型办法与可变参数:

public <T> void printMsg(T... args) {for (T t : args) {Log.d("泛型测试", "t is" + t);
  }
}

静态方法与泛型

留神在类中的静态方法应用泛型:
- 静态方法无法访问类上定义的泛型
- 如果静态方法操作的援用数据类型不确定的时候, 必须要将泛型定义在办法上

如果静态方法要应用泛型的话, 必须将静态方法定义成泛型办法:

public class StaticGenerator<T> {
  ...
  ...
  /*
   * 如果在类中定义应用泛型的静态方法, 须要增加额定的泛型申明 - 将这个办法定义成泛型办法
   * 否则会报错: StaticGenerator cannot be refrenced from static context
   */
   public static <T> void show(T t) {}}

泛型办法总结

泛型办法能使办法独立于类而产生变动, 应用准则:
- 无论何时, 如果能做到, 就尽量应用泛型办法
- 如果应用泛型办法将整个类泛型话, 就应该应用泛型办法
- 对于一个 static 办法, 无法访问泛型类型的参数. 如果 static 办法要应用泛型, 就必须使之成为泛型办法
  
  泛型的高低边界
在应用泛型的时候, 能够为传入的泛型类型实参进行高低边界的限度:
- 比方: 类型的实参只准传入某种类型的父类或者某种类型的子类

为泛型办法增加上边界, 即传入的类型实参必须是指定类型的子类型:

public void showKeyValue1(Generic<? extends Number> obj) {Log.d("泛型测试", "key value is" + obj.getKey());
}

Generic<String> generic1 = new Generic<String>("11111");
Generic<Integer> generic2 = new Generic<Integer>(2222);
Generic<Float> generic3 = new Generic<Float>(2.4f);
Generic<Double> generic4 = new Generic<Double>(2.56);

/*
 * 这一行在编译的时候就会报错, 因为 String 类型并不是 Number 类型的子类
 *  
 * showKeyValue1(generic1);
 */
 showKeyValue2(generic2);
 showKeyValue3(generic3);
 showKeyValue4(generic4);

为泛型类增加上边界, 即类中泛型必须是指定类型的子类型:

public class Generic<T extends Number> {
  private T key;

  public Generic(T key) {this.key = key;}

  public T getKey() {return key;}
}

/*
 * 这一行代码在编译的时候会报错, 因为 String 的类型不是 Number 的子类
 */
 Generic<String> generic1 = new Generic<String>("1111");

在泛型办法中增加高低边界限度时, 必须在权限申明与返回值之间的 < T > 上增加高低边界:

/*
 * 如果应用:
 *         public <T> showKeyName(Generic<T extends Number> container);
 * 编译器会报错.
 */
 public <T extends Number> T showKeyName(Generic<T> container) {System.out.println("container key:" + container.getKey());
   T test = container.getKey();
   return test;
 }

从下面能够看出 : 泛型的高低边界增加, 必须与泛型的申明在一起

泛型数组

在 Java 中, 不能创立一个确切的泛型类型的数组

/*
 * 这个数组创立的形式是不容许的
 * List<String>[] ls = new ArrayList<String>[10];
 */
 
 // 应用通配符创立泛型数组是能够的
 List<?>[] ls = new ArrayList<?>[10];

 // 上面的这个办法也是能够的
 List<String> ls = new ArrayList[10];

示例:
```
List<String>[] lsa = new List<String>[10]; // 不容许这样定义
Object o = lsa;
Object[] oa = (Object) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3)); 
oa[1] = li; // 不倡议这样应用, 然而能够通过运行时查看
String s = lsa[1].get(0); // 运行时报错, 类型转换异样
```
- 因为 JVM 的擦除机制, 在运行时 JVM 是不晓得泛型信息的:
  - 所有能够给 oa[1] 赋值一个ArrayList 却不会出现异常
  - 然而在取出数据的时候要做一次类型转换, 就会呈现ClassCastException
  - 如果能够进行泛型数组的申明, 那么下面的这种状况在编译期将不会呈现任何正告和谬误, 只有在运行时才会报错
- 通过对泛型数组的申明进行限度, 对于这样的状况, 能够在编译期提醒代码有类型平安问题

数组的类型不能够是类型变量, 除非是采纳通配符的形式: 因为对于通配符的形式, 最初取出数据是要做显式的类型转换的

List<?>[] lsa= new List<?>[10]; // 能够这样定义为泛型数组
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li; // 能够这样赋值
Integer i = (Integer) lsa[1].get(0); // 能够这样取出数据

关于泛型:Java中泛型的基本介绍深入解析泛型的使用方式

泛型的基本概念

泛型的应用

泛型类

泛型接口

泛型通配符

泛型办法

泛型办法的根本用法

类中的泛型办法

泛型办法与可变参数

静态方法与泛型

泛型办法总结

泛型的高低边界

泛型数组

Just My Socks（注册教程内含优惠码）

关于泛型:Java中泛型的基本介绍深入解析泛型的使用方式

泛型的基本概念

泛型的应用

泛型类

泛型接口

泛型通配符

泛型办法

泛型办法的根本用法

类中的泛型办法

泛型办法与可变参数

静态方法与泛型

泛型办法总结

泛型的高低边界

泛型数组

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）