java入門基礎學習----泛型

概念：泛型就是引數化型別，使用廣泛的型別

作用：

       1. 安全：在編譯的時候檢查型別安全；  2.省心：所有的強制轉換都是自動和隱式的，提高程式碼的重用率

 

一、  泛型類：宣告時使用泛型
  字母：
  T Type 表示型別
  K V 分別代表兼職中的Key Value
  E 代表Element
  使用是確定型別 
  注意：
  1.泛型只能使用引用型別，不能基本型別
  2.泛型宣告時字母不能使用在 靜態屬性|靜態方法上

 

 介面中泛型字母只能使用在方法中，不能使用在全域性常量中

 

  泛型方法<>，返回型別前面
  只能訪問物件的資訊，不能修改資訊（因為型別不確定）

 

二、抽象類繼承

package com.kennosaur.gen03;
/**
 * 父類為泛型類
 * 1.屬性
 * 2.方法
 * 
 * 要麼同時擦除，要麼子類大於等於父類的型別,
 * 不能子類擦除,父類泛型
 * 1.屬性型別
 *   父類中，隨父類而定
 *   子類中，隨子類而定
 * 2.方法重寫
 *   隨父類而定
 * @author Administrator
 *
 * @param <T>
 */
public abstract class Father<T,T1> {
	T name;
	public abstract void test(T t);
}

/**
 * 子類指定具體型別
 * 屬性型別為具體型別
 * 方法同理
 */
class Child1 extends Father<String,Integer>{
	String t1;
	@Override
	public void test(String t) {
		t1 = this.name;		
	}	
}
/**
 * 子類為泛型類，型別在使用時確定
 *
 *
 */
class Child2<T1,T> extends Father<T,T1>{
	T t2;
	@Override
	public void test(T t) {
				
	}	
}

/**
 * 子類為泛型，父類不指定型別---泛型的擦除,使用Object替換
 */
class Child3<T1, T2> extends Father{

	@Override
	public void test(Object t) {
				
	}	
}

/**
 * 子類與父類同時擦除
 */
class Child4 extends Father{

	@Override
	public void test(Object t) {
				
	}	
}

/**
 * 錯誤：子類擦除，父類使用泛型
 */
//class Child5 extends Father<T, T1>{
//
//	@Override
//	public void test(T t) {
//		
//	}
//
//}

三、介面泛型

package com.kennosaur.gen03;
/**
 * 泛型介面:與繼承同理
 * 重寫方法隨父類而定
 * @author Administrator
 *
 * @param <T>
 */
public interface Comparable<T> {
	void compare(T t);
}
//宣告子類指定具體型別
class Comp implements Comparable<Integer>{

	@Override
	public void compare(Integer t) {
		// TODO Auto-generated method stub
		
	}
	
}
//擦除
class Comp1 implements Comparable{

	@Override
	public void compare(Object t) {
		// TODO Auto-generated method stub
		
	}
	
}

//父類擦除，子類泛型
class Comp2<T> implements Comparable{

	@Override
	public void compare(Object t) {
		// TODO Auto-generated method stub
		
	}
	
}

//子類泛型>=父類泛型
class Comp3<T> implements Comparable<T>{

	@Override
	public void compare(T t) {
		// TODO Auto-generated method stub
		
	}
	
}

//父類泛型，子類擦除----錯誤
//class Comp4 implements Comparable<T>{
//	
//}

 

四、泛型的擦除

1.繼承|實現宣告時不指定型別；

2.使用時不指定型別

統一Object對待

 

五、泛型沒有多型

萬用字元？

package com.kennosaur.gen04;

import com.kennosaur.gen01.App;

/**
 * ?的使用：宣告型別|宣告方法上，不能宣告類或使用時
 * ? extends: <=上限， 指定型別為子類或自身
 * ? super :  >=下限，指定型別為自身或父類
 * @author Administrator
 *
 */
public class Student<T> {
	 T score;
	 
	 public static void main(String[] args) {
		 Student<?> stu = new Student<String>();
		 test(new Student<Integer>());
		 test2(new Student<Apple>());
		 //test3(new Student<Apple>());   錯誤，泛型沒有多型
		 
		 //test4(new Student<Apple>());   X錯誤
		 
//		 stu = new Student<Fruit>();
//		 test4(stu);                      X錯誤
		 
		 test4(new Student<Object>());
		 test4(new Student<Fruit>());
	 }
	 
	 public static void test(Student<?> stu) {
		 
	 }
	 
	 public static void test2(Student<? extends Fruit> stu) {
			 
	 }
	 public static void test3(Student<Fruit> stu) {
		 
	 }
	 
	 public static void test4(Student<? super Fruit> stu) {
		 
	 }
}

泛型的巢狀：使用時從外到內，一層層拆分

 

泛型陣列是不存在的

    沒有泛型陣列，不能建立泛型陣列

    可以只有宣告，可以使用“?”宣告，沒有實際意義