乐趣区

关于后端:盘点一下面试官最爱问的泛型和包装类建议反复观看真的写的非常详细

jiezi

泛型

泛型：能够在类或办法中预支地应用未知的类型。

tips: 个别在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为 Object 类型。

通过咱们如下代码体验一下：

public class GenericDemo2 {public static void main(String[] args) {Collection<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("itcast");
        // list.add(5);// 当汇合明确类型后，寄存类型不统一就会编译报错
        // 汇合曾经明确具体寄存的元素类型，那么在应用迭代器的时候，迭代器也同样会晓得具体遍历元素类型
        Iterator<String> it = list.iterator();
        while(it.hasNext()){String str = it.next();
            // 当应用 Iterator<String> 管制元素类型后，就不须要强转了。获取到的元素间接就是 String 类型
            System.out.println(str.length());
        }
    }
}

tips: 泛型是数据类型的一部分，咱们将类名与泛型合并一起看做数据类型。

泛型的应用

定义格局：

修饰符 class 类名 < 代表泛型的变量 > {}

例如，API 中的 ArrayList 汇合：

class ArrayList<E>{public boolean add(E e){ }

    public E get(int index){ }
       ....
}

应用泛型：即什么时候确定泛型。

在创建对象的时候确定泛型

例如，ArrayList<String> list = new ArrayList<String>();

此时，变量 E 的值就是 String 类型, 那么咱们的类型就能够了解为：

class ArrayList<String>{public boolean add(String e){ }

     public String get(int index){ }
     ...
}

再例如，ArrayList<Integer> list = new ArrayList<Integer>();

此时，变量 E 的值就是 Integer 类型, 那么咱们的类型就能够了解为：

class ArrayList<Integer> {public boolean add(Integer e) { }

     public Integer get(int index) { }
     ...
}

举例自定义泛型类

public class MyGenericClass<MVP> {
    // 没有 MVP 类型，在这里代表 未知的一种数据类型 将来传递什么就是什么类型
    private MVP mvp;
     
    public void setMVP(MVP mvp) {this.mvp = mvp;}
     
    public MVP getMVP() {return mvp;}
}

应用:

public class GenericClassDemo {public static void main(String[] args) {         
         // 创立一个泛型为 String 的类
         MyGenericClass<String> my = new MyGenericClass<String>();        
         // 调用 setMVP
         my.setMVP("大胡子登登");
         // 调用 getMVP
         String mvp = my.getMVP();
         System.out.println(mvp);
         // 创立一个泛型为 Integer 的类
         MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
         my2.setMVP(123);         
         Integer mvp2 = my2.getMVP();}
}

含有泛型的办法

定义格局：

修饰符 < 代表泛型的变量 > 返回值类型 办法名(参数){}

例如，

public class MyGenericMethod {public <MVP> void show(MVP mvp) {System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {return mvp;}
}

应用格局：调用办法时，确定泛型的类型

public class GenericMethodDemo {public static void main(String[] args) {
        // 创建对象
        MyGenericMethod mm = new MyGenericMethod();
        // 演示看办法提醒
        mm.show("aaa");
        mm.show(123);
        mm.show(12.45);
    }
}

含有泛型的接口

定义格局：

修饰符 interface 接口名 < 代表泛型的变量 > {}

例如，

public interface MyGenericInterface<E>{public abstract void add(E e);
    
    public abstract E getE();}

应用格局：

1、定义类时确定泛型的类型

例如

public class MyImp1 implements MyGenericInterface<String> {
    @Override
    public void add(String e) {// 省略...}

    @Override
    public String getE() {return null;}
}

此时，泛型 E 的值就是 String 类型。

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

例如

public class MyImp2<E> implements MyGenericInterface<E> {
    @Override
    public void add(E e) {// 省略...}

    @Override
    public E getE() {return null;}
}

确定泛型：

/*
 * 应用
 */
public class GenericInterface {public static void main(String[] args) {MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

泛型通配符 <?>

当应用泛型类或者接口时，传递的数据中，泛型类型不确定，能够通过通配符 ? 示意。
留神一旦应用泛型的通配符后，只能应用 Object 类中的共性办法，汇合中元素本身办法无奈应用。

通配符应用办法
泛型的通配符: 当不晓得应用什么类型来接收数据的时候, 此时能够应用? 示意未知数据。（? 示意未知通配符）

但此时只能承受数据, 不能往该汇合中存储数据。

举个例子大家了解应用即可：

public static void main(String[] args) {Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表能够接管任意类型

泛型不存在继承关系
即：Collection< Object > list = new ArrayList< String >(); 这种是谬误的。

通配符高级应用 —- 受限泛型

之前设置泛型的时候，实际上是能够任意设置的，只有是类就能够设置。然而在 JAVA 的泛型中能够指定一个泛型的下限和上限。

泛型的下限：

格局：类型名称 <? extends 类 > 对象名称
意义：只能接管该类型及其子类
泛型的上限：

格局：类型名称 <? super 类 > 对象名称
意义：只能接管该类型及其父类型
比方：现已知 Object 类，String 类，Number 类，Integer 类，其中 Number 是 Integer 的父类

public static void main(String[] args) {Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);// 报错
    getElement(list3);
    getElement(list4);// 报错
  
    getElement2(list1);// 报错
    getElement2(list2);// 报错
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的下限：此时的泛型?，必须是 Number 类型或者 Number 类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的上限：此时的泛型?，必须是 Number 类型或者 Number 类型的父类
public static void getElement2(Collection<? super Number> coll){}

包装类

根本对象包装成对象，

根本类效率高

包装类性能更多，可调用办法。

主动装箱和拆箱

主动装箱就是主动将根本数据类型转换为包装器类型；

主动拆箱就是主动将包装器类型转换为根本数据类型。

自 JDK1.5 开始

Integer i = 4;// 主动装箱。相当于 Integer i = Integer.valueOf(4);
i = i + 5;// 等号左边：将 i 对象转成根本数值(主动拆箱) i.intValue() + 5;
// 加法运算实现后，再次装箱，把根本数值转成对象。

根本类型转换为 String

根本类型转换 String 总共有三种形式，查看课后材料能够得悉，这里只讲最简略的一种形式：

根本类型间接与””相连接即可；如：34+""

static toString(参数); 重载的 Object 中的 toString()

static valueOf(参数)；

String 转换成对应的根本类型

除了 Character 类之外，其余所有包装类都具备 parseXxx 静态方法能够将字符串参数转换为对应的根本类型：

public static byte parseByte(String s)：将字符串参数转换为对应的 byte 根本类型。
public static short parseShort(String s)：将字符串参数转换为对应的 short 根本类型。
public static int parseInt(String s)：将字符串参数转换为对应的 int 根本类型。
public static long parseLong(String s)：将字符串参数转换为对应的 long 根本类型。
public static float parseFloat(String s)：将字符串参数转换为对应的 float 根本类型。
public static double parseDouble(String s)：将字符串参数转换为对应的 double 根本类型。
public static boolean parseBoolean(String s)：将字符串参数转换为对应的 boolean 根本类型。
代码应用（仅以 Integer 类的静态方法 parseXxx 为例）如：

public class Demo18WrapperParse {public static void main(String[] args) {int num = Integer.parseInt("100");
    }
}

留神: 如果字符串参数的内容无奈正确转换为对应的根本类型，则会抛出 java.lang.NumberFormatException 异样。

最初

感激你看到这里，看完有什么的不懂的能够在评论区问我，感觉文章对你有帮忙的话记得给我点个赞，每天都会分享 java 相干技术文章或行业资讯，欢送大家关注和转发文章！

退出移动版