投稿
  1. 极客之音首页
  2. 后端开发
  3. Java
  4. Java自学入门

Java入门-泛型

李, 若俞 • • Java自学入门 • 阅读 277

今日语录：人生高处见的前提条件肯定不会有躺平

一、泛型入门

1、泛型的理解和好处

  • 案例代码

    import java.util.ArrayList;
    import java.util.Hashtable;
    import java.util.Map;

    /**
    * @author chenx
    * @date 2022年01月04日
    */
    public class HashtableDemo {
    public static void main(String[] args) {

     // 使用传统方法
     /**
      * 1、不能对接入到集合ArrayList中的而数据类型进行约束（不安全）
      * 2、遍历的时候，需要进行类型转换，如果集合中的数据量大，对效率有影响
      */
     ArrayList arrayList = new ArrayList();
     arrayList.add(new Dog("旺财",11));
     arrayList.add(new Dog("发财",1));
     arrayList.add(new Dog("瞎晃",12));

     for(Object o : arrayList){
      Dog dog = (Dog)o;
      //System.out.println(dog.getAge()+dog.getName());
     }


     // 使用泛型
     /**
      * 1、当我们ArrayList<Dog>表示存放到 ArrayList 集合中的元素是Dog类型
      * 2、当编译器发现添加的类型，不满足要求时，会报错
      * 3、在遍历的时候，可以直接取出Dog
      */
     ArrayList<Dog> arrayListSec = new ArrayList<Dog>();
     arrayListSec.add(new Dog("旺财",11));
     arrayListSec.add(new Dog("发财",1));
     arrayListSec.add(new Dog("瞎晃",12));
     //arrayListSec.add(new Cat("af"));
     for(Dog o : arrayListSec){
      System.out.println(o.getAge()+"+"+o.getName());
     }
    }
    }

    class Dog{
    private String name;
    private int age;
    public Dog(String name,int age){
     this.name = name;
     this.age = age;
    }

    public String getName() {
     return name;
    }

    public void setName(String name) {
     this.name = name;
    }

    public int getAge() {
     return age;
    }

    public void setAge(int age) {
     this.age = age;
    }
    }

    class Cat{
    private String name;

    public String getName() {
     return name;
    }

    public void setName(String name) {
     this.name = name;
    }

    }

  • 使用传统方法的局限

    1、不能对接入到集合ArrayList中的数据类型进行约束（不安全）

    2、遍历的时候，需要进行类型转换，如果集合中的数据量大，对效率有影响

  • 使用泛型好处

    1、编译时，检查添加元素的类型，提高了安全性

    2、减少了类型转换的次数，提高效率

    3、不再提示编译警告

2、泛型简介

1、泛型，又称为参数化类型，是JDK5.0出现的新特性，解决数据类型的安全性问题

2、在类声明或实例化时只要制定好需要的具体的类型即可

3、Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException（类型转换异常)。同时，代码更简洁、健壮

4、泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Map;

/**
 * @author chenx
 * @date 2022年01月04日
 */
public class HashtableDemo {
 public static void main(String[] args) {
  Dog<Integer> integerDog = new Dog<>(100,100);
  System.out.println(integerDog.name);
  integerDog.show();

  Dog<String> xIo = new Dog<>("XIo", 100);
  System.out.println(xIo.getName());
  xIo.show();

  Dog<Double> doubleDog = new Dog<>(12.134, 123);
  System.out.println(doubleDog.getName());
  doubleDog.show();
 }
}

/**
 * 泛型的作用是：
 * 1. 可以在类声明时通过一个标识表示类中某个属性的类型，
 * 2. 是某个方法的返回值的类型，
 * 3. 可以是参数类型。
 * @param <E>
 */
class Dog<E>{

 E name; // E 表示 name的数据类型，该数据类型在定义Dog对象的时候指定，即在编译期间，就确定E是什么类型

 private int age;

 public Dog(E name,int age){ // E 也可以是参数类型
  this.name = name;
  this.age = age;
 }

 public E getName() { // E 也可以是方法的返回值类型
  return name;
 }

 public void setName(E name) {
  this.name = name;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }

 public void show(){
  System.out.println(name.getClass());
 }
}

运行结果：

Java入门-泛型
image-20220208225440838

3、泛型的语法

  • 泛型的声明
interface 接口<T>{} 和 class 类名<K,V>{} // 比如：List, ArrayList

说明：

1、其中，T,K,V不代表值，而是表示类型

