泛型全解--Java基础081

什么是泛型？
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。

泛型的好处：

  1. 将运行时的异常提前至了编译时。
  2. 避免了无谓的强制类型转换 。
 
  
泛型在集合中的常见应用：
 
  ArrayList<String>  list = new ArrayList<String>();  true     推荐使用。
 
        ArrayList<Object>  list = new ArrayList<String>();  false
  ArrayList<String>  list = new ArrayList<Object>();  false
 
  //以下两种写法主要是为了兼顾新老系统的兼用性问题。
       ArrayList<String>  list = new ArrayList();           true   
       ArrayList    list = new ArrayList<String>();   true   
 
注意： 泛型没有多态的概念，左右两边的数据 类型必须 要一致，或者只是写一边的泛型类型。

package cn.itcastset;
/*
需求： 定义一个方法可以接收任意类型的参数，而且返回值类型必须 要与实参的类型一致。

自定义泛型：  自定义泛型就是一个数据类型的占位符或者是一个数据类型的变量。

方法上自定义泛型：
	
	修饰符  	<声明自定义的泛型>返回值类型    函数名(使用自定义泛型 ...){
	
	}


在泛型中不能使用基本数据类型，如果需要使用基本数据类型，那么就使用基本数据类型对应的包装类型。

byte----> Byte
short---> Short 
int----> Integer
long----> Long 

double ----> Double 
float -----> Float

boolean-----Boolean

char-------》 Character 


方法泛型注意的事项：
	1. 在方法上自定义泛型，这个自定义泛型的具体数据类型是在调用该 方法的时候传入实参时确定具体的数据类型的。
	2. 自定义泛型只要符合标识符 的命名规则即可, 但是自定义泛型我们一般都习惯使用一个大写字母表示。  T Type  E Element
	
*/

class MyArrays{
	
	//翻转
	public <T>void reverse(T[] arr){
		for(int i=0,j=arr.length-1;i<j;i++,j--){
			T temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	
	public <T>String toString(T[] arr){
		
		StringBuilder sb = new StringBuilder();
		for(int i=0;i<arr.length;i++){
			if(i==0){
				sb.append("["+arr[i]+",");
			}else if(i==arr.length-1){
				sb.append(arr[i]+"]");
			}else{
				sb.append(arr[i] + ",");
			}
		}
		
		return sb.toString();
	}
	
}

public class Demo1 {
	
	public static void main(String[] args) {
		
		Integer[] arr = {10,24,14,16};
		
		MyArrays tool = new MyArrays();
		tool.reverse(arr);
		System.out.println("数组的元素:" + tool.toString(arr));
	}
	
}

package cn.itcastset;

/*
  需求： 编写一个数组 的工具类 

 泛型类：
 
泛型类的定义格式：
	
	class 类名<声明自定义泛型>{
	
	}
 
泛型类要注意的事项：
 	1. 在类上自定义泛型的具体数据类型是在使用该类的时候创建对象时候确定的。
 	2. 如果一个类在类上已经声明了自定义泛型，如果使用该类创建对象 的时候没有指定 泛型的具体数据类型，那么默认为Object类型
 	3.在类上自定义泛型不能作用于静态的方法，如果静态的方法需要使用自定义泛型，那么需要在方法上自己声明使用。
 */


class MyArrays1<T>{
	
	//翻转
	public void reverse(T[] arr){
		for(int i=0,j=arr.length-1;i<j;i++,j--){
			T temp = arr[i];
			arr[i] = arr[j];
			arr[j] = temp;
		}
	}
	
	public String toString(T[] arr){
		
		StringBuilder sb = new StringBuilder();
		for(int i=0;i<arr.length;i++){
			if(i==0){
				sb.append("["+arr[i]+",");
			}else if(i==arr.length-1){
				sb.append(arr[i]+"]");
			}else{
				sb.append(arr[i] + ",");
			}
		}
		
		return sb.toString();
	}
	
}

public class Demo {
	
	public static void main(String[] args) {
		
		Integer[] arr = {10,24,14,16};
		
		MyArrays1<Integer> tool = new MyArrays1<Integer>();
		tool.reverse(arr);
		System.out.println("数组的元素:" + tool.toString(arr));
	}
	
}

package cn.itcastset;


/*
 泛型接口
 
泛型接口的定义格式: 

	interface 接口名<声明自定义泛型>{
	
	}

泛型接口要注意的事项：
	1. 接口上自定义的泛型的具体数据类型是在实现一个接口的时候指定 的。
	2. 在接口上自定义的泛型如果在实现接口的时候没有指定具体的数据类型，那么默认为Object类型。
	
需求： 目前我实现一个接口的时候，我还不明确我目前要操作的数据类型，我要等待创建接口实现类 对象的时候我才能指定泛型的具体数据类型。
	
	如果要延长接口自定义泛型 的具体数据类型，那么格式如下：
	格式：  
		public class Demo4<T> implements Dao<T>{
		
		}
	
 */

interface Dao<T>{
	
	public void add(T t);	
}

public class Demo3<T> implements Dao<T> {

	public static void main(String[] args) {
		Demo3<String> d = new Demo3<String>();
	}

	public void add(T t){
		
	}


}

package cn.itcastset;


import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

/*
 泛型的上下限：
 
需求1： 定义一个函数可以接收接收任意类型的集合对象， 要求接收的集合对象只能存储Integer或者是Integer的父类类型数据。

需求2： 定义一个函数可以接收接收任意类型的集合对象， 要求接收的集合对象只能存储Number或者是Number的子类类型数据。

泛型中通配符： ？ 
	
	? super Integer : 只能存储Integer或者是Integer父类元素。  泛型 的下限
 	
 	? extends Number ： 只能存储Number或者是Number类型的子类数据。 泛型上限
 	
 */
public class Demo4 {

	public static void main(String[] args) {
		ArrayList<Integer> list1 = new ArrayList<Integer>();
		ArrayList<Number> list2 = new ArrayList<Number>();
		
		HashSet<String> set = new HashSet<String>();
		//getData(set);
		
	}
	
	//泛型的上限
	public static void getData(Collection<? extends Number> c){
		
		
	}
	
	//泛型的下限
	public static void print(Collection<? super Integer> c){
		
	}
	
}