【装包拆包----泛型】

---

装箱和拆箱

装箱：
把基本数据类型给到引用数据类型

    public static void main(String[] args) {
        //自动装包
        //第一种装包
        Integer c = 12;
        //第二种装包
        int a = 7;
        Integer b = a;

        //显示装包
        Integer aa = Integer.valueOf(10);
    }
1
2
3
4
5
6
7
8
9
10
11

拆箱：
把包装类型给到基本引用数据类型

    public static void main(String[] args) {
        //自动拆包
        Integer a = 10;
        int b = a;

        //显示拆包
        int aa = a.intValue();
    }
1
2
3
4
5
6
7
8

泛型

含义：泛型：就是适用于许多许多类型。
语法：

泛型只能接受包装类

创建一个泛型数组

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

//类名后的  代表占位符，表示当前类是一个泛型类
class MyArray<T>{
    //泛型数组
    public Object[] array =new Object[10];

    public void setArray(int pos,T val) {
       array[pos] = val;
    }
    public T getArray(int pos){
        return (T)array[pos];
    }
}
public class Test {
    public static void main(String[] args) {
    //类型后加入  指定当前类型
        MyArray <Integer> myArray = new <Integer>MyArray();
        myArray.setArray(0,7);
        myArray.setArray(1,10);
        int a = myArray.getArray(1);
        System.out.println(a);

        MyArray <String> myArray1 = new <String>MyArray();
        myArray1.setArray(0,"jiujiu");
        myArray1.setArray(1,"happy");
        String str = myArray1.getArray(1);
        System.out.println(str);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

注意：
1.不能new一个泛型类型的数组

泛型的上界

//T只能是Number或者Numberd的子类
class FanXing<T extends Number>{

}
class Person{
//父类
}
class Student extends Person{
    //子类
}

//T只能是Person或者Person的子类
class FanXing2<T extends Person>{


}
public class Test {
    FanXing <Integer> fanXing = new <Integer> FanXing();
    FanXing <Double> fanXing2 = new <Integer> FanXing();
    
    //报错
    FanXing <String> fanXing3 = new <Integer> FanXing();
    //String不是Numberd的子类


    FanXing2 <Student> fanXing4 = new <Student> FanXing2();
    FanXing2 <Person> fanXing5 = new <Person> FanXing2();


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

泛型方法

class Person implements Comparable<Person>{
    @Override
    public int compareTo(Person o) {
        return 0;
    }
}


class Alg<T extends  Comparable<T>>{

    public T findMaxValue(T[] array){
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (max.compareTo(array[i])<0){
                max = array[i];
            }
        }
        return max;
    }

}

//泛型方法
class Alg2{
    public<T extends  Comparable<T>>T findMaxValue(T[] array){
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (max.compareTo(array[i])<0){
                max = array[i];
            }
        }
        return max;
    }

}
public class Test {
    public static void main(String[] args) {
        Alg<Integer> alg = new Alg<Integer>();
        Integer[] integer={1,2,3,4,5,6,7};
        Integer ret = alg.findMaxValue(integer);
        System.out.println(ret);

         //泛型方法实例化
        Alg2 alg2 =new Alg2();
        Integer[] integer1 = {1,2,3,4,5,6,7,8};
        Integer ret2 = alg2.findMaxValue(integer1);
        System.out.println(ret2);
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50