泛型&通配符

泛型&通配符


一、泛型介绍&理解

1.1 泛型概述&使用(集合/比较器)

泛型:类似于场景中的标签,即为类型参数,在声明它的类、接口或方法中,代表未知的某种通用类型。
比如使用集合存储数据时,除了元素的类型不确定,其他部分是确定的(例如关于这个元素如何保存,如何管理等)。
JDK1.5设计了泛型的概念,例如:JDK5.0改写了集合框架中的全部接口和类、java.lang.Comparable接口、java.util.Comparator接口、Class类等。为这些接口、类增加了泛型支持,从而可以在声明变量、创建对象时传入类型实参。

简单示例:不确定的类型用T来表示,如果不指定的话,可传入任意类型的

public class Teacher<T> {
    T name;
    int add(T num){
        return 0;
    }
}
//测试:不指定具体类型,缺点:会出现类型转换异常等等
@Test
public void test1(){
     Teacher tea = new Teacher();
     tea.name = 1;//可以是任意类型的
     tea.name ="23";
 }
 //测试:指定具体类型,此时所有T代表的类型参数全部替换为类型String
@Test
public void test2(){
     Teacher<String> tea = new Teacher<>();
     //tea.name = 1;//报错
     tea.name ="23";
 }

1.什么是泛型?
即类型参数,允许在定义类、接口、方法时通过一个标识表示类中某个属性的类型、某个方法的返回值或参数的类型
这个类型参数将在使用时(例如,继承或实现这个接口、创建对象或调用方法时)确定(即传入实际的类型参数,也称为类型实参)。

2、使用泛型之前可能存在的问题

  • 在集合中
    • 问题1:类型不安全,因为add()的参数是0bject类型,意味着任何类型的对象都可以添加成功
    • 问题2:需要使用强转操作,繁琐。还有可能导致ClassCastException异常。
  • 在比较器中
    • 不能确定是什么类型的对象比较大小,需要判断是否是该类型的实例、类型转换等操作,用了泛型之后,他就只能接受指定类型的对象

3、使用泛型的好处:以集合为例:把一个集合中的内容限制为一个特定的数据类型,这就是generic背后的核心思想。
Java泛型可以保证如果程序在编译时没有发出警告,运行时就不会产生ClassCastException异常。即,把不安全的因素在编译期间就排除了,而不是运行期;既然通过了编译,那么类型一定是符合要求的,就避免了类型转换。
比较器的泛型实现示例
集合使用泛型前后的对比

集合使用泛型示例:ArrayList,注意可以用类型推断
实现功能:使用集合的removeIf方法删除偶数,为Predicate接口指定泛型<Ineteger>

public class TestNumber {
    public static void main(String[] args) {
        ArrayList<Integer> coll = new ArrayList<Integer>();
        Random random = new Random();
        for (int i = 1; i <= 5 ; i++) {
            coll.add(random.nextInt(100));
        }
        System.out.println("coll中5个随机数是:");
        for (Integer integer : coll) {
            System.out.println(integer);
        }
        //方式1:使用集合的removeIf方法删除偶数
        coll.removeIf(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) {
                return integer % 2 == 0;
            }
        });
        //方式2:调用Iterator接口的remove()方法
        //Iterator<Integer> iterator1 = coll.iterator();
        //while(coll.hasNext()){
        //    Integer i = coll.next();
        //   if(i % 2 == 0){
        //       coll.remove();
        //    }
        //}

        System.out.println("coll中删除偶数后:");
        Iterator<Integer> iterator = coll.iterator();
        while(iterator.hasNext()){
            Integer number = iterator.next();
            System.out.println(number);
        }
    }
}

集合使用泛型示例:HashMap,注意可以用类型推断

