1.定義和使用含有泛型的類
package generic.demo1;
/**
* 定義一個含有泛型的類，泛型是一個未知的資料類型，當我們不确定什麼資料類型的時候，我們可以使用泛型
* 泛型可以接收任意的資料類型，如Integer,String,Student
* 建立對象的的時候确定泛型的資料類型
* @param <E>
*/
public class Demo01Generic <E>{
private E game;
public E getGame() {
return game;
}
public void setGame(E game) {
this.game = game;
}
}
package generic.demo1;
public class Demo02GenericClass {
public static void main(String[] args) {
//Demo01Generic類不寫泛型，則預設是Object類型
Demo01Generic gc = new Demo01Generic();
gc.setGame("so angry ");
//建立Demo01Generic對象，泛型使用Integer類型
Demo01Generic<Integer> gc2 = new Demo01Generic<>();
gc2.setGame(1);
Integer game = gc2.getGame();
System.out.println(game);
//建立Demo01Generic對象，泛型使用String類型
Demo01Generic<String> gc3 = new Demo01Generic<>();
gc3.setGame("lobster");
String game1 = gc3.getGame();
System.out.println(game1);
}
}
運作結果
2.定義和使用含有泛型的方法
含有泛型的方法的定義格式如下
修飾符<泛型> 傳回值類型 方法名(參數清單(使用泛型)){
//方法體
}
注意：含有泛型的方法在調用的時候确定泛型的資料類型。傳遞什麼類型的參數，泛型就是什麼類型
package generic.demo1;
/**
* 含有泛型的方法
* 含有泛型的方法的定義格式如下
* 修飾符<泛型> 傳回值類型 方法名(參數清單(使用泛型)){
* //方法體
* }
* 注意：含有泛型的方法在調用的時候确定泛型的資料類型。傳遞什麼類型的參數，泛型就是什麼類型
*/
public class GenericMethod {
//定義一個含有泛型的方法
public <M> void method(M m){
System.out.println(m);
}
//定義一個含有泛型的靜态方法
public static <S> void method1(S s){
System.out.println(s);
}
}
package generic.demo1;
/**
* 測試含有泛型的方法
*/
public class Demo03GenericMethod {
public static void main(String[] args) {
//建立一個GenericMethod對象
GenericMethod gc = new GenericMethod();
//調用含有泛型的方法，傳遞什麼類型，泛型就是什麼類型
gc.method(10);
gc.method("abc");
gc.method(8.8);
gc.method(true);
System.out.println("========");
gc.method1("靜态方法，不建議通過建立對象使用，可以用更好的方法");
//靜态方法可以怎麼調用？
//類名.靜态方法名(參數)
GenericMethod.method1("這是一個含有泛型的靜态方法");
GenericMethod.method1(1);
GenericMethod.method1(8.8);
GenericMethod.method1(true);
}
}
運作結果
3.定義和使用含有泛型的接口
案例說明
package generic.demo1;
/**
* 定義一個有泛型的接口
*/
public interface GenericInterface<I> {
public abstract void method(I i);
}
package generic.demo1;
/*
GenericInterface接口的實作類1
*/
public class GenericInterfaceImpl1 implements GenericInterface<String>{
//重寫接口的抽象方法
@Override
public void method(String s) {
System.out.println(s);
}
}
package generic.demo1;
/**
* 含有泛型的接口的實作類2
*/
public class GenericInterfaceImpl2<I> implements GenericInterface<I> {
@Override
public void method(I i) {
System.out.println(i);
}
}
package generic.demo1;
/**
* 測試含有泛型的接口
*/
public class Demo04GenericInterface {
public static void main(String[] args) {
//建立GenericInterfaceImpl1對象
GenericInterfaceImpl1 gci1 = new GenericInterfaceImpl1();
gci1.method("字元串");
//建立GenericInterfaceImpl2對象
GenericInterfaceImpl2<Integer> gci2 = new GenericInterfaceImpl2<>();
gci2.method(10);
GenericInterfaceImpl2<Double> gci3 = new GenericInterfaceImpl2<>();
gci3.method(8.8);
}
}
運作結果