2、任意字母都可以，常用T表示，是Type的缩写

  • 泛型的实例化

    1、要在类型名后面指定类型参数的值（类型），如

    List<String> strList = new ArrayList<String>();
    Iterator<Customer> iterator = customers.iterator();

  • 泛型的使用示例

    要求：泛型在HashSet,HashMap的使用情况
    1、创建3个学生对象
    2、放入到HashSet中学生对象
    3、放入到HashMap中，要求Key是String name，Value就是学生对象
    4、使用两种遍历方式

    import java.util.*;

    /**
     * @author chenx
     * @date 2022年01月04日
     */
    public class HashtableDemo {
     public static void main(String[] args) {
      System.out.println("--------------使用HashSet------------");
      // 1、HashSet
      Set<Student> set = new HashSet<Student>();
      set.add(new Student("join",12));
      set.add(new Student("CC",2));
      set.add(new Student("ss",3));

      Iterator<Student> iterator = set.iterator();
      while(iterator.hasNext()){
       // 使用泛型后，快捷键会自动返回Student类型
       Student student = iterator.next();
       System.out.println(student.name);
      }

      System.out.println("--------------使用HashMap------------");
      // 3、HashMap
      HashMap<String,Student> hashMap = new HashMap<String,Student>();
      hashMap.put("YY",new Student("YY",0));
      hashMap.put("EE",new Student("EE",2));
      hashMap.put("BB",new Student("BB",1));
      for(String key : hashMap.keySet()){
       System.out.println(key+"+"+hashMap.get(key).age);
      }
     }
    }

    /**
     * 1、创建3个学生对象
     * 2、放入到HashSet中学生对象
     * 3、放入到HashMap中，要求Key是String name，Value就是学生对象
     * 4、使用两种遍历方式
     */
    class Student{
     public String name;
     public int age;
     public Student(String name, int age){
      this.name = name;
      this.age = age;
     }
    }

    运行结果：

    Java入门-泛型
    image-20220208232035533

4、泛型使用的注意事项和细节

1、interface List{},public class HashSet{}…等等

  • 说明：T，E只能是引用类型

  • 示例代码：

    List<Integer> list = new ArrayList<Integer>(); //OK
    List<int> list2 = new ArrayList<int>(); // ERROR

2、在给泛型指定具体类型后，可以传入该类型或者子类类型

3、泛型使用形式

  • Listlist1 = new ArrayList();
  • Listlist2 = new ArrayList<>();

4、如果我们这样写 List list3 = new ArrayList();默认给它的泛型是【E就是 Object】，等价：

ArrayList<Object> arrayList = new ArrayList<Object>();

二、自定义泛型

1、自定义泛型类

基本语法

  • class 类名<T,R...>{
     成员
    }

注意细节

1、普通成员可以使用泛型(属性、方法)

2、使用泛型的数组，不能初始化（因为数组在new时，不能确定T的类型，所以无法在内存中开辟空间）

3、静态方法中不能使用类的泛型（因为静态是和类相关的，在类加载的时候，对象还没有创建，所以如果静态方法和静态属性使用了静态，JVM就无法完成初始化）

4、泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）

5、如果在创建对象时，没有指定类型，默认为Object

示例代码

package com.hspedu.customgeneric;


import java.util.Arrays;

/**
 * @author chenx
 * @version 1.0
 */
@SuppressWarnings({"all"})
public class CustomGeneric_ {
    public static void main(String[] args) {

        //T=Double, R=String, M=Integer
        Tiger<Double,String,Integer> g = new Tiger<>("john");
        g.setT(10.9); //OK
        //g.setT("yy"); //错误，类型不对
        System.out.println(g);
        Tiger g2 = new Tiger("john~~");//OK T=Object R=Object M=Object
        g2.setT("yy"); //OK ,因为 T=Object "yy"=String 是Object子类
        System.out.println("g2=" + g2);

    }
}

//老韩解读
//1. Tiger 后面泛型，所以我们把 Tiger 就称为自定义泛型类
//2, T, R, M 泛型的标识符, 一般是单个大写字母
//3. 泛型标识符可以有多个.
//4. 普通成员可以使用泛型 (属性、方法)
//5. 使用泛型的数组，不能初始化
//6. 静态方法中不能使用类的泛型
class Tiger<T, R, M> {
    String name;
    R r; //属性使用到泛型
    M m;
    T t;
    //因为数组在new 不能确定T的类型，就无法在内存开空间
    T[] ts;

    public Tiger(String name) {
        this.name = name;
    }

    public Tiger(R r, M m, T t) {//构造器使用泛型

        this.r = r;
        this.m = m;
        this.t = t;
    }

