前言
一、包装类
1.基本数据类型与包装类
基本数据类型对应的类类型–》包装类(类中必然有属性/方法)
byte—>Byte
short—>Short
long—>Long
float–>Float
double—>Double
boolean–>Boolean
int—>Integer
char—>Character
有包装类有以下好处:
1.使用比较方便
2.数据的转换(相当于数据类型也面向对象了)
2.装箱(装包)拆箱(拆包)
装箱:基本类型–》包装类型
public static void main(String[] args) {
int a=10;
Integer b=a;//自动装箱
Integer c=new Integer(a);//显示装箱
Integer d=Integer.valueOf(a);//与前面一个意思,因为前面底层调用了valueOf。//显示装箱
}
拆箱:包装类型–》基本类型
public static void main(String[] args) {
Integer a=99;
int i=a.intValue();//显示拆箱
Float b=9.9f;
float c=b.floatValue();//拆小数
int d=a;//自动拆箱
}
3.例子
为啥127相等,128不等?
Integer a=127;
Integer b=127;
Integer c=128;
Integer d=128;
System.out.println(a==b);//true
System.out.println(c==d);//false
Integer底层是valueOf,下面是底层原理:
public static Integer valueOf(int i){
if(i>=IntegerCache.low&&i<=IntergerCache.high)//i>=-128,i<=127
{
return IntegerCache.cache[i+(-IntegerCache.low)];
}
return new Integer(i);
//若127,在范围内,127+128=255,下标为255,不用new新的空间
//如128,不在范围内,要new新的空间。
}
初级泛型
很抽象,要求看懂即可。
类和方法:具体类型,自定义类型。
泛型:适用于许多许多类型,对类型实现了参数化。传递类型!
1.引出泛型
实现一个类,类中包含一个数组成员,使数组中可以存放任何类型的数据,也可以根据成员方法返回数组中某个下标的值。
class MyArray{
public Object[] objects=new Object[10];
public Object getPos(int pos){
return objects[pos];
}
public void setVal(int pos ,Object val){
objects[pos]=val;
}
}
public class Test02 {
public static void main(String[] args) {
MyArray myArray=new MyArray();
myArray.setVal(0,377);
myArray.setVal(1,"dhj");
int val=(int)myArray.getPos(0);//Object必须强转为int类型
System.out.println(val);//377
}
}
必须强制类型转换。
2.泛型如何写
可以存任何类型数据,但是我指定存任何类型数据。
类名后的代表占位符,表示当前类是一个泛型类。<>里面一定是一个引用类型。
1.
第一种泛型方式:
class MyArray<T>{//<T>代表占位符,表示当前类是一个泛型类。
//public Object[] objects=new Object[10];//正确写法
public T[] objects=(T[]) new Object[10];//这样写,有缺陷
public T getPos(int pos){
return objects[pos];
}
public void setVal(int pos ,T val){
objects[pos]=val;
}
}
public class Test02 {
public static void main(String[] args) {
MyArray<Integer> myArray=new MyArray<Integer>();//指定当前传的是Integer类型
myArray.setVal(0,377);
myArray.setVal(1,77);
int val=myArray.getPos(0);//不需要强转了!!
System.out.println(val);//377
MyArray<String> myArray1=new MyArray<>();//第二个<>里面的内容可以省略
myArray1.setVal(0,"dhhs");
myArray1.setVal(1,"jdjjd");
String val2=myArray1.getPos(1);
System.out.println(val2);//jdjjd
}
}
第二种泛型方式(常用)
class MyArray<T>{//<T>代表占位符,表示当前类是一个泛型类。
public Object[] objects=new Object[10];
public T getPos(int pos){
return (T)objects[pos];//强转T类型
}
public Object getArray() {
return objects;
}
public void setVal(int pos ,T val){
objects[pos]=val;
}
}
public class Test02 {
public static void main(String[] args) {
MyArray<Integer> myArray=new MyArray<Integer>();//指定当前传的是Integer类型
myArray.setVal(0,377);
myArray.setVal(1,77);
int val=myArray.getPos(0);//不需要强转了!!
System.out.println(val);//377
}
}
泛型存在意义:在编译的时候,帮我们进行类型检查
在编译的时候,帮我们进行类型转换
在运行的时候是没有泛型的概念。(JVM无泛型)
擦除机制:·编译过程中将所有的T都替换为Object。(编译时实现)
2.
如果根据上面的添加数组的返回值:不允许把object类型进行强制类型转换
因为object数组里面能放任意类型的数据,所以不能强转为单一类型
MyArray<T>类中:
public T[] getArray(){
return objects;
}
main方法里:
Object obj=myArray1.getArray();//返回值只能用Object接收,而且不能够强转。//不允许把object类型进行强制类型转换
如果一定要进行转换,就实例化具体类型的数组(明确你的数组类型)
class MyArray<T>{//<T>代表占位符,表示当前类是一个泛型类。
//public T[] objects=(T[]) new Object[10];//把这里覆盖了
public T[] objects;
public MyArray(){
}
public MyArray(Class<T>clazz,int capacity){
objects=(T[]) Array.newInstance(clazz,capacity);
}
public T[] getArray() {
return objects;
}
public static void main(String[] args) {
MyArray<Integer> myArray1 = new MyArray<Integer>(Integer.class, 10);//指定当前数组传的是Integer类型
Object obj = myArray1.getArray();
}
3.泛型的上界
写泛型,求数组中的最大值。
引用类型不可以大于小于比较。Object是所有的父类,中无compareable与compareTo。擦除为一个实现了这个接口的类型。就可以了。
以下求数组最大值的题目为例子:
class Alg<T extends Comparable>{//设置边界,防止compar被擦除,只留下object//擦除为一个实现了这个接口的类型//上界
public T findMax(T[] array){
T max=array[0];
for (int i = 1; i < array.length; i++) {
if(max.compareTo(array[i])<0){//引用类型不可以大于小于比较
max=array[i];
}
}
return max;
}
}
public class Test03 {
public static void main(String[] args) {
Alg<Integer> alg=new Alg<>();//Integer,String等引用类型都实现了comparable接口。
// 但是自定义类型中如果没有自己实现,那就不可以。
Integer[] array={1,23,5,3,53,22,32};
Integer max= alg.findMax(array);
System.out.println(max);
}
}
泛型的静态方法:
class Alg{
public static<T extends Comparable> T findMax(T[] array){//T被盖住没有comparable重写。
T max=array[0];
for (int i = 1; i < array.length; i++) {
if(max.compareTo(array[i])<0){//引用类型不可以大于小于比较
max=array[i];
}
}
return max;
}
}
public class Test03 {
public static void main(String[] args) {
Integer[] array={1,23,5,3,53,22,32};
Integer max= Alg.<Integer>findMax(array);//静态,直接类名调用
System.out.println(max);
}
}