包装类和简单认识泛型

包装类

基本数据类型	包装类
byte	Byte
int	Int
short	Short
long	Long
float	Float
char	Char
boolean	Boolaen

装箱和拆箱

int i=10;
//装箱操作，新建一个Interger类型对象，将i的值放入对象的某个属性中
Integer ii=Inter.valueOf(i);
Inter ij=new Interger(I);
//拆箱操作，Integer对象中的值取出，放到一个基本数据类型中
int j=ii.intValue;

自动装箱和自动封箱

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

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

泛型

对类型实现了参数化。

引出泛类

实现一个类。类中包含一个数组成员，使得数组中可以存放任何类型的数据。也可以根据成员方法返回数组中某个下标的值？
思路：
1.我们之前学过的数组，只能存放指定类型的元素，例如：int[] array=new int[10];String[] strs=new Stromg[10];
2.所有类的分类·，默认为Object，数组是否可以创建？

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

1.任何类型数据都可以存放
2.1号下标本身就是字符串，但的确编译报错
所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。

语法

class 泛型类名称<类型形参列表>{
  //这里可以使用类型参数
  }
  class ClassName<T1,T2,..T3>{
  }

将上述代码改写

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

代码解释：
1.类名后的代表占位符，表示当前类是一个泛类型
2.注释1处，不能new泛型类型的数组
3.注释2处，类型后加入指定当前类型
4.注释3处，不需要进行强行类型转换

泛型类的使用

语法

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

实例

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

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

类型指导

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

泛型是如何编译的

擦除机制

在编译过程中，将所有T替换为Object这种机制，我们称为：擦除机制

泛型的上界

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

语法

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

实例

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

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

MyArray<Integer>l1;//正常，因为Integer是Number的子类型
MyArray<String>l2;错误，因为String

写一个泛型类，其中一个方法，然后求数组中的最大值

class Alg<T extends Comparable<T>>{
  public T findMax(T[] array){
   T max=array[0];
   for(int i=1;i<array.length;i++){
    if(max<array[i]){
      max=array[i];
      }
   }
   return max;
   }
}
public class Txt{
  public static void main(String[] args){
    ALg<Integer>alg =new Alg<>();
    Integer[] array={1,5,2,7,19,4};
    Integer max=alg.findMax(array);
    System.out.println(max);
    }
 }    

泛型方法

定义语法

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

实例

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