代码太乱？看看泛型 ， 重写太麻烦？看看泛型...java泛型介绍 - Java日常

泛型的介绍和几个实现类

---

前言

在一个类中实现一个打印不同类型值的方法的时候, 你会怎么做呢? 常见的方法就是利用方法的重载吧， 对于不同类型的来重载例如print()方法, 传参调用即可，但是这种方法显然麻烦。下面就来介绍这种方法（这只是它的一个效果）：

---

一、泛型简介

jdk1.5有的（jdk5）
1. 设计背景：
	我们在使用ArrayList的时候发现：他就像是一个容器，默认装入Object类型；在泛型引入之前，我们可以将任意的对象放入其中（会显得很乱）；
	所以说我们利用 泛型来给其加上一个“标签”，限制只能放入什么数据类型的数据。就像垃圾分类一样，方便管理。
2. 定义：
	所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。
	这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。
	如：List<String>，这表明该List只能保存字符串类型的对象。
3. 历史：
	JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。
4. 常用：
	Element、Key、Type、Value

二、使用方法

1. 注意事项：

1. 集合、接口或集合类在jdk5.0之后都修改为支持泛型的结构
2. 在实例化集合类时， 可以知名具体的泛型的类型
3. 指明完以后，在集合类或接口时，内部结构使用到类的泛型的位置，都指定为实例化时候的泛型类型；
	比如：add(E e)  ---> 实例化以后： add(Integer e)
4. 泛型的类型，必须是一个类，不能是基本数据类型。需要用到基本数据类型的时候，拿包装类来替换即可；
5. 如果实例化时，没有指定泛型，默认为Object类型
6. 泛型类可以有多个<E1 , E2 , E3...>
7. 注意构造器的时候不能这样写
	public Order<>(){} //错误
	正常写即可
8. 泛型不同的引用不能相互赋值
9. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
10. jdk1.7，泛型的简化操作：ArrayList<Fruit> list = new ArrayList<>();
11. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。
12. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
13. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。静态中不能使用泛型🔺（静态结构早于指定的泛型，所以不能用于静态）
14. 泛型方法可以声明为静态；原因：泛型参数是在调用方法时候确定的，并非在实例化的时候确定的；
15. 异常类不能声明为泛型类（异常的catch块里面也不可以使用泛型）

2. 在集合中使用泛型：

代码如下：

//希望用list来实现只放用户的姓名:
public void test01(){
    ArrayList<String> list = new ArrayList<>();
    list.add("张三");
    list.add("Tom");
//        list.add(123);//不正确的数据,被限制添加
    System.out.println(list);
}

3. 自定义泛型类（类中使用泛型）

代码如下：

/**
 * @author Weilei Zhang
 * @Program: Order
 * @Description: TODO
 * @create 2021-03-13 1:35
 */
public class Order<T> {
    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型, 如下
    T orderT;
//这样写的意思是, 传过来什么类型, T 就是什么类型的


    public Order(String name , int orderId , T t){
        this.orderName = name;
        this.orderId = orderId;
        this.orderT = t;
    }

    public Order(){

    }

    public T getOrderT(){
        return orderT;
    }
// setT
    public void setOrderT(T t){
        this.orderT = t;
    }

}

//测试代码：
class Test{
public static void main(String[] args) {
	    //如果定义了泛型,实例化没有指明类的类型,默认为Object类型
	    //但是建议用指明类的泛型
	    //这样表示T就是String类型的
	    Order<String> order = new Order<String>();
	    order.setOrderT("asd");
	    System.out.println(order.getOrderT());//输出: asd
	}
}

4.对于泛型类的继承

一个子类继承一个泛型的父类，子类可以是泛型类，也可以不是泛型类：

代码如下：

/**
 * @author Weilei Zhang
 * @Program: SubOrder01
 * @Description: TODO 子类
 * @create 2021-03-13 1:48
 */
 //上面的代码知道了，父类Order是泛型类，子类可以不是泛型类，并且可以指定具体的泛型，也可以不指定：
public class SubOrder01 extends Order<String> {//子类不是泛型类
}
public class SubOrder01 extends Order<T> {//子类不是泛型类
}

//子类也可以是泛型类
public class SubOrder01<T> extends Order<String> {//子类是泛型类
}
public class SubOrder01<String> extends Order<T> {//子类是泛型类
}
public class SubOrder01<T> extends Order<T> {//子类是泛型类
}

5. 泛型接口：

代码如下：

public interface Generic<T> {
    void show(T t);
}

//=====================================

public class GenericImpl<T> implements Generic<T>{
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

//===========================================

public class GenericTest {
    public static void main(String[] args) {
        new Generic<String>() {
            @Override
            public void show(String s) {
                System.out.println(s);
            }
        }.show("我是一个字符串"); // 通过匿名内部类对象来直接调用重写放方法

        GenericImpl<Integer> ingG = new GenericImpl<>();
        ingG.show(9527);
    }
}

6.泛型方法（可以简化重写操作）

代码如下：

public class Generic {
    // 泛型方法
    public <T> void show(T t){
        System.out.println(t);
    }// 简化了重写过程
}
//============================================

public class GenericTest {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show(1314);//相当于进行了方法的重写
        g.show("Mr.xie");
        g.show(3.14f);
        g.show(3.1415926);
        g.show(true);
        g.show('A');
    }
}

---

总结

1. 注意泛型方法：
           我们查看源码时候可以看到类似这样的代码：

public void add(E e)(){
	//不是泛型方法
}

           这样的不是泛型方法，下面的才是：

public<T> void add(T t){
	//是泛型方法
}

           所以，含有泛型方法的不一定是泛型类。（他们俩没关系）

其它的注意事项看上面即可；