![](https://img.laitimes.com/img/__Qf2AjLwojIjJCLyojI0JCLiYWan5SNyYjNyMWMmRjYhJGM3gjNzYzX2AzM0ATM3AzLcFTMyIDMy8CXn9Gbi9CXzV2Zh1WavwVbvNmLvR3YxUjLyM3Lc9CX6MHc0RHaiojIsJye.gif)
個人名片:
🐼作者簡介:一名大一在校生
🐻❄️個人首頁:小新愛學習. 🐼
🕊️系列專欄:零基礎學java ----- 重識c語言 ---- 計算機網絡
🐓每日一句:沒有太晚的開始,隻有過早的放棄
前言:
最近有許多小夥伴問小新有沒有好用的刷題網站,想提升一下自我能力
經過小新缜密的思考與親身體驗,推薦超實用的🎉點選直接通路牛客網🎉
裡面用豐富的大廠面試真題、各類算法由易到難層層遞進、專項題庫應有盡有,還不快來體驗體驗🎏🎏🎏
快來開啟刷題之旅吧!!!
文章目錄
- 泛型
- 1.1 泛型概述:
- 泛型定義格式:
- Demo:
- 總結:
- java 中泛型标記符:
- 1.2 泛型類
- 泛型類的定義格式:
- 泛型類的使用:
- 1.3 泛型方法:
- 泛型方法的定義格式:
- 泛型方法的定義和使用
- 1.4 泛型接口:
- 泛型接口的定義格式:
- 泛型接口的定義和使用
- 1.5 類型通配符
- 代碼示例:
- 1.6 可變參數:
- 代碼示例:
- 歡迎添加微信,加入我的核心小隊,請備注來意
泛型
1.1 泛型概述:
Java 泛型(generics)是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制,該機制允許程式員在編譯時檢測到非法的類型。
泛型的本質是參數化類型,也就是說所操作的資料類型被指定為一個參數。
一提到參數,最熟悉的就是定義方法時有形參,然後調用此方法時傳遞實參,對于參數化類型的了解:
顧名思義:就是将類型由原來的具體的類型參數化,然後在使用/調用時傳入具體的類型
這種參數類型可以用在類,方法和接口中,分别被稱為泛型類,分型方法,泛型接口。
假定我們有這樣一個需求:寫一個排序方法,能夠對整型數組、字元串數組甚至其他任何類型的數組進行排序,該如何實作?
答案是可以使用 Java 泛型。
使用 Java 泛型的概念,我們可以寫一個泛型方法來對一個對象數組排序。然後,調用該泛型方法來對整型數組、浮點數數組、字元串數組等進行排序。
泛型定義格式:
- <類型>:指定一種類型格式。這裡的類型可以是形參
- <類型1,類型2…>:指定多種類型的格式,多種類型之間的用逗号隔開。這裡的類型可以看成是形參
- 将來具體調用時候給定的類型可以看成是實參,并且實參的類型隻能是引用資料類型
Demo:
要求:collection集合存儲字元串并周遊
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
//要求:
public class Demo {
public static void main(String[] args) {
//建立集合對象
//Collection c = new ArrayList();//先不使用泛型
//使用泛型
Collection<String> c = new ArrayList<String>();
//添加元素:
c.add("hello");//向上轉型
c.add("world");
c.add("java");
//c.add(100);//自動封裝為Integer類型,使用泛型可以将編譯器出現的問題提前
//周遊集合(疊代器)
//Iterator t = c.iterator();
Iterator<String> t = c.iterator();//使用泛型不需要強制轉換
while(t.hasNext()) {
//Object obj = t.next();
//String obj = (String)t.next();//向下轉型,變為String類型
String s = t.next();
// ClassCastException
System.out.println(s);
}
}
}
在未指定集合中元素類型的時候,預設是Object類型,因為泛型預設是引用類型,而Object可以代表所有的引用類型
因為添加的時候是Object類型,是以擷取也是
總結:
泛型的好處:
- 把運作時期的問題提前到了編譯時期
- 避免了強制類型轉換
java 中泛型标記符:
- E - Element (在集合中使用,因為集合中存放的是元素)
- T - Type(Java 類)
- K - Key(鍵)
- V - Value(值)
- N - Number(數值類型)
- ? - 表示不确定的 java 類型
1.2 泛型類
概述:
泛型類的聲明和非泛型類的聲明類似,除了在類名後面添加了類型參數聲明部分。
和泛型方法一樣,泛型類的類型參數聲明部分也包含一個或多個類型參數,參數間用逗号隔開。一個泛型參數,也被稱為一個類型變量,是用于指定一個泛型類型名稱的辨別符。因為他們接受一個或多個參數,這些類被稱為參數化的類或參數化的類型。
泛型類的定義格式:
- 格式:修飾符class類名< 類型>{ }
-
範例:public class Generic< T> { }
此處T可以随便寫為任意辨別符,常見的如T,E,K,V等形式的參數常用與表示泛型
泛型類的使用:
public class Generic <T>{
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
public static void main(String[] args) {
Generic<String> g = new Generic<String>();
g.setT("張三");
System.out.println(g.getT());
Generic<Integer> g1 = new Generic<Integer>();
g1.setT(20);
System.out.println(g1.getT());
}
}
控制台輸出:張三 20
1.3 泛型方法:
泛型方法的定義格式:
- 格式:修飾符< 類型> 傳回值類型 方法名(類型 變量名){ }
- 範例:public < T> void show(T t){ }
泛型方法的定義和使用
package com.ithmm_06;
public class Generic <T> {
// public void show(Integer i){
// System.out.println(i);
// }
// public void show(Double d){
// System.out.println(d);
// }
//使用泛型改進方法
// public void show(T t){
// System.out.println(t);
// }
//使用泛型方法改進
public <T> void show(T t){
System.out.println(t);
}
public static void main(String[] args){
// Generic t = new Generic();
// t.show("hello");
// t.show(1);
// t.show(2.0);
//t.show(true);//報錯沒有boolean類型方法
//使用泛型建立對象
// Generic<String> g1 = new Generic<String>();
// g1.show("hello");
//
// Generic<Integer> g2 = new Generic<Integer>();
// g2.show(1);
//
// Generic<Double> g3 = new Generic<Double>();
// g3.show(2.0);
Generic g = new Generic();
g.show("hello");
g.show(1);
g.show(2.0);
}
}
控制台輸出:hello 1 2.0
1.4 泛型接口:
泛型接口的定義格式:
- 格式:修飾符 interface 接口名 < 類型>{ }
- 範例:public interface Generic< T> { }
泛型接口的定義和使用
package com.ithmm_07;
public class Generic {
public static void main(String[] args) {
//測試類
GenericFace<String> g = new GenericImpl<String>();
g.show("Hello");
GenericFace<Integer> g2 = new GenericImpl<Integer>();
g2.show(100);
}
}
interface GenericFace <T> {
void show(T t);
}
class GenericImpl <T> implements GenericFace<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}
控制台輸出:hello 100
1.5 類型通配符
為了表示各種泛型List的父類,可以使用類型通配符
- 類型通配符:<?>
- List<?>:表示元素類型未知的List,他的元素可以比對任何的類型
- 這種帶通配符的List僅僅表示它是個=各種泛型List的父類,并不能把元素添加到其中
如果我們不希望List<?>是任何泛型List的父類,隻希望它代表某一類泛型List的父類,可以使用類型通配符的上限
- 類型通配符的上限:<?extends 類型>
- List<? extends Number>:它表示類型是Number或者其子類型
除了可以指定類型通配符的上限,我們也可以指定類型通配符的下限
- 類型通配符:<?Super 類型>
代碼示例:
package com.ithmm_07;
import java.util.ArrayList;
import java.util.List;
public class GenericDemo {
public static void main(String[] args) {
//類型通配符
List<?> kist1 = new ArrayList<Object>();
List<?> kist2 = new ArrayList<Number>();
List<?> kist3 = new ArrayList<String>();
System.out.println("-------------------");
//類型通配符的上限
// List<? extends Number> lis = new ArrayList<Object>();//報錯
List<?extends Number> list5 = new ArrayList<Integer>();
List<?extends String> list6 = new ArrayList<String>();
//類型通配符下限<? super 類型>
List <? super Number> list7 = new ArrayList<Object>();
List <?super Number> list8 = new ArrayList<Number>();
// List<? super Number> list9 = new ArrayList<Integer>();報錯
}
}
1.6 可變參數:
- 可變參數又稱個數可變,用作方法的形參出現,那麼方法參數個數就是可變的
- 可變參數隻能作為函數的最後一個參數,但其前面可以有也可以沒有任何其他參數
- 由于可變參數必須是最後一個參數,是以一個函數最多隻能有一個可變參數
- Java的可變參數,會被編譯器轉型為一個數組
- 變長參數在編譯為位元組碼後,在方法簽名中就是以數組形态出現的。這兩個方法的簽名是一緻的,不能作為方法的重載。如果同時出現,是不能編譯通過的。可變參數可以相容數組,反之則不成立
- 格式:修飾符 傳回值類型 方法名 (資料類型…變量名){ }
- 範例:public static int sum (int …a){ }
- 這裡的可變參數是一個數組
- 如果一個方法有多個參數,包含可變參數,可變參數要放在最後面
代碼示例:
package com.ithmm_07;
public class ArgDemo01 {
public static void main(String[] args) {
System.out.println(sum(10,20,2,0,5,5));
System.out.println(sum(10,20));
System.out.println(sum(2,5,4,8,8,5,5,5));
}
public static int sum(int ... a){
int sum =0;
for(int i: a){
sum += i;
}
return sum;
}
}