//泛型在Map中的使用
@Test
public void test2(){
	//HashMap<String,Integer> map = new HashMap<String,Integer>();
    HashMap<String,Integer> map = new HashMap<>();//使用类型推断
    map.put("Tom",67);
    map.put("Jim",56);
    map.put("Rose",88);
    //编译不通过
    //ap.put(67,"Jack");

    //遍历key集
    Set<String> keySet = map.keySet();
    for(String str:keySet){
        System.out.println(str);
    }

    //遍历value集
    //var values = map.values();//可以使用类型推断
    Collection<Integer> values = map.values();
    Iterator<Integer> iterator = values.iterator();
    while(iterator.hasNext()){
        Integer value = iterator.next();
        System.out.println(value);
    }
    //遍历entry集
    Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
    Iterator<Map.Entry<String, Integer>> iterator1 = entrySet.iterator();
    while(iterator1.hasNext()){
        Map.Entry<String, Integer> entry = iterator1.next();
        String key = entry.getKey();
        Integer value = entry.getValue();
        System.out.println(key + ":" + value);
    }
}

Comparable接口使用泛型后

class CircleComparator1 implements Comparator<Circle> {//指定具体的泛型类型
    @Override
    public int compare(Circle o1, Circle o2) {
        //不再需要强制类型转换,代码更简洁
        return Double.compare(o1.getRadius(), o2.getRadius());
    }
}
//测试类
public class TestHasGeneric {
    public static void main(String[] args) {
        CircleComparator1 com = new CircleComparator1();
        System.out.println(com.compare(new Circle(1), new Circle(2)));//如果有错误,会在编译阶段就报错
        //System.out.println(com.compare("圆1", "圆2"));
        //编译错误,因为"圆1", "圆2"不是Circle类型,是String类型,编译器提前报错,
        //而不是冒着风险在运行时再报错。
    }
}

CompareTor构造器的定义方式:使用泛型实现,指定只接受某个类型的
只有比较的定义不一样,其它的部分都是一样的,这里以匿名内部类方式

//价格从小打到排序,价格一样,name从大到小排序
Comparator<Product> comp = new Comparator<Product>() {
    @Override
    public int compare(Product p1, Product p2) {
        int res = Double.compare(p1.price,p1.price);
        if(res != 0){
            return res;//从小到大排序
        }
        return -p1.name.compareTo(p2.name);//从大到小排序
    }
};

1.2 自定义范型结构(类/接口/方法)

1、<类型>这种语法形式就叫泛型。
<T>:称为类型参数,代表未知的数据类型,可以指定为<String>,<Integer>,<Circle>等。类比方法中形参将<T>称为类型形参,将<Circle>称为类型实参。T可以替换成K,V等任意字母

泛型类/接口的声明:在类名或接口名后面声明泛型类型,我们把这样的类或接口称为泛型类泛型接口
多个泛型参数声明:<E1,E2,E3>
JDK7.0 开始,泛型的简化操作:ArrayList<Fruit> flist = new ArrayList<>();

【修饰符】 class 类名<类型变量列表>extends 父类】 【implements 接口们】{
    
}
【修饰符】 interface 接口名<类型变量列表>implements 接口们】{
    
}
//例如:
public class ArrayList<E>    
public interface Map<K,V>{
    ....
}    

泛型方法声明格式:在【修饰符】与返回值类型之间声明类型变量。把声明了类型变量的方法,称为泛型方法。

[修饰符] <类型变量列表> 返回值类型 方法名([形参列表])[throws 异常列表]{
    //...
}
public class DAO {
    public <E> E get(int id, E e) {
        E result = null;
        return result;
    }
}

