初识包装类和泛型

注：此博文为本人总结学习过程中的笔记

1.包装类

在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。

1.1.基本类型和对应的包装类型

除了Integer和Character，其他基本类型的包装类都是首字母大写。 

1.2.装箱和拆箱 

int i = 10;

//装箱操作，新建一个Integer类型对象，将i的值放入对象的某个属性中
Integer ii = Integer.valueOf(i);
Integer ij = new Integer(i);

//拆箱操作，将Integer对象中的值取出，放到一个基本数据类型中
int j = ii.intValue();

1.3.自动装箱和自动拆箱 

可以看到在使用过程中，装箱和拆箱带来不少的代码量，所以为了减少开发者的负担，Java提供了自动机制。

int i = 10;

Integer ii = i;//自动装箱
Integer ij = (Integer)i;//自动装箱

int j = ii;//自动拆箱
int k = (int)ii;//自动拆箱

2.泛型 

 一般的类和方法，只能使用具体的类型，要么是基本类型，要么是自定义的类。如果要编写可以应用与多种类型的代码，这种刻板的限制对代码的束缚就会很大。

泛型是在JDK1.5引入的新的语法，通俗讲，泛型就是适用于很多类型。从代码上讲，就是对类型实现了参数化。

泛型的主要目的是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型作为参数传递，需要什么类型就传入什么类型。

2.1.语法

class 泛型类名称<类型形参列表> {
    //可以使用类型参数
}

class ClassName<T1, T2..., Tn> {

}

class 泛型类名称<类型形参列表> extends 继承类/*这里可以使用类型参数*/ {
    //这里可以使用类型参数
}

class ClassName<T1, T2,..., Tn> extends ParentClass<T1> {
    //可以只使用部分类型参数
}

示例：

class MyArray<T> {
    public Objcet[] array = new Object[10];
    
    public T getPos(int Pos) {
        return (T)this.array[pos];
    }
    public void setVal(int pos, T val) {
        this.array[pos] = val;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<>();//1
        myArray.setVal(0, 10);
        myArray.setval(1, 12);
        int ret = myArray.getPos(1);//2
        System.out.println(ret);
        myArray.setVal(2, "bit");//3
    }
}

代码解释：

1.类名后的<T>代表占位符，表示当前类是一个泛型类

【规范】类型形参一般使用一个大写字母表示，常用的名称有：

E 表示 Element

K 表示 Key

V 表示 Value

N 表示 Number

T 表示 Type

S, U, V 等等，表示第二，第三，第四个类型

2.注释1处，类型后加入<Integer>指定当前类型

3.注释2处，不需要进行强制类型转换，已进行自动拆箱

4.注释3处，代码编译报错，此时因为在注释2处指定类当前的类型，此时在注释4处，编译器会在存放元素的时候帮助我们进行类型检查。

2.2.泛型类的使用

2.2.1.语法

泛型类<类型实参> 变量名;//定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参);//实例化一个泛型类对象

示例：

MyArray<Integer> list = new MyArray<Integer>();

注意：泛型只能接收类，所有的基本数据类型必须使用包装类

当编译器可以根据上下文推导出类型实参许哟时，可以省略类型实参的填写

MyArray<Integer> list = new MyArray<>();//可以推导出实例化需要的类型实参为Integer

2.3.泛型的上界 

在定义泛型类是，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。

2.3.1.语法

class 泛型类名称<类型形参 extends 类型边界>  {
    ...
}

示例：

publc class MyArray<E extends Number> {
    ...
}

只接受Number的子类型作为E的类型实参 

MyArray<Integer>I1;//正常，因为Integer是Number的子类型
MyArray<Integer>I2;//编译错误，因为String不是Number的子类型

没有指定类型边界E，可以视为E extends Object 

复杂示例：

public class MyArray<E extends Comparable<E>> {
    ...
}

E必须是实现了Comparable接口的 

2.4.泛型方法

2.4.1.语法

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) {...}

示例：

public class Util {
    //静态的泛型方法 需要在static后用<>声明泛型类型参数
    public static <E> void swap(E[] array, int i, int j) {
        E t = array[i];
        array[i] = arr[j];
        array[j] = t;
    }
}

使用类型推导示例：

Integer[] a = {...};
swap(a, 0, 9);

String[] b = {...};
swap(b, 0, 9);

不使用类型推导示例：

Integer[] a = {...};
Util.<Integer>swap(a, 0, 9);

String[] b = {...};
Util.<String>swap{b, 0, 9};