java范型_Java知识点总结（Java泛型）
Java知識點總結(Java泛型)
@(Java知識點總結)[Java, Java泛型]
[toc]
泛型
泛型就是參數化類型
適用于多種數據類型執行相同的代碼
泛型中的類型在使用時指定
泛型歸根到底就是“模版”
優點：使用泛型時，在實際使用之前類型就已經確定了，不需要強制類型轉換。
泛型主要使用在集合中
import java.util.ArrayList;
import java.util.List;
public class Demo01 {
// 不使用泛型，存取數據麻煩
public static void test1(){
List list = new ArrayList();
list.add(100);
list.add("zhang");
/*
* 從集合中獲取的數據是Object類型，Object類型是所有類型的根類，但是在具體使用的時候需要
* 類型檢查，類型轉化，處理類型轉化異常
* 使用麻煩
*/
Object o = list.get(1);
if (o instanceof String) {
String s = (String)o;
}
System.out.println(o);
}
// 使用泛型
public static void test2(){
List list = new ArrayList();
//list.add(100); 放數據時安全檢查，100不是String類型，不能存放
list.add("存數據安全，取數據省心");
String s = list.get(0); //取出來的數據直接就是泛型規定的類型
System.out.println(s);
}
public static void main(String[] args) {
test1();
test2();
}
}
自定義泛型
泛型字母
形式類型參數(formal type parameters)即泛型字母
命名泛型字母可以隨意指定，盡量使用單個的大寫字母(有時候多個泛型類型時會加上數字，比如T1，T2)
常見字母(見名知意)
T Type
K V Key Value
E Element
當類被使用時，會使用具體的實際類型參數(actual type argument)代替
泛型類
只能用在成員變量上，只能使用引用類型
泛型接口
只能用在抽象方法上
泛型方法
返回值前面加上 <T>
/**
* 自定義泛型類
*
* 定義"模版"的時候，泛型用泛型字母：T 代替
* 在使用的時候指定實際類型
*
* @author Administrator
* @param
*/
public class Student {
private T javase;
//private static T javaee; // 泛型不能使用在靜態屬性上
public Student() {
}
public Student(T javase) {
this();
this.javase = javase;
}
public T getJavase() {
return javase;
}
public void setJavase(T javase) {
this.javase = javase;
}
}
/**
* 自定義泛型的使用
* 在聲明時指定具體的類型
* 不能為基本類型
* @author Administrator
*
*/
class Demo02 {
public static void main(String[] args) {
//Student Student = new Student(); //不能為基本類型，編譯時異常
Student student = new Student();
student.setJavase(85);
System.out.println(student.getJavase());
}
}
/**
* 自定義泛型接口
*
* 接口中泛型字母只能使用在方法中，不能使用在全局常量中
*
* @author Administrator
* @param
*/
public interface Comparator {
//public static final T1 MAX_VALUE = 100; //接口中泛型字母不能使用在全局常量中
//T1 MAX_VALUE;
public static final int MAX_VALUE = 100;
void compare(T2 t);
T2 compare();
public abstract T1 compare2(T2 t);
}
import java.io.Closeable;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.List;
/**
* 非泛型類中定義泛型方法
* @author Administrator
*
*/
public class Method {
// 泛型方法，在返回類型前面使用泛型字母
public static void test1(T t){
System.out.println(t);
}
// T 只能是list 或者list 的子類
public static void test2(T t){
t.add("aa");
}
// T... 可變參數 ---> T[]
public static void test3(T...a) {
for (T temp : a) {
try {
if (null != temp) {
temp.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws FileNotFoundException {
test1("java 是門好語言");
test3(new FileInputStream("a.txt"));
}
}
泛型的繼承
/**
* 泛型繼承
*
* 保留父類泛型 ----》泛型子類
* 不保留父類泛型 -----》子類按需實現
*
* 子類重寫父類的方法，泛型類型隨父類而定 子類使用父類的屬性，該屬性類型隨父類定義的泛型
*
* @author Administrator
*
* @param
* @param
*/
public abstract class Father {
T1 age;
public abstract void test(T2 name);
}
// 保留父類泛型 ----》泛型子類
// 1)全部保留
class C1 extends Father {
@Override
public void test(T2 name) {
}
}
// 2) 部分保留
class C2 extends Father {
@Override
public void test(Integer name) {
}
}
// 不保留父類泛型 -----》子類按需實現
// 1)具體類型
class C3 extends Father {
@Override
public void test(Integer name) {
}
}
// 2)沒有具體類型
// 泛型擦除：實現或繼承父類的子類，沒有指定類型，類似于Object
class C4 extends Father {
@Override
public void test(Object name) {
}
}
/**
* 泛型擦除
* 類似于Object,不等于Object
* @author Administrator
*
*/
public class Demo03 {
public static void test(Student student){
student.setJavase(100);
}
public static void main(String[] args) {
// 泛型擦除
Student student = new Student();
test(student);
Student student2 = new Student();
//test(student2); //編譯異常
}
}
通配符
通配符(Wildcards)
T、K、V、E 等泛型字母為有類型，類型參數賦予具體的值
？未知類型 類型參數賦予不確定值，任意類型
只能用在聲明類型、方法參數上，不能用在定義泛型類上
/**
* 泛型的通配符 類型不確定，用于聲明變量或者形參上面
*
* 不能使用在類上 或者 new 創建對象上
* @author Administrator
*
*/
public class Demo04 {
// 用在形參上
public static void test(List> list) {
List> list2; // 用在聲明變量上
list2 = new ArrayList();
list2 = new ArrayList();
list2 = new ArrayList();
}
public static void main(String[] args) {
test(new ArrayList());
test(new ArrayList());
}
}
extends/super
上限(extends)
指定的類必須是繼承某個類，或者實現了某個接口(不是implements)，即<=
? extends List
下限(super)
即父類或本身
？ super List
import java.util.ArrayList;
import java.util.List;
/**
* extends:泛型的上限 <= 一般用于限制操作 不能使用在添加數據上，一般都是用于數據的讀取
*
* supper:泛型的上限 >= 即父類或自身。一般用于下限操作
*
* @author Administrator
* @param
*/
public class Test {
private static void test01() {
Test t1 = new Test();
Test t2 = new Test();
Test t3 = new Test();
}
private static void test02(List extends Fruit> list) {
}
private static void test03(List super Apple> list) {
}
public static void main(String[] args) {
// 調用test02(),測試 extends <=
test02(new ArrayList());
test02(new ArrayList());
test02(new ArrayList());
// test02(new ArrayList()); Object 不是 Fruit 的子類 ，編譯不通過
// 調用test03() ,測試super >=
test03(new ArrayList());
test03(new ArrayList());
//test03(new ArrayList()); ReadApple < apple,所以不能放入
}
}
class Fruit {
}
class Apple extends Fruit {
}
class Pear extends Fruit {
}
class ReadApple extends Apple {
}
泛型嵌套
從外向里取
import java.util.Map.Entry;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* 泛型嵌套
* @author Administrator
*
*/
public class Demo05 {
public static void main(String[] args) {
Student2 student = new Student2();
student.setScore("優秀");
System.out.println(student.getScore());
//泛型嵌套
School> school = new School>();
school.setStu(student);
String s = school.getStu().getScore(); //從外向里取
System.out.println(s);
// hashmap 使用了泛型的嵌套
Map map = new HashMap();
map.put("a", "張三");
map.put("b", "李四");
Set> set = map.entrySet();
for (Entry entry : set) {
System.out.println(entry.getKey()+":"+entry.getValue());
}
}
}
public class School {
private T stu;
public T getStu() {
return stu;
}
public void setStu(T stu) {
this.stu = stu;
}
}
public class Student2 {
T score;
public T getScore() {
return score;
}
public void setScore(T score) {
this.score = score;
}
}
其他
import java.util.ArrayList;
import java.util.List;
/**
* 泛型沒有多態
* 泛型沒有數組
* JDK1.7對泛型的簡化
* @author Administrator
*
*/
public class Demo06 {
public static void main(String[] args) {
Fruit fruit = new Apple(); // 多態，父類的引用指向子類的對象
//List list = new ArrayList(); //泛型沒有多態
List extends Fruit> list = new ArrayList();
//泛型沒有數組
//Fruit[] fruits = new Fruit[10];
//ArrayList底層是一個Object[],它放數據的時候直接放，取數據的時候強制類型轉化為泛型類型
/*public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}*/
/*E elementData(int index) {
return (E) elementData[index];
}*/
//JDK1.7泛型的簡化,1.6編譯通不過
List list2 = new ArrayList<>();
}
}
總結
以上是生活随笔為你收集整理的java范型_Java知识点总结（Java泛型）的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 首发价近万元！曝微软Surface Du
- 下一篇： java实验3_Java 实验3