1、自定义泛型类或泛型接口、方法:

  • 泛型类或接口:在类或接口中定义某个成员时,该成员的相关类型是不确定的,而这个类型需要在使用这个类或接口时才可以确定
    • 在类的内部(比如:属性、方法、构造器中)使用类的泛型。其在本类或本接口中即代表某种类型
    • 创建自定义泛型类的对象时:
      • 可指明泛型参数类型。一旦指明,内部凡是使用类的泛型参数的位置,都具体化为指定的类的泛型类型。
      • 泛型擦除:如果没有指明泛型参数类型,那么泛型对应的类型均按照Object处理,但不等价于Object。
    • 指定泛型类型:只能是引用数据类型,如果是基本则可以使用包装类型代替
    • 如果泛型结构是一个接口或抽象类,则不可创建泛型类的对象。
    • 不可以在静态方法中使用类的泛型。
    • 异常类不能是带泛型的
    • 不能用new E[],但可E[] elements = (E[])new Object[capacity];参考ArrayList源码声明:Object[] elementData,而非泛型参数类型数组。
  • 泛型方法:在没有定义泛型类/接口时,但是某个方法形参类型不确定时,可以单独定义<泛型参数>。
    • 方法可以被泛型化,并且可以被声明为static的,与所在类是否泛型无关,其中的泛型参数在方法被调用时确定。

2、泛型类/接口继承的一些特性

  • 泛型类型的继承性:继承/实现泛型类/接口时,子类/接口可以确定泛型结构中的泛型参数。如果不确定泛型的类型,则可以继续使用泛型参数,还可以新增泛型参数。
  • 如果B是A的一个子类型(子类或者子接口),而G是具有泛型声明的类或接口,G<B>并不是G<A>的子类型!
    比如:String是Object的子类,但是List<String>并不是List<Object>的子类。

泛型继承的一些特性

class A<T>{
}
//1)没有类型 擦除
class B extends A{}
//子类:继承父类的泛型参数// 1)全部保留
class B extends A<T>{
}
//子类:指定父类的泛型参数类型 // 2)具体类型
class C extends A<Integer>{
}
//子类:在父类的基础上新增泛型参数
class D<E> extends A<Integer>{
}

泛型类/接口、方法的一些实现(及泛型方法的调用方式)

@Test
public void test8(){
	//T[] arr = new T[];//是错误的写法
	//T[] arr = (T[])new Object[6];
    Integer[] arr = new Integer[]{12,21,43,56};
    Integer[] arr1 = reverse(arr);
    for (int i = 0; i < arr1.length; i++) {
        System.out.println(arr1[i]);
    }

} //编写一个泛型方法,接收一个任意引用类型的数组,并反转数组中的所有元素
public <T> T[] reverse(T[] arr){
    for (int min = 0,max = arr.length-1; min <max; min++,max--) {
        T temp = arr[min];
        arr[min] = arr[max];
        arr[max] = temp;
    }
    return arr;
}

泛型类的使用场景:声明一个学生类,该学生包含姓名、成绩,而此时学生的成绩类型不确定,为什么呢,因为,语文老师希望成绩是“优秀”、“良好”、“及格”、“不及格”,数学老师希望成绩是89.5, 65.0,英语老师希望成绩是’A’,‘B’,‘C’,‘D’,‘E’。那么我们在设计这个学生类时,就可以使用泛型。

//省略了get/set方式
class Student<T>{
    String name;
    T score;

    public Student() {
        super();
    }
    public Student(String name, T score) {
        super();
        this.name = name;
        this.score = score;
    }
    @Override
    public String toString() {
        return "姓名:" + name + ", 成绩:" + score;
    }
}
public class TestStudent {
    public static void main(String[] args) {
        //语文老师使用时:
        Student<String> stu1 = new Student<String>("张三", "良好");

        //数学老师使用时:
        //Student<double> stu2 = new Student<double>("张三", 90.5);//错误,必须是引用数据类型
        Student<Double> stu2 = new Student<Double>("张三", 90.5);

        //英语老师使用时:
        Student<Character> stu3 = new Student<Character>("张三", 'C');

        //错误的指定
        //Student<Object> stu = new Student<String>();//错误的
    }
}

二、通配符&读写特点

1、通配符:?
注意:不能用在泛型方法声明上;不能用在泛型类的声明上;不能用在创建对象
2、通配符的使用:以ArrayList<?>为例 G\<?> 可以看做是G<A>类型的父类,G<?>引用/变量=G<A>对象

读写数据的特点(以集合ArrayList<?>为例说明)
读取数据:允许的,读取的值的类型为Object类型
写入数据:不允许的。特例写入null值。

