Java之路---Day16(泛型)

2019-11-02-23:25:26

目錄

　　1.泛型的概念:

　　2.泛型的定義和使用:

　　　　2.1定義和使用含有泛型的類：

　　　　2.2定義和使用含有泛型的方法：

　　　　2.3定義和使用含有泛型的介面：

泛型的概念:

　　泛型是一種未知的數據類型,當我門不知道使用什麼數據類型的時候,可以使用泛型,泛型也可以看成是一個變數,用來接受數據類型

　　E e:Element 元素

　　T t:Type 類型

泛型的定義和使用:

　　我們在集合中會大量使用到泛型,用來靈活地將數據類型應用到不同的類、方法、介面當中，將數據類型作為參數進行傳遞

　　定義和使用含有泛型的類：

　　　　修飾符 class 類名<代表泛型的變數>{ }

 1 package demosummary.generic;
 2 
 3 public class GenericClass<E> {
 4     private E name;
 5 
 6     public GenericClass() {
 7     }
 8 
 9     public GenericClass(E name) {
10         this.name = name;
11     }
12 
13     public E getName() {
14         return name;
15     }
16 
17     public void setName(E name) {
18         this.name = name;
19     }
20 
21     @Override
22     public String toString() {
23         return "GenericClass{" +
24                 "name=" + name +
25                 '}';
26     }
27 }

 1 package demosummary.generic;
 2 
 3 public class GenericClassTest {
 4     public static void main(String[] args) {
 5         //不寫泛型則預設為Object類
 6         GenericClass gc = new GenericClass();
 7         gc.setName("預設為Object類");
 8         Object obj = gc.getName();
 9         System.out.println(obj);
10 
11         //使用泛型為Integer類
12         GenericClass<Integer> gci = new GenericClass<>();
13         gci.setName(1);
14         Integer integer = gci.getName();
15         System.out.println(integer);
16     }
17 }

　　定義和使用含有泛型的方法：

　　　　格式：修飾符<泛型> 返回值類型 方法名（參數列表（使用泛型））{

　　　　　　語句體;

　　　　}

　　註意：含有泛型的方法，在調用方法的時候確定泛型的數據類型，傳遞什麼類型的參數，泛型就是什麼類型

 1 package demosummary.generic;
 2 
 3 public class GenericMethod {
 4     //定義一個含有泛型的方法
 5     public <E> void method(E e){
 6         System.out.println(e);
 7     }
 8 
 9     //定義一個含有泛型的靜態方法
10     public static <M> void method01(M m){
11         System.out.println(m);
12     }
13 }

 1 package demosummary.generic;
 2 
 3 public class GenericMethodTest {
 4     public static void main(String[] args) {
 5         //創建一個GenericMethod對象
 6         GenericMethod gm = new GenericMethod();
 7         gm.method(1);//傳入Integer類型
 8         gm.method("字元串");//傳入String類型
 9         gm.method(1.1);//傳入Float類型
10         gm.method(true);//傳入Boolean類型
11 
12         //靜態方法建議通過類名調用
13         GenericMethod.method01(2);//傳入Integer類型
14         GenericMethod.method01("靜態方法");//傳入String類型
15     }
16 }

　　定義和使用含有泛型的介面：

　　　　格式：

　　　　　　修飾符 interface介面名<代表泛型的變數>{ }

 　　　　第一種使用方式：

　　　　　　定義介面的實現類，實現介面，指定介面的泛型

　　　　第二種使用方式：

　　　　　　介面使用什麼泛型，實現類就使用什麼泛型，類跟著介面走

1 package demosummary.generic;
2 //定義一個抽象類
3 public interface GenericInterface<E> {
4     //創建一個抽象方法
5     public void method(E e);
6 }

1 package demosummary.generic;
2 
3 public class GenericInterface01 implements GenericInterface<String>{
4     //重寫抽象方法
5     @Override
6     public void method(String s) {
7         System.out.println(s);
8     }
9 }

1 package demosummary.generic;
2 
3 public class GenericInterface02<E> implements GenericInterface<E>{
4     //重寫抽象類中的抽象方法
5     @Override
6     public void method(E e) {
7         System.out.println(e);
8     }
9 }

 1 package demosummary.generic;
 2 
 3 public class GenericInterfaceTest {
 4     public static void main(String[] args) {
 5         //創建一個GenericInterface01對象,指定實現類泛型為String類型
 6         GenericInterface01 gi01 = new GenericInterface01();
 7         gi01.method("泛型指定為字元串");
 8 
 9         //創建一個GenericInterface02對象,介面泛型為Integer類型,實現類也為Integer類型
10         GenericInterface02<Integer> gi02 = new GenericInterface02<>();
11         gi02.method(2);
12 
13         //創建一個GenericInterface02對象,介面泛型為String類型,實現類也為String類型
14         GenericInterface02<String> gi021 = new GenericInterface02<>();
15         gi021.method("介面為什麼泛型,實現類就是什麼泛型");
16     }
17 }