【java基础】泛型程序设计基础

叁歲伎倆 2023-09-24 22:02 41阅读 0赞

### 文章目录 ###

*  泛型是什么
 *  自定义泛型类
 *  自定义泛型方法
 *  类型变量的限定
 *  总结

# 泛型是什么 #

泛型类和泛型方法有类型参数，这使得它们可以准确地描述用特定类型实例化时会发生什么。在没有泛型类之前，程序员必须使用Objct编写适用于多种类型的代码。这很烦琐，也很不安全。

随着泛型的引入，Java有了一个表述能力很强的类型系统，允许设计者详细地描述变量和方法的类型要如何变化。

泛型程序设计（generic programming)意味着编写的代码可以对多种不同类型的对象重用。

下面的代码就是没有使用泛型的集合

// 该集合我想要存放int类型的数据
            List list = new ArrayList();
            list.add(100); // 加入int
            list.add("hello"); // 放入字符串
            list.add(true); // 放入布尔类型
    
            for (int i = 0; i < list.size(); i++) {
        
                Object o = list.get(i); // 获取到的值是Object
                int k = (Integer) o; // 强制转换
                System.out.println(k);
            }

可以发现上面的代码在集合中什么都能放入，并没有进行类型检查。而且在获取集合元素的时候返回的是Object，我们还要进行强转。运行看看一下，结果如下

![在这里插入图片描述][196b26ec99d041b9b5eb37cacff0b694.png]

可以发现报错了，这就是因为在集合里面存放了其他类型的数据。集合不使用泛型那么就是存储的Object数据，我们将其转换为Integer所以就出现了ClassCastException。现在就已经可以发现java的弊端了，没有一个参数检查机制，代码极不安全，泛型就是用来弥补这点的。看下面泛型代码。

List<Integer> list = new ArrayList<>();
            list.add(100);
            // list.add("hello") // 类型检查，编译都不能通过
            // list.add(true) // 编译不能通过
    
            for (int i = 0; i < list.size(); i++) {
        
                Integer k = list.get(i); // 返回的直接就是Integer
                System.out.println(k);
            }

我们可以在<>里面指定要存储的元素类型，这就是泛型，使用泛型后在往集合添加元素的时候就会进行检查，如果不是指定的元素，那么就会出现编译错误，程序编译都不能通过。使用泛型后，集合返回的就直接是指定的类型，也就不需要强转类型转换了。

通过上面的代码，大家应该初步体会到了泛型的好处和强大，下面就来学习如何自定义泛型类和泛型方法

# 自定义泛型类 #

泛型类就是有一个或多个类型变量的类。下面我就通过MyTool这个类来进行说明

public class MyTool<T> {
        
        private T info;
    
        public MyTool(T info) {
        
            this.info = info;
        }
    
        public T getInfo() {
        
            return info;
        }
    }

上面的MyTool这个类就是一个泛型类，在这个类中引入了一个类型变量**T**，用尖括号(<>)括起来的，放在类名后面。这个T就是我们在创建对象的时候指定的。

MyTool<String> myTool = new MyTool<>("这是自定义泛型类");

我们在尖括号(<>)里面写的类型就会成为T的类型，这里<>里面写的类型为String，那么T就是代表String。

对于 new MyTool<>(“这是自定义泛型类”) 这部分代码，我们在构造器中传入了一个字符串，原因就是T代表的是字符串，而我们的构造器中要传入的内容就是T，也就是字符串，没有问题。

对于在上面的MyTool类，由于我们指定的T为String，所以可以将其理解为就是一个普通类，如下

public class MyTool {
        
        private String info;
    
        public MyTool(String info) {
        
            this.info = info;
        }
    
        public String getInfo() {
        
            return info;
        }
    }

现在，对于泛型类的基本使用基本就说完了，我们自定义泛型类就是在类后面加上<>，在这里面写上类型变量，然后再类中使用这个类型变量即可。**对于类型变量，我们一般都是使用大写字母，而且很简短**，在Java库使用变量E表示集合的元素类型，K和V分别表示表的键和值的类型。T(必要时还可以用相邻的字母U和S)表示“任意类型”。  
**注意：对于类型变量并不是一定为一个大小字母，只不过是约定俗成罢了**，例如，下面代码也是正确的

public class TypeParameter<AAAAA> {
        
        private AAAAA aaaaa;
    }

但是还是建议大家就写为一个大写字母，遵顼java规范。