4、有限制条件的通配符
List<? extends A>:理解"<=“(-∞,A],可以将List<A>或List<B>赋值给List<? extends A>。其中B类是A类的子类。
List<? super A>:理解”>="[A,+∞),可以将List<A>或List<B>赋值给List<?extends A>。其中B类是A类的父类。

读写数据的特点:技巧,开发中编译是否报错
? extends A:以集合为例:可以读取数据、不能写入数据(例外:null)
? super A:以集合为例:可以读取数据、可以写入A类型或A类型子类的数据(例外:null)

通配符的使用

//注意点1:编译错误:不能用在泛型方法声明上,返回值类型前面<>不能使用?
public static <?> void test(ArrayList<?> list){
}
//注意点2:编译错误:不能用在泛型类的声明上
class GenericTypeClass<?>{
}
//注意点3:编译错误:不能用在创建对象上,右边属于创建集合对象
ArrayList<?> list2 = new ArrayList<?>();

有限制的通配符

<? extends Number>     //(无穷小 , Number]
//只允许泛型为Number及Number子类的引用调用

<? super Number>      //[Number , 无穷大)
//只允许泛型为Number及Number父类的引用调用

<? extends Comparable>
//只允许泛型为实现Comparable接口的实现类的引用调用

测试通配符及有限制条件的通配符、读写特点

//测试:通配符?的使用
@Test
public void test1() {
    List<?> list = null;
    List<Object> list1 = null;
    List<String> list2 = null;
    list = list1;
    list = list2;
    method(list1);
    method(list2);
}
public void method(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
    //list.add("AA");//错误的
}
//测试:通配符?的读写数据的特点
@Test
public void test2() {
    List<?> list = null;
    List<String> list1 = new ArrayList<>();
    list1.add("AA");
    list = list1;
    //读取数据(以集合为例说明)
    Object obj = list.get(0);
    System.out.println(obj);
    //list.add("BB");//写入数据(以集合为例说明)//写入数据,操作失败。
    //特例:可以将null写入集合中。
    list.add(null);
}
//有限制条件的通配符的使用:? extends Father。范围(无穷小,Father]
@Test
public void test3(){
    List<? extends Father> list = null;
    List<Object> list1 = null;
    List<Father> list2 = null;
    List<Son> list3 = null;
    //list = list1;//编译错误,?不包括这个范围
    list = list2;
    list = list3;
}
//针对于? extends A的读写
@Test
public void test3_1() {
    List<? extends Father> list = null;
    List<Father> list1 = new ArrayList<>();
    list1.add(new Father());
    list = list1;
    //读取数据:可以的Father father = list.get(0);
    //写入数据:
    list.add(null);
    //list.add(new Father());
    //list.add(new Son());//编译错误,还可能是更小的
}
//有限制条件的通配符的使用:? super Father。范围[Father,无穷大)
@Test
public void test4() {
    List<? super Father> list = null;
    List <Object > list1 = null;
    List<Father> list2 = null;
    List<Son> list3 = null;
    list = list1;
    list = list2;
    //list = list3;//不包括这个范围
}
public void test4_1() {
    List<? super Father> list = null;
    List<Father> list1 = new ArrayList<>() list1.add(new Father());
    list = list1;
    //读取数据:可以的
    Object obj = list.get(0);
    //写入数据:
    list.add(null);
    //list.add(new Object());
    list.add(new Father());//多态的特性,小的可以添加给大的
    list.add(new Son());
}

三、企业真题

1、Java 的泛型是什么?有什么好处和优点?JDK 不同版本的泛型有什么区别?(软动力)
泛型,是程序中出现的不确定的类型。
以集合来举例:把一个集合中的内容限制为一个特定的数据类型,这就是generic背后的核心思想。
jdk7.0新特性:

ArrayList<String> list = new ArrayList<>(); //类型推断

后续版本的新特性:

Comparator<Employee> comparator = new Comparator<>(){} //类型推断
  • 14
    点赞
  • 28
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值