文章目录

包装类基本数据类型和对应的包装类装箱和拆箱面试题

泛型什么是泛型泛型的语法泛型类的使用泛型的使用裸类型(Raw Type) （仅需了解）擦除机制泛型的上界泛型方法

包装类

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

注意，除了int基本数据类型的包装类是Integer和char基本数据类型的包装类是Character以外的基本数据类型的包装类都是首字母大写。

装箱和拆箱

装箱：把基本数据类型变成包装类的过程，就叫作装箱。

拆箱：把包装类变成基本数据类型的过程，就叫作拆箱。

装箱分为显示装箱和自动装箱。

拆箱分为显示拆箱和自动拆箱。

显示装箱和自动装箱

<code> public static void main(String[] args) { -- -->

int a = 15;

Integer a1 = Integer.valueOf(a);//显示装箱

Integer a2 = a;//自动装箱

}

显示拆箱和自动拆箱

public static void main(String[] args) {

Integer a = 15;

int a1 = a.intValue();//显示拆箱

int a2 = 15;//自动拆箱

}

自动装箱，自动拆箱的原理

自动装箱和自动拆箱的原理都是底层帮助我们调用valueOf 或者 intValue方法；

面试题

下面的代码的运行结果是什么？

<code>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);

}

当我们把上述代码运行，发现结果令人惊讶

为什么呢？明明两个结果都应该是true，但第一个是true 第二个是false?

我们发现这两个都是装箱操作，那么我们装箱是怎么工作的，也就是valueOf的逻辑是什么。

观察valueOf方法，当我们给valueOf方法传入一个值，并且他满足一定范围，返回一个数组值，不满足返回新的对象。

那这个方法的值范围是多少呢？

范围是[-128,127]。

泛型

什么是泛型

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的

代码，这种刻板的限制对代码的束缚就会很大。---- 《Java编程思想》

通俗来讲，就是适用于许多许多类型。把想要的数据类型当作参数传递，需要什么类型，就传入什么类型。

泛型的语法

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

// .....

}

类名后的 代表占位符，表示当前类是一个泛型类。

泛型类的使用

泛型类的语法

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

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

new后面的<类型实参>中的类型实参可以省略，编译器可以根据上下文推导出类型实参。

泛型的使用

<code>class MyArray <E>{ -- -->

public Object[] objects = new Object[10];

public void setVal(int pos,E val) {

objects[pos] = val;

}

public E getVal(int pos) {

return (E)objects[pos];

}

}

public class Test {

public static void main(String[] args) {

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

myArray.setVal(0,12);

myArray.setVal(1,13);

Integer a = myArray.getVal(1);

System.out.println(a);

}

}

我们以Integer为例，当我们以Integer类型当作参数传入，那E类型必须是整数类型，不能是其他类型。

如果传入其他类型，编译器会通过自动类型检查发现错误并报错。

注意<>内只能写类类型，不能写简单类型。

裸类型(Raw Type) （仅需了解）

裸类型是一个泛型类但没有带着类型实参（为了兼容老版本的api）

擦除机制

擦除机制：就是在编译时，将所有的E替换Object。

泛型的上界

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

示例一

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

...

}

class MyArray <E extends Number>{

public Object[] objects = new Object[10];

public void setVal(int pos,E val) {

objects[pos] = val;

}

public E getVal(int pos) {

return (E)objects[pos];

}

}

当我们规定E的上界时，此时传入的参数必须是Number或者是Number的子类。

如果不是将会报错。

示例二

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

...

}

写一个泛型方法，求数组中的最大值。

观察上面的代码，发现在if判断句报错，这是为什么呢？

因为E的类型我们不知道，我们无法比较。

解决方法：让E继承Comparable接口。

<code>class Alg <E extends Comparable<E>> { -- -->

public E findMax(E[] array) {

E max = array[0];

for (int i = 1; i < array.length; i++) {

if(max.compareTo(array[i]) < 0) {

max = array[i];

}

}

return max;

}

}

注意<>中的数据类型必须实现了Comparable接口。如果没有将会报错

泛型方法

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

class Alg1 {

public <E extends Comparable<E>> E findMax(E[] array) {

E max = array[0];

for (int i = 1; i < array.length; i++) {

if(max.compareTo(array[i]) < 0) {

max = array[i];

}

}

return max;

}

}

调用泛型方法，有俩种。

1.java通过参数传递，推导出类型。

2.手动添加类型。