简单介绍java的泛型和包装类

我就是我 2023-10-11 14:17 68阅读 0赞

## 泛型 ##

*  **泛型**：可以在类或方法中预支地使用未知的类型。

> tips:  
> 一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。  
> 泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型。

#### 泛型的使用 ####

定义格式：

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

例如，API中的ArrayList集合：

class ArrayList<E>{
         
        public boolean add(E e){
         }
    
        public E get(int index){
         }
       	....
    }

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

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

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

此时，变量E的值就是String类型,那么API中的ArrayList集合就可以理解为：

class ArrayList<String>{
         
         public boolean add(String e){
         }
    
         public String get(int index){
          }
         ...
    }

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

此时，变量E的值就是Integer类型,那么API中的ArrayList集合就可以理解为：

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){
        }

## 包装类 ##

基本对象包装成对象，

基本类效率高

包装类功能更多，可调用方法。

<table> 
 <thead> 
  <tr> 
   <th>基本类型</th> 
   <th>对应的包装类（位于java.lang包中）</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td><strong>Integer</strong></td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td><strong>Character</strong></td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

### 自动装箱和拆箱 ###

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

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

自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`异常。