泛型-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_80768157/article/details/143086112

一、什么是泛型

泛型是指定一个表示类型的变量,即“参数化类型”。用泛型来代替某个实际的类型，而后通过实际调用时传入或推导的类型来对泛型进行替换，以达到代码复用的目的。

比如在一个类中定义一个String类型的变量，这时候只要是String类型，我们都能够正常运行，但我们如果突然需要一个Integer类型的变量时，这个时候我们只能重新创建一个类，把 value 改为 Integer类型。随着业务的增加，会导致设置的类越来越多，因此有了泛型的。

只要将我们平常的代码简单修改

public class demo<T> {
    private T t;
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
}
//demo<T>表示此类型是由外部调用本部类指定的。T也可以用其他字母代替。

二、泛型类和泛型对象

泛型类

就是在类声明时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。只有用户使用该类的时候，该类所属的类型才能明确。

格式：

[访问权限] class 类名称<泛型类型标识1，泛型类型标识2，…，泛型类型标识n>

[访问权限] 泛型类型标识变量名称;

[访问权限] 泛型类型标识方法名称;

[访问权限] 返回值类型声明方法名称(泛型类型标识变量名称){};

创建泛型对象

定义好泛型类后，我么就可以创建泛型对象

格式：

类名称<参数化类型> 对象名称 = new 类名称<参数化类型>();

代码

ArrayList<Integer> list = new ArrayList<Integer>();
//这时只能再list集合中添加Interger类型的变量，如果添加其他类型变量，编译不通过     
list.add(1);// 添加字符串对象                             
list.add(2);                                       
for (Integer str : list) {// 遍历集合                  
    System.out.println(str);                       
}

泛型方法

public class demo {                          
    public static void main(String[] args) {      
        Dog dog = new Dog();                      
        dog.show("hello");//hello                 
        dog.show(12);//12                         
        dog.show(23.4);//23.5                     
    }                                             
}                                                 
class Dog{                                        
    String eat;                                   
    Integer age;                                  
    //定义了泛型方法，该方法的参数在调用时才会被确认,传入的是什么参数，返回值就是什么类型的                     
    public <T> void show(T t){                    
        System.out.println(t);                    
    }                                             
}

泛型接口

格式

[访问权限] interface 接口名称<泛型标识> {}

Interface Animal <T>{

...

}

定义泛型接口的子类

第一种，直接在子类实现的接口中明确给出泛型类型

//定义接口
public interface Inter <T>{
    public abstract void show(T t);
}
//接口实现类
public class InterImpl implements Inter<String>{
    //在实现的时候确认参数类型
    @Override
    public void show(String s) {
        System.out.println(s);
    }
}

第二种，直接在子类后声明泛型

//定义接口
public interface Inter <T>{
    public abstract void show(T t);
}
//接口实现类
public class InterImpl<T> implements Inter<T>{
    //在实现的时候确认参数类型
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}
public class demo{
      public static void main(String[] args) {
          Inter<String> inter = new InterImpl();
          inter.show("hello");//hello
          Inter<Integer> ii = new InterImpl<>();
          ii.show(12);//12
      }
}