Java培训课程SE进阶之自定义泛型

泛型字母

形式类型参数(formal type parameters)即泛型字母

命名:泛型字母可以随意指定,尽量使用单个的大写字母(有时候多个泛型类型时会加上数字,比如T1,T2)

常见字母(见名知意)

  • T:Type
  • K V:Key Value
  • E:Element

1  泛型声明形式之一:泛型类、接口

需求:定义学生类,其中有学生成绩

  • 整数
  • 小数
  • 字符串“优秀、良好、合格、不及格”

class Student<T>{

     private String name;

     private T score;

 

     public Student() {

          super();

     }

     public Student(String name, T score) {

          super();

          this.name = name;

          this.score = score;

     }

     public String getName() {

          return name;

     }

     public void setName(String name) {

          this.name = name;

     }

     public T getScore() {

          return score;

     }

     public void setScore(T score) {

          this.score = score;

     }

     @Override

     public String toString() {

          return “姓名:” + name + “, 成绩:” + score;

     }

}

 

public class TestStudentScore {

 

     public static void main(String[] args) {

          Student<Integer> s1 = new Student<Integer>(“张三”,89);

          Integer score = s1.getScore();

 

          Student<Integer> s2 = new Student<Integer>();

//        s2.setScore(“优秀”);

          s2.setScore(99);

     }

}

声明时的要点

  • 在类/接口上声明的泛型,在本类或本接口中即代表某种类型,可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型
  • 在类/接口上声明的泛型不能使用在静态成员上

泛型类的构造器如下:public GenericClass(){}。

而如下是错误的:public GenericClass<E>(){}

  • 泛型类在声明时还可以指定泛型的上限

package com.atguigu.generic.classtype;

 

public class TestPerson {

 

     public static void main(String[] args) {

//        Person<Dog> p = new Person<Dog>();

//        Person<Object> = new Person<Object>();

     }

 

}

/*class Human<T super Person>{

 

}*/

class Person<T extends Person>{

     private T parnter;//伴侣

}

 

class Man extends Person<Woman>{

 

}

class Woman extends Person<Man>{

 

}

class Dog{

 

}

指定时的要点

当类或接口被使用时,会使用具体的实际类型参数(actual type argument)代替

  • 泛型的指定中不能使用基本数据类型,可以使用包装类替换
  • 泛型如果不指定,将被擦除,泛型对应的类型均按照Object处理,但不等价于Object

 

例如:

(1)ArrayList<String> list = new ArrayList<String>();   声明集合变量或创建集合对象,指定泛型

(2)class Dog implements Comparable<Dog>{…}   实现接口时,指定泛型

(3)public void test(ArrayList<Student> list){}      使用泛型类或接口作为形参时,此处指定为学生类型

(4)public void test(ArrayList<?> list){}            使用泛型类或接口作为形参时,此处指定为任意类型