对于泛型类，我们在<>里面可以写上多个类型变量，使用逗号分隔，例如下面代码

public class MulTypeParam<K,V> {
        
    }

这样定义以后，我们在使用这个对象就要在<>里面传入2个变量

MulTypeParam<Integer, String> typeParam = new MulTypeParam<>();

这样写的话，那么K就代表Integer类型，V就代表String类型

# 自定义泛型方法 #

上面说的是自定义泛型类，现在来讲一下泛型方法。下面就是一个简单示例

public class SimpleGenericMethod {
        
    
        public static <T> T getMiddleInfo(T... ts) {
        
            int index = ts.length / 2;
            return ts[index];
        }
    }

对于泛型方法，我们并不需要放在泛型类中，放在普通类中也没有问题。对于泛型方法，我们将类型变量放在<>中，<>放在返回值前面，修饰符后面。

上面的方法就是接收T类型的参数，然后返回一个T。下面就是对泛型方法的调用

String middleInfo = SimpleGenericMethod.<String>getMiddleInfo("java", "python", "c", "c++", "php");

可以发现在泛型方法中，我们是在方法前面添加了一个<>，然后指定了类型。但是对于大多数情况下，<>都可以省略，编译器会根据传入的参数推断出类型。  
在几乎所有情况下，泛型方法的类型推导都可以正常工作。下面写法就是省略<>写法

String middleInfo = SimpleGenericMethod.getMiddleInfo("java", "python", "c", "c++", "php");

类型推导的原则就是寻找参数的公共父类。

对于泛型方法，我们也可以在<>里面定义多个类型变量

public static <X, Y> Y towTypeParam(X x, Y y) {
        
            return y;
        }

上面代码就表示传入一个X类型的变量和一个Y类型的变量，然后返回一个Y类型变量。

# 类型变量的限定 #

在很多的情况下，我们使用泛型时，并不是上面类型的参数都能传入，而是有所现在，比如是某个类的子类，或者必须实现某个接口。下面就来说明如何完成这些对泛型的限制。

先来看一个例子

public interface Eat {
        
        
        void eat();
    }

public class TypeParamRestrict {
        
    
        public static <T> void eats(T... ts) {
        
            for (T t : ts) {
        
                ((Eat) t).eat();
            }
        }
    }

看看上面这个eats有上面问题呢？可以发现，我们并没有检查T类型的参数，T不一定是一个实现接口的Eat的对象，这样调用就会出错，所以，我们应该对T进行限制，写法如下

public class TypeParamRestrict {
        
    
        public static <T extends Eat> void eats(T... ts) {
        
            for (T t : ts) {
        
                t.eat();
            }
        }
    }

T extends Eat就表示传入的类型必须是为Eat，或者Eat的子类。这里使用extends可能有人很疑惑，Eat不是接口吗？为什么是使用extends，事实上，这里选择extends是为了更接近子类的概念，对于接口和类都是使用extends。使用了限定符后，就不需要进行类型转换了，T已经是Eat的子类，所以可以直接掉用eat方法。

上面这样写了以后，再调用eats这个方法，参数就必须是实现Eat接口的类。

对于一个类型变量，我们还可以有多个限定，例如下面代码

使用&就表示必须且的意思，表示T要同时实现Eat和Serializable接口。  
**注意：对于限定，可以有多个接口，但是只能有一个是类，而且必须写为第一个限定。为什么只能有一个限定类，因为java是单继承的。类型变量不可能同时实现多个类**

# 总结 #

泛型程序设计（generic programming)就是意味着编写的代码可以对多种不同类型的对象重用。

关于泛型的更多知识，参考以下内容

[**泛型程序设计基础**][Link 1]  
[**类型擦除、桥方法、泛型代码和虚拟机**][Link 2]  
[**泛型的限制及其继承规则**][Link 3]  
[**泛型的通配符(extends,super,?)**][extends_super]

[196b26ec99d041b9b5eb37cacff0b694.png]: https://img-blog.csdnimg.cn/196b26ec99d041b9b5eb37cacff0b694.png
[Link 1]: https://blog.csdn.net/m0_51545690/article/details/129354354
[Link 2]: https://blog.csdn.net/m0_51545690/article/details/129356404
[Link 3]: https://blog.csdn.net/m0_51545690/article/details/129360054
[extends_super]: https://blog.csdn.net/m0_51545690/article/details/129363949