# Java高级之泛型

**Repository Path**: fpfgitmy_admin/java-high-generics

## Basic Information

- **Project Name**: Java高级之泛型
- **Description**: java泛型的简述
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 3
- **Forks**: 1
- **Created**: 2021-04-28
- **Last Updated**: 2023-08-06

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

### 泛型
+ jdk1.5引入，指定参数对应的类型，比如垃圾分类
+ 泛型不能是基本数据类型，如果要用到基本类型的位置，需要用包装类替换
+ 在实例化集合时，可以指明具体的泛型类型
+ 指明完成以后，在集合类或接口中凡是定义类的类或接口时，内部结构，比如方法、构造器、属性等，在实例化时候，都将使用该泛型
+ 如果实例化时，没有指明泛型的类型，默认类型为java.lang.Object类型

#### 通配符

#### 为什么使用泛型？
+ 如果不适用泛型，则会造成类型不安全，在遍历时会强制转化类型会导致类型转化异常
+ 在编译时就会进行类型检查，保 证数据的安全
#### 在集合中使用泛型
+ ArrayList的使用
```
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        for (Integer item : list) {
            System.out.println(item);
        }
    }
```
+ HashMap的使用
```
package com.felixfei.study.test;


import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @describle
 */
public class GenericTest {

    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("tom", 1);
        hashMap.put("jie", 2);
        Set<Map.Entry<String, Integer>> entries = hashMap.entrySet();

        Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> entry = iterator.next();
            System.out.println("获取到的key= " + entry.getKey());
            System.out.println("获取到的value= " + entry.getValue());
        }
    }
}

```
#### 自定义泛型类
+ 泛型类、泛型接口、泛型方法
+ 泛型类可能有多个，多个用逗号隔开，比如<E1,E2,E3>
+ 定义构造器的时候不用加泛型
+ 如果泛型类是一个接口或抽象类，则不可创建泛型类的对象
+ 静态方法中不能使用类的泛型
+ 异常类不能声明为泛型的
+ 父类有泛型
    + 子类可以保留父类泛型
    + 子类不保留父类泛型（擦除）
    + 子类指定父类泛型参数
+ 泛型不同的引用不能相互赋值
##### 定义泛型类
```
package com.felixfei.study.model;

/**
 * @describle：自定义泛型类 在实例化的时候T是什么类型就是什么类型
 */
public class Order<T> {

    private String orderName;
    private int orderId;
    // 使用泛型

    T orderT;

    public Order() {
    }

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

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
}

```
##### 使用泛型类
```
package com.felixfei.study.test;

import com.felixfei.study.model.Order;

/**
 * @describle
 */
public class GenericTest {

    public static void main(String[] args) {
        // 如果定义了类是带泛型的，建议在实例化时要指明类的泛型
        Order<String> order = new Order<String>();
        order.setOrderT("abc");
    }
}

```
##### 子类继承方式
```
package com.felixfei.study.model;

/**
 * @author felixfei
 * @version 1.0
 * @date 2021/4/8 22:50
 * @describle
 */
public class SubOrder extends Order<Integer>{
}

```
```
package com.felixfei.study.test;
import com.felixfei.study.model.Order;
import com.felixfei.study.model.SubOrder;

/** 
* @describle 
*/
public class GenericTest {   
 public static void main(String[] args) {      
    // 由于子类在继承带泛型的父类时，指明了泛型类型，则实例化对象时，不再需要指明泛型        
    SubOrder subOrder = new SubOrder();      
    subOrder.setOrderT(123);   
 }
}
```
##### 子类保留泛型T
```
package com.felixfei.study.model;

/**
 * @describle 仍然是泛型类
 */
public class SubOrder1<T> extends Order<T> {
}

```
```
package com.felixfei.study.test;

import com.felixfei.study.model.Order;
import com.felixfei.study.model.SubOrder;
import com.felixfei.study.model.SubOrder1;

/**
 * @describle
 */
public class GenericTest {

    public static void main(String[] args) {
        // 由于子类在继承带泛型的父类时，指明了泛型类型，则实例化对象时，不再需要指明泛型
        SubOrder1<String> subOrder1 = new SubOrder1<>();
        subOrder1.setOrderT("123");
    }
}

```
##### 定义泛型方法
+ 在方法中出现了泛型的结构，泛型参数于类的泛型参数没有任何关系（泛型方法所属的类是不是泛型类都没有关系）
+ 泛型方法，可以声明为静态的，原因：泛型参数是在调用方法时确定的，并非在实例化类时确定
```
package com.felixfei.study.test;

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

/**
 * @describle 泛型方法
 */
public class GenericTest {

    // 当参数 E[] arr 中的 E 会被认为某个类，需要在当前方法上添加 <E> 才能标识为该 E 是方法上定义的泛型类
    // 同时 <E> 也定义了该方法是泛型方法
    public <E> List<E> copyFromArrayToList(E[] arr) {
        ArrayList<E> es = new ArrayList<>();
        for (E e : arr) {
            es.add(e);
        }
        return es;
    }

    public static void main(String[] args) {
        GenericTest genericTest = new GenericTest();
        Integer[] arr = {1, 2, 3, 4};
        // 泛型方法在调用时，指明泛型参数的类型
        List<Integer> list = genericTest.copyFromArrayToList(arr);
        System.out.println(list);
    }
}

```
##### 泛型类和泛型方法的使用场景
+ 增、删、改、查时候指定对应表的类的泛型(orm映射,一个表映射一个类) 
+ 封装公共的方法
```
package com.felixfei.study.mapper;

import java.util.List;

/**
 * @describle 定义BaseMapper
 */
public class BaseMapper<T> {

    public void add(T t) {
    }

    public boolean delete(int id) {
        return false;
    }

    public void update(T t) {

    }

    public List<T> list() {
        return null;
    }

    public T getOne(int id) {
        return null;
    }

    // 泛型方法的使用
    public <E> E getValue() {
        return null;
    }
}

```

```
package com.felixfei.study.mapper;

import com.felixfei.study.model.User;

/**
 * @describle
 */
public class UserMapper extends BaseMapper<User> {

}

```