    public Tiger(String name, R r, M m, T t) {//构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    //因为静态是和类相关的，在类加载时，对象还没有创建
    //所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
//    static R r2;
//    public static void m1(M m) {
//
//    }

    //方法使用泛型

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public R getR() {
        return r;
    }

    public void setR(R r) {//方法使用到泛型
        this.r = r;
    }

    public M getM() {//返回类型可以使用泛型.
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

    @Override
    public String toString() {
        return "Tiger{" +
                "name='" + name + ''' +
                ", r=" + r +
                ", m=" + m +
                ", t=" + t +
                ", ts=" + Arrays.toString(ts) +
                '}';
    }
}

2、自定义泛型接口

基本语法

interface 接口名<T,R…>{ }

注意细节

1、接口中，静态成员也不能使用泛型（这个和泛型类规定一样）

2、泛型接口的数据类型，在继承接口或者实现接口时确定

3、没有指定类型，默认为Object

示例代码

package com.hspedu.customgeneric;

/**
 * @author chenx
 * @version 1.0
 */
public class CustomInterfaceGeneric {
    public static void main(String[] args) {

    }
}

/**
 *  泛型接口使用的说明
 *  1. 接口中，静态成员也不能使用泛型
 *  2. 泛型接口的类型, 在继承接口或者实现接口时确定
 *  3. 没有指定类型，默认为Object
 */

//在继承接口 指定泛型接口的类型
interface IA extends IUsb<String, Double> {

}
//当我们去实现IA接口时，因为IA在继承IUsu 接口时，指定了U 为String R为Double
//，在实现IUsu接口的方法时，使用String替换U, 是Double替换R
class AA implements IA {

    @Override
    public Double get(String s) {
        return null;
    }
    @Override
    public void hi(Double aDouble) {

    }
    @Override
    public void run(Double r1, Double r2, String u1, String u2) {

    }
}

//实现接口时，直接指定泛型接口的类型
//给U 指定Integer 给 R 指定了 Float
//所以，当我们实现IUsb方法时，会使用Integer替换U, 使用Float替换R
class BB implements IUsb<Integer, Float> {

    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }
}
//没有指定类型，默认为Object
//建议直接写成 IUsb<Object,Object>
class CC implements IUsb { //等价 class CC implements IUsb<Object,Object> {
    @Override
    public Object get(Object o) {
        return null;
    }
    @Override
    public void hi(Object o) {
    }
    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {

    }

}

interface IUsb<U, R> {

    int n = 10;
    //U name; 不能这样使用

    //普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);

    void run(R r1, R r2, U u1, U u2);

    //在jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
    default R method(U u) {
        return null;
    }
}



3、自定义泛型方法

基本语法

修饰符 <T,R...>返回类型 方法名（参数列表）{

}

注意细节

1、泛型方法，可以定义在普通类中，也可以定义在泛型类中

2、当泛型方法被调用时，类型会确定

3、public void eat(E e){} ，修饰符之后没有<T,R…> eat方法不是泛型方法，而是使用了泛型

示例代码

package com.hspedu.customgeneric;

import java.util.ArrayList;

/**
 * @author chenx
 * @version 1.0
 * 泛型方法的使用
 */
@SuppressWarnings({"all"})
public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马", 100);//当调用方法时，传入参数，编译器，就会确定类型
        System.out.println("=======");
        car.fly(300, 100.1);//当调用方法时，传入参数，编译器，就会确定类型

        //测试
        //T->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
    }
}

//泛型方法，可以定义在普通类中, 也可以定义在泛型类中
class Car {//普通类

    public void run() {//普通方法
    }
    //说明 泛型方法
    //1. <T,R> 就是泛型
    //2. 是提供给 fly使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());//String
        System.out.println(r.getClass());//Integer
    }
}

class Fish<T, R> {//泛型类
    public void run() {//普通方法
    }
    public<U,M> void eat(U u, M m) {//泛型方法

    }
    //说明
    //1. 下面hi方法不是泛型方法
    //2. 是hi方法使用了类声明的 泛型
    public void hi(T t) {
    }
    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }

}

三、泛型的继承和通配符

1、注意细节

1、泛型不具备继承性

Java入门-泛型
image-20220227155823262

2、List<?> :支持任意泛型类型

3、List<? extends A> :表示上限，可以接受A或者A的子类

4、List<? super A>:表示支持A类一级A类的父类，不限于直接父类，规定了泛型的下限

2、示例代码

package com.hspedu;

import java.util.ArrayList;
import java.util.List;

/**
 * @author chenx
 * @version 1.0
 * 泛型的继承和通配符
 */
public class GenericExtends {
    public static void main(String[] args) {

        Object o = new String("xx");

        //泛型没有继承性
        //List<Object> list = new ArrayList<String>();

        //举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        //如果是 List<?> c ，可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);

        //List<? extends AA> c： 表示 上限，可以接受 AA或者AA子类
//        printCollection2(list1);//×
//        printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√

        //List<? super AA> c: 支持AA类以及AA类的父类，不限于直接父类
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        //printCollection3(list4);//×
        //printCollection3(list5);//×


        //冒泡排序

        //插入排序

        //....


    }
    // ? extends AA 表示 上限，可以接受 AA或者AA子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

    //说明: List<?> 表示 任意的泛型类型都可以接受
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是Object
            System.out.println(object);
        }
    }



    // ? super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类，
    //规定了泛型的下限
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }

}

class AA {
}

class BB extends AA {
}

class CC extends BB {
}


原文始发于微信公众号（Whisper Coding）：Java入门-泛型

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/255515.html

赞 (0)
李, 若俞的头像李, 若俞
0 0

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站，欢迎收藏到浏览器，订阅我们！