(5)public void test(ArrayList<? extends Person>  使用泛型类或接口作为形参时,此处指定为Person或其子类

(6)public void test(ArrayList<? super Son>      使用泛型类或接口作为形参时,此处指定为Son或其父类

关于泛型类/接口的继承/实现说明

父类有泛型,子类可以选择保留泛型也可以选择指定泛型类型:

  • 子类不保留父类的泛型:按需实现
  • 没有类型 擦除
  • 具体类型
  • 子类保留父类的泛型:泛型子类
  • 全部保留
  • 部分保留

结论:子类必须是“富二代”,子类除了指定或保留父类的泛型,还可以增加自己的泛型

class Father<T1,T2>{

 

}

//子类不保留父类的泛型

//1)没有类型  擦除

class Son extends Father{//等价于class Son extends Father<Object,Object>{

 

}

//2)具体类型

class Son2 extends Father<Integer,String>{

 

}

//子类保留父类的泛型

//1)全部保留

class Son3<T1,T2> extends Father<T1,T2>{

 

}

//2)部分保留

class Son4<T2> extends Father<Integer,T2>{

 

}

class Father<T1,T2>{

 

}

//子类不保留父类的泛型

//1)没有类型  擦除

class Son<A,B> extends Father{//等价于class Son extends Father<Object,Object>{

 

}

//2)具体类型

class Son2<A,B> extends Father<Integer,String>{

 

}

//子类保留父类的泛型

//1)全部保留

class Son3<T1,T2,A,B> extends Father<T1,T2>{

 

}

//2)部分保留

class Son4<T2,A,B> extends Father<Integer,T2>{

 

}

具体示例代码

class Dog implements Comparable{

 

     @Override

     public int compareTo(Object o) {

          return 0;

     }

 

}

class Cat implements Comparable<Cat>{

 

     @Override

     public int compareTo(Cat o) {

          return 0;

     }

 

}

class MySet<E> implements Collection<E>{

 

    @Override

    public boolean add(E e) {

         return false;

    }

……  

}

关于泛型的擦除说明

使用泛型类时未指定泛型的具体类型:类似于Object,不等同于Object

  • 泛型擦除,默认按照Object处理但编译不会类型检查
  • 明确指定Object,编译会按Object类型检查

public class TestGenericErasure {

      public static void main(String[] args) {

            //1、使用时:类似于Object,不等同于Object

            ArrayList list = new ArrayList();

//          list.add(new Date());//有风险

            list.add(“hello”);

 

            test(list);//泛型擦除,编译不会类型检查

 

//          ArrayList<Object> list2 = new ArrayList<Object>();

//          test(list2);//一旦指定Object,编译会类型检查,必须按照Object处理

      }

 

      public static void test(ArrayList<String> list){

            String str = “”;

            for(String s:list){

                  str += s + “,”;

            }

            System.out.println(“元素:”+str);

      }

}

 

12.2.2 泛型形式之二:泛型方法

  • 如果某个类不是泛型类,而某个方法需要使用泛型
  • 如果某个类是泛型类,但是需要在静态方法上使用泛型

泛型方法的格式:

[访问权限]  <泛型字母>  返回类型  方法名([泛型字母 参数名称])  抛出的异常

package com.atguigu.generic.method;

 

import java.util.List;

 

public class TestMyArrays {

 

     public static void main(String[] args) {

          Integer[] arr = {1,2,3,4};

          String str = MyArrays.toString(arr);

          System.out.println(str);

     }

}

class MyArrays{

     public static <T> String toString(T[] arr){

          String str = “[“;

          int i = 0;

          for (T t : arr) {

               str += t;

               if(i!=arr.length-1){

                    str += “,”;

               }

               i++;

          }

          str += “]”;

          return str;

     }

}

示例:java.util.Arrays类

  • public static <T> List<T> asList(T… a)

注意:Arrays.asList(…) 方法返回的 List 集合既不是 ArrayList 实例,也不是 Vector 实例。 Arrays.asList(…)  返回值是一个固定长度的 List 集合

  • public static <T> T[] copyOf(T[] original, int newLength)
  • public static <T> T[] copyOfRange(T[] original, int from,int to)

     public static void main(String[] args) {

          //public static <T> List<T> asList(T… a)

          List<String> list = Arrays.asList(“hello”,”world”,”java”);

          List<Integer> list2 = Arrays.asList(1,2,3);

 

          //public static <T> T[] copyOf(T[] original, int newLength)

          String[] str = {“hello”,”world”,”java”};

          String[] array = Arrays.copyOf(str, 10);

 

          //public static <T> T[] copyOfRange(T[] original, int from,int to)

          String[] as = Arrays.copyOfRange(array, 0, 3);

          System.out.println(Arrays.toString(str));

          System.out.println(Arrays.toString(array));

          System.out.println(Arrays.toString(as));

     }

 

注意:

  • 泛型方法可以是静态方法也可以是非静态方法
  • 泛型方法声明泛型时也可以指定上限

package com.atguigu.generic.method;

 

import java.util.ArrayList;

import java.util.List;

 

public class TestMyArrays {

 

      public static void main(String[] args) {

            List<Integer> list = new ArrayList<Integer>();

            list.add(2);

            list.add(3);

            list.add(4);

            list.add(5);

            list.add(1);

            MyArrays.sort(list);

 

            for (Integer integer : list) {

                  System.out.println(integer);

            }

      }

 

}

class MyArrays{

      public static <T extends Comparable<T>> void sort(List<T> list){

            for(int i=0; i<list.size()-1; i++){

                  for(int j=0; j<list.size()-i-1; j++){

                       Comparable<T> c1 = (Comparable<T>)list.get(j);

                       if(c1.compareTo(list.get(j+1))<0){

                             T temp = list.get(j);

                             list.set(j, list.get(j+1));

                             list.set(j+1, temp);

                       }

                  }

            }

      }

}

 

     public static void main(String[] args) {

/*        test(new String());

          test(new Object());*/

          test(new Person());

          test(new Man());

     }

 

     public static <T extends Person> void test(T t){

          System.out.println(t);

     }

 

     /*public static <T super Person> void test(T t){

          //错误

     }*/

 

}

class Person{

 

}

class Man extends Person{

 

}

     public static <T extends Closeable> void free(T… t){

          for(T c : t){

               try {

                    if(c!=null){

                         c.close();

                    }

               } catch (IOException e) {

                    e.printStackTrace();

               }

          }

     }


上一篇:
下一篇:
关于尚硅谷
教育理念
名师团队
学员心声
资源下载
视频下载
资料下载
工具下载
加入我们
招聘岗位
岗位介绍
招贤纳师
联系我们
电话:010-56253825
邮箱:info@atguigu.com
地址:北京市昌平区宏福科技园综合楼6层(北京校区)

 深圳市宝安区西部硅谷大厦B座C区一层(深圳校区)

上海市松江区谷阳北路166号大江商厦6层(上海校区)