包装类，认识泛型

一.包装类

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

2.装箱和拆箱

3.自动装箱和自动拆箱

显式拆箱可以拆成自己想要的类型

二.泛型

1.什么是泛型

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

泛型就是适用于许多许多类型

2.引出泛型

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

代码示例

class MyArray{
    public Object[] array = new Object[10];

    public Object getPos(int pos){
        return array[pos];
    }
    public void setVal(int pos, Object val){
        array[pos] = val;
    }
}

public class Main {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setVal(0, 10);
        myArray.setVal(1, "hello");//字符串也可以存放
        String ret = (String) myArray.getPos(1);//编译报错
        System.out.println(ret);
    }
}

问题：以上代码实现后发现

1.任何类型数据都可以存放

2.1号下标本身就是字符串，但是编译报错，必须进行强制类型转换向下转型

虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望他只能够持有一种数据类型。而不是同时持有这么多类型。所以泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型

 3.语法

class MyArray<T>{  //<T>代表当前类是一个泛型类
    public Object[] array = new Object[10];

    public T getPos(int pos){
        return (T)array[pos];
    }
    public void setVal(int pos, T val){  //直接将放的元素指为T
        this.array[pos] = val;
    }
}

public class Main {
    public static void main(String[] args) {
        MyArray<String> myArray = new MyArray<>(); //指定了数组里只能放String类型
        //myArray.setVal(0, 10);//放整型报错了
        myArray.setVal(1, "hello");
        String ret =  myArray.getPos(1);
        System.out.println(ret);

        MyArray<Integer> myArray2 = new MyArray<>();
        myArray2.setVal(1, 10);
        Integer a = myArray2.getPos(1);
        System.out.println(a);
    }
}

这样就可以定义多个存放不同类型的数组了

代码解释：

三.泛型类的使用

1.语法

2.示例

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

后面这个Integer可以省略

注意：泛型只能接受类，所有基本数据类型必须使用包装类！Integer不能写成int

四.泛型的运行

运行的时候，会把T擦除成Object类

五.泛型的上界

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

1.语法

2.示例

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

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

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

复杂示例

实现一个泛型方法可以返回任何类型数组的最大值

class Alg<T extends Comparable<T>>{
        public T Max(T[] array){
                T max = array[0];
                for (int i = 0; i < array.length; i++) {
                        //if (array[i]>max) Object类不能直接比较
                        if (array[i].compareTo(max)>0){  //需要实现Comparable接口
                                max = array[i];    //使用compareTo方法
                        }
                }
                return max;
        }
}

六.泛型方法

1.定义语法

2.示例

class Alg{
        public <T extends Comparable<T>> T Max(T[] array){
                T max = array[0];
                for (int i = 0; i < array.length; i++) {
                        //if (array[i]>max) Object类不能直接比较
                        if (array[i].compareTo(max)>0){  //需要实现Comparable接口
                                max = array[i];    //使用compareTo方法
                        }
                }
                return max;
        }
}
public class Main {
        public static void main(String[] args) {
                Alg alg = new Alg();
                Integer[] array = {1, 22, 55, 21 ,45};
                Integer ret = alg.Max(array);
                System.out.println(ret);
        }
}

也可以不实例化对象，将alg写成静态方法，直接通过类调用

class Alg{
        public static <T extends Comparable<T>> T Max(T[] array){
                T max = array[0];
                for (int i = 0; i < array.length; i++) {
                        //if (array[i]>max) Object类不能直接比较
                        if (array[i].compareTo(max)>0){  //需要实现Comparable接口
                                max = array[i];    //使用compareTo方法
                        }
                }
                return max;
        }
}
public class Main {
        public static void main(String[] args) {
                //Alg alg = new Alg();
                Integer[] array = {1, 22, 55, 21 ,45};
                Integer ret = Alg.Max(array);
                System.out.println(ret);
        }
}