前言: https://www.cnblogs.com/LoveBB/p/17277662.html 什麼是範型 JDK 1.5開始引入Java泛型(generics)這個特性,該特性提供了編譯時類型安全檢測機制,允許程式員在編譯時檢測到非法的類型。停,業餘的客套話就不多說了,這些術語,講了N遍,不 ...
前言:
https://www.cnblogs.com/LoveBB/p/17277662.html
什麼是範型
JDK 1.5開始引入Java泛型(generics)這個特性,該特性提供了編譯時類型安全檢測機制,允許程式員在編譯時檢測到非法的類型。停,業餘的客套話就不多說了,這些術語,講了N遍,不管你看不看得懂,我的目的就是就要把你教懂,所以,這裡不是重點。
泛型的作用
泛型有四個作用:類型安全、自動轉換、性能提升、可復用性。即在編譯的時候檢查類型安全,將所有的強制轉換都自動和隱式進行,同時提高代碼的可復用性。實在不想說,但是不說又不行,生怕你們把路走偏了。
泛型的使用
- 我們寫代碼,基本上就是:類、介面、方法。
泛型類
- 先來來個3簡單的類,平時的類動則幾十上百行,現在我們化繁為簡,就是為了讓我們更清楚類的結構。
正經類
public class Student {
}
public class Teacher {
}
public class Room {
}
有些人心裡忍不住要噴了,這誰不會呀。嘿嘿,彆著急,這想說的就是我們修煉的名門正派功法,這是很標準的"正派"寫法。接下來,我將使用魔教功法進行魔改。
範型類結構
public class 類名 <泛型類型1,...> {
// todo
}
範型類
- 一個範型
簡簡單單
public class Student<T> {
}
- 兩個範型
我好像在罵人,但是你沒有證據吧
public class Student<S,B> {
}
- 三個範型
這裡註意,範型裡面的 S, B, Q 都是自定義的,一般用大寫字母表示,個數不限
public class Student<S, B, Q> {
}
- N 個範型
嘿嘿,個數不限,那就來個不限的吧
public class Student<S, B, Q, V, N, F, D, A, U, I, O, P, L, H, J, K, G> {
}
- 關於字母
有人說,字母就26個啊,你寫重覆的話,那不是一樣了嘛。對,你是對的,但是魔教功法就在於,他不講道理,誰說一定要使用大寫字母了,下麵來個逼死強迫症寫法,什麼叫無限火力,放飛自我。
public class Student<Sq, VIP, diss, QR, LKl, WOrd, Hao, Da, VPP, Ji, Ni, Tai, Mei, N, WoCao, D, CPDD, U, I, Love, Dog, OPHJKG, JiuK, HangZhou, WO, LAi, CoffEr, VCS> {
}
怎麼樣,好好的一個類,經過魔教功法的改造,是不是看起來很不一樣了。
- 一般規定
雖然我們可以亂寫,但是魔教功法還是有一套自己的體系,一般關於大寫字母的定義如下
T:任意類型 type
E:集合中元素的類型 element
K:key-value形式 key
V: key-value形式 value
N: Number(數值類型)
?: 表示不確定的java類型
對比
- 為了加深記憶,我們前後再對比一下內容
// 改造前
public class Student {
}
// 改造後
public class Student<T> {
}
實例化
- 範型類應該怎麼樣實例化呢,請看下麵正派寫法
// 正經寫法
Student student = new Student();
// 範型寫法
Student<T> student = new Student<>();
// 案例1
Student<String> student = new Student<>();
// 案例2
Student<Integer> student = new Student<>();
// 案例3
Student<Teacher> student = new Student<>();
// 案例4:前面都沒意思,來試試套娃吧,哈哈,走火入魔了沒有,魔功就是魔功,這裡要自己動手,才清晰明瞭
Student<Student<Student<Student<Student<String, Student<String, Long>>, Boolean>, Integer>, String>, Student<String, Integer>> student = new Student<>();
// 案例5:那個最長的,我實在懶得寫了,後面全部用String代替了,這一套寫下來,能不能唬住人。
Student<
String,
BigDecimal,
Integer,
Boolean,
Long,
Double,
Room,
Teacher,
String,
String,
String,
String,
String,
String,
String,
String,
String
> student = new Student<>();
咱就是說,用了魔教功法之後,我們 new 出來的對象,想傳什麼就傳什麼。有多少個範型參數,就傳多少個對象進去。總之就一句話,很強,運用好了,絕對是秒天秒地秒空氣。crud 之內,已然無敵。
泛型介面
看過範型類了,那接下來就是介面。有一說一,範型介面的使用率比範型類高出很多很多
正經介面
public interface Student {
// todo
}
範型介面結構
public interface 介面名<T> {
// todo
}
範型介面
- 兩個參數
public interface Student<T> {
// todo
}
- 兩個參數
public interface Student<S, B> {
// todo
}
- 三個參數
停,就到這裡吧,再寫下去就不禮貌了,容易走火入魔。參數是和類一樣的,可以N個,英文字母不限大小。
對比
// 改造前
public interface Student {
// todo
}
// 改造後
public interface Student<T> {
// todo
}
- 實例化
眾所周知,介面只能用實現介面的方式來實例化,java8之後還能用函數式編程,這裡就不展開來講了
// 正經實現
public class GoodStudent implements Student{
}
// 範型實現
public class GoodStudent<T> implements Student<T>{
}
// 這裡不用 T 可不可以呢,答案是可以的,只要子類和父類的範型一樣就行
public class GoodStudent<B> implements Student<B>{
}
// 實戰1
public class GoodStudent<String> implements Student<String>{
}
// 實戰2
public class GoodStudent<Integer> implements Student<Integer>{
}
// 實戰N,別忘記了我們還能套娃,還能無限火力N,這裡就不演示了
- 那子類和父類的範型不一樣呢,那就編譯器報錯唄
使用方式
那說了那麼多,這個範型有什麼用呢,答案是:介面、類聲明中定義的類型形參則可以在整個介面、類中使用。
可以作為參數類型,入參,返回值使用
- 範型使用
public class GoodStudent<T> implements Student<T>{
// 範型作為參數類型
private T personality;
// 範型介面1,作為入參
public void evaluation(T t){
}
// 範型介面2,作為入參和返回值
public T evaluation2(T t){
return t;
}
}
- 案例參考(比較容易看懂)
// 實例化後很簡單的,一看就懂,這就是我們正常的寫法
public class GoodStudent<String> implements Student<String>{
// 範型參數
private String personality;
public void evaluation(String t){
}
public String evaluation2(String t){
return t;
}
}
// 案例2
public class GoodStudent<Integer> implements Student<Integer>{
// 範型參數
private Integer personality;
public void evaluation(Integer t){
}
public Integer evaluation2(Integer t){
return t;
}
}
- 實例化
public static void main(String[] args) {
// String 類型
GoodStudent<String> goodStudent = new GoodStudent<>();
String personality = "";
goodStudent.evaluation(personality);
String result = goodStudent.evaluation2(personality);
// Integer 類型
GoodStudent<Integer> goodStudent = new GoodStudent<>();
Integer personality = "";
goodStudent.evaluation(personality);
Integer result = goodStudent.evaluation2(personality);
// 套娃類型,我就套一層,不然容易走火入魔
GoodStudent<GoodStudent<String>> goodStudent = new GoodStudent<>();
GoodStudent<String> personality = new GoodStudent<>();
// 內層
String resultString = personality.evaluation2("");
goodStudent.evaluation(personality);
// 外層
GoodStudent<String> result = goodStudent.evaluation2(personality);
}
泛型方法
- 介紹範型方法之前,我們先看看普通方法,我們經常寫的方法就是這樣
正經方法
// 無返回值,無入參
public void test(){
}
// 無返回值,有入參
public void test(String s){
}
// 有返回值,無入參
public String test(){
return "";
}
// 有返回值,有入參
public String test(String s){
return s;
}
範型方法結構
// 範型方法就是加上一個範型聲明
public <泛型類型> 返回類型 方法名(泛型類型 變數名) {
// todo
}
範型演示(註意和之前正常的對比)
// 無返回值,無入參(無意義)
public <T> void test(){
}
// 無返回值,有入參(不常用)
public <T> void test(T s){
}
// 有返回值,無入參(不太常用)
public <T> T test(){
retrn null;
}
// 有返回值,有入參(經常用)
public <T> T test(T s){
return s;
}
案例
- 正經案例
public class GoodStudent implements Student {
// 無返回值,無入參
public void test() {
}
// 無返回值,有入參
public void test2(String s) {
}
// 有返回值,無入參
public String test3() {
return "";
}
// 有返回值,有入參
public String test4(String s) {
return s;
}
}
- 正經調用
public static void main(String[] args) {
GoodStudent goodStudent = new GoodStudent();
goodStudent.test();
String s = "";
goodStudent.test2(s);
String s1 = goodStudent.test3();
String s2 = goodStudent.test4(s);
}
- 範型案例
public class GoodStudent implements Student {
// 無返回值,無入參(無意義)
public <T> void test(){
}
// 無返回值,有入參(不常用)
public <T> void test2(T s){
}
// 有返回值,無入參(不太常用)
public <T> T test3(){
return null;
}
// 有返回值,有入參(經常用)
public <T> T test4(T s){
return s;
}
}
- 範型調用
public static void main(String[] args) {
// String 範型
GoodStudent goodStudent = new GoodStudent();
goodStudent.test();
String s = "";
goodStudent.test2(s);
String s1 = goodStudent.test3();
String s2 = goodStudent.test4(s);
// Integer 範型
GoodStudent goodStudent = new GoodStudent();
goodStudent.test();
Integer s = "";
goodStudent.test2(s);
Integer s1 = goodStudent.test3();
Integer s2 = goodStudent.test4(s);
// Student<String> 範型
GoodStudent goodStudent = new GoodStudent<>();
goodStudent.test();
Student<String> s = new GoodStudent<>();
goodStudent.test2(s);
Student<String> s1 = goodStudent.test3();
Student<String> s2 = goodStudent.test4(s);
}
範型方法是傳什麼參數,就是什麼返回值
泛型通配符(上下界)
你以為這就完了?下麵才是絕殺。
Java泛型的通配符是用於解決泛型之間引用傳遞問題的特殊語法, 主要有以下三類:
- 無邊界的通配符,使用精確的參數類型
- 關鍵字聲明瞭類型的上界,表示參數化的類型可能是所指定的類型,或者是此類型的子類
- 關鍵字聲明瞭類型的下界,表示參數化的類型可能是指定的類型,或者是此類型的父類
無邊界更多是服務於上界和下界的
// 表示類型參數可以是任何類型
public class B<?> {
}
// 上界:表示類型參數必須是A或者是A的子類
public class B<T extends A> {
}
// 下界:表示類型參數必須是A或者是A的超類型
public class B<T supers A> {
}
正常類
public class GoodStudent implements Student{
// String參數
private String personality;
// String 作為入參
public void evaluation(String t){
}
// String作為入參和返回值
public String evaluation2(String t){
return t;
}
}
- 範型類
public class GoodStudent<T> implements Student<T>{
// 範型參數
private T personality;
// 範型介面1,作為入參
public void evaluation(T t){
}
// 範型介面2,作為入參和返回值
public T evaluation2(T t){
return t;
}
}
- 下界範型
public class GoodStudent<T extends String> implements Student<T> {
// 範型參數
private T personality;
// 範型介面1,作為入參
public void evaluation(T t){
}
// 範型介面2,作為入參和返回值
public T evaluation2(T t){
return t;
}
}
到這裡,我已經走火入魔了,後續的後面在寫了,從這裡我們也能看出,一個“正派”的類,經過”魔教“功法範型的改造之後,已經具備一定的複雜性了。這就是 魔功-範型 帶來的威力。
// 改造前
public class GoodStudent implements Student{
// String參數
private String personality;
// String 作為入參
public void evaluation(String t){
}
// String作為入參和返回值
public String evaluation2(String t){
return t;
}
}
// 改造後
public class GoodStudent<T extends String> implements Student<T> {
// 範型參數
private T personality;
// 範型介面1,作為入參
public void evaluation(T t){
}
// 範型介面2,作為入參和返回值
public T evaluation2(T t){
return t;
}
}
作者:天下沒有收費的bug
出處:https://www.cnblogs.com/LoveBB/
本文版權歸作者和博客園共有,歡迎轉載,但未經作者同意必須在文章頁面給出原文鏈接,否則保留追究法律責任的權利。