包装类+初识泛型

1 .包装类

1.1 基本数据类型对应的包装类

1.2.1装箱

1.2.2拆箱

2.初识泛型

2.1什么是泛型

2.2泛型类

2.3裸类型

2.4泛型的上界

2.5泛型方法

1 .包装类

基本数据类型所对应的类类型

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

1.1 基本数据类型对应的包装类

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

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

1.2 装箱和拆箱

1.2.1装箱

（1）自动装箱
int a=100;
Integer val=a;
System.out.println(val);

（2）显示装箱
Integer integer1 = new Integer(a);
System.out.println(integer1);
Integer integer2 = Integer.valueOf(a);
System.out.println(integer2);

自动装箱 Integer val=a;本质就是Integer.valueOf(a)

1.2.2拆箱

(1)自动拆箱
Integer val=100;
int a=val;
System.out.println(a);

（2）显示拆箱
int a2=val.intValue();
System.out.println(a2);

自动拆箱int a=val本质就是val.intValue()

而且可以拆箱成各种类型

理解加深

public static void main ( String [] args ) {

Integer a = 127 ;

Integer b = 127 ;

Integer c = 128 ;

Integer d = 128 ;

System . out . println ( a == b );

System . out . println ( c == d );

}

运行结果：

解析：

总结：装箱的整形在-128到127之间返回的引用相同。

2.初识泛型

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

2.1什么是泛型

就是适用于许多许多类型 。从代码上讲，就是对类型实现了参数化。

泛型的主要目的：

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

2.2泛型类

语法

class 泛型类名称 < 类型形参列表 > {

// 这里可以使用类型参数

}

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

}

泛型类的使用

泛型类 < 类型实参 > 变量名 ; // 定义一个泛型类引用

new 泛型类 < 类型实参 > ( 构造方法实参 ); // 实例化一个泛型类对象

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

使用举例：

写一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。

代码（2-1）如下：

class MyArray<T> {
public T[] array = (T[])new Object[10];//1
public T getPos(int pos) {
return this.array[pos];
}
public void setVal(int pos,T val) {
this.array[pos] = val;
}
}

对于泛型的进一步补充：

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

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

2.，不能new泛型类型的数组

代码（2-1）T[] array = (T[])new Object[10];是否就足够好，答案是未必的。

我们可以参考官方代码：

改造代码（2-1）

class MyArray<T> {
    public Object[] array = new Object[10];//1
    public T getPos(int pos) {
        return (T)array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
}

2.3裸类型

裸类型是一个泛型类但没有带着类型实参，例如 MyArrayList 就是一个裸类型

MyArray list = new MyArray ();

为什么有这样的写法呢？

泛型在编译的过程当中存在擦除机制（以代码（2-1）为例）

将 所有的E替换为Object 这种机制，我们称为： 擦除机制 。

Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。

avap -c 查看字节码文件，所有的E都是Object。

泛型类的使用时我们给的类型实参主要起两个作用：

（1）存储数据的时候，可以帮我们进行自动的类型检查

（2）获取数据的时候，可以帮我们进行类型转换

2.4泛型的上界

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

语法：

写法1.

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

...

}

public class MyArray < E extends Number > {

...

}

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

写法2.

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

...

}

E必须是实现了Comparable接口的

举例：

写一个类，可以传入多种类型的数组，返回其中的最大值。

写法1：

写法2：

正确代码：

public class Text2 {
    public static <E extends Comparable<E>>  E Max(E[]arr) {
        E ret = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (ret.compareTo(arr[i]) < 0) {
                ret = arr[i];
            }
        }
        return ret;
    }

2.5泛型方法

定义语法

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

示例

public class Text2 {
    public static <E extends Comparable<E>>  E Max(E[]arr) {
        E ret = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (ret.compareTo(arr[i]) < 0) {
                ret = arr[i];
            }
        }
        return ret;
    }

    public static void main(String[] args) {
        Integer[] arr={6,2,3,4,1000,1};
        System.out.println(Max(arr));
    }
}

使用示例-可以类型推导