如果我們需要產生多個對象，每個對象的邏輯完全一樣，只是對象內的成員變數的類型不同。那麼我們該如何去做？ ① 創建多個類文件，給每個類中的成員變數設置指定的數據類型; 1 public class Demo1{ 2 public static void main(String []args){ 3 M ...
如果我們需要產生多個對象，每個對象的邏輯完全一樣，只是對象內的成員變數的類型不同。那麼我們該如何去做？
① 創建多個類文件，給每個類中的成員變數設置指定的數據類型;
1 public class Demo1{
2 public static void main(String []args){
3 MyClass1 myclass1=new MyClass1("張三");
4 System.out.println(myclass1.getData());
5 MyClass2 myclass2=new MyClass2(10);
6 System.out.println(myclass2.getData());
7 }
8 }
9
10 class MyClass1{
11 private String data;
12 public MyClass1(String data){
13 this.data=data;
14 }
15
16 public void setData(String data){
17 this.data=data;
18 }
19 public String getData(){
20 return data;
21 }
22 }
23
24 class MyClass2{
25 private int data;
26 public MyClass2(int data){
27 this.data=data;
28 }
29
30 public void setData(int data){
31 this.data=data;
32 }
33 public int getData(){
34 return data;
35 }
36 }
View Code
缺點：這種方式會導致類的膨脹，重用性太差;
① 創建一個類文件，給這個類中的成員變數設置Object數據類型;
1 public class Demo11{
2 public static void main(String []args){
3 MyClass myClass1=new MyClass("張三");
4 System.out.println((String)myClass1.getData());
5 MyClass myClass2=new MyClass(10);
6 System.out.println((Integer)myClass2.getData());
7 //以上可以執行
8 //但int類型不能裝換為String類型
9 System.out.println((String)myClass2.getData());
10 }
11 }
12
13 class MyClass{
14 private Object data;
15 public MyClass(Object data){
16 this.data=data;
17 }
18
19 public void setData(Object data){
20 this.data=data;
21 }
22 public Object getData(){
23 return data;
24 }
25 }
View Code
缺點：編譯時正常，但運行時可能會異常;
泛型類就能解決以上兩個問題;
泛型簡介
① 泛型是JDK4.5引入的新特性，也是最重要的一個特性;
② 泛型可以再編譯的時候檢查類型安全，並且所有的強制轉換都是自動和隱式的;
③ 泛型的原理就是“類型的參數化”，即把類型看作參數。也就是說把所要操作的數據類型看作參數，就像方法的形式參數是運行時傳遞的值的占位符一樣;
④ 簡單的說，類型變數扮演的角色就如同一個參數，它提供給編譯器用來類型檢查的信息;
⑤ 泛型可以提高代碼的擴展性和重用性;
總結：所謂泛型，即通過參數化類型來實現在同一份代碼上操作多種數據類型，泛型編程是一種編程範式，它利用“參數化類型”將類型抽象化，從而實現更為靈活的復用;
泛型類示例：
1 public class GenClass <T>{
2 private T obj;
3 public GenClass(T obj){
4 this.obj=obj;
5 }
6 public T getObj(){
7 return obj;
8 }
9 public void setObj(T obj){
10 this.obj=obj;
11 }
12 }
T代表類型，比如Integer，String
用泛型類解決以上問題
1 public class GenericDemo1{
2 public static void main(String []args){
3 //創建一個泛型類對象
4 GenClass<String> gen1=new GenClass<String>("張三");
5 System.out.println(gen1.getData());
6 GenClass<Integer> gen2=new GenClass<Integer>(10);
7 System.out.println(gen2.getData());
8 //使用了泛型之後再做強制類型轉換編譯無法通過
9 //System.out.println((String)gen2.getData());
10 }
11 }
12
13 //創建一個泛型類
14 class GenClass<T>{
15 private T data;
16 public GenClass(T data){
17 this.data=data;
18 }
19
20 public void setData(T data){
21 this.data=data;
22 }
23 public T getData(){
24 return data;
25 }
26 }
View Code
泛型的用法
① 泛型的參數類型可以使泛型類;
1 public class GenericDemo1{
2 public static void main(String []args){
3 //一個泛型類作為另一個泛型類的參數
4 GenClass<GenClass<Student>> gen1=new GenClass<GenClass<Student>>();
5 GenClass<Student> gen2=new GenClass<Student>();
6 gen2.setData(new Student("張三"));
7 gen1.setData(gen2);
8
9 System.out.println(gen1.getData().getData());
10 }
11 }
12
13 //創建一個泛型類
14 class GenClass<T>{
15 private T data;
16 public GenClass(){
17
18 }
19 public GenClass(T data){
20 this.data=data;
21 }
22
23 public void setData(T data){
24 this.data=data;
25 }
26 public T getData(){
27 return data;
28 }
29 }
30
31 class Student{
32 private String name;
33 public Student(String name){
34 this.name=name;
35 }
36 public String toString(){
37 return "我是："+name;
38 }
39 }
View Code
② 泛型類可以同時設置多個類型參數;
1 public class GenericDemo1{
2 public static void main(String []args){
3 //帶2個參數的泛型
4 GenClass2<String,Integer> gen1=new GenClass2<String,Integer>("張三",20);
5 System.out.println(gen1.getData1());
6 System.out.println(gen1.getData2());
7 }
8 }
9
10 class GenClass2<T1,T2>{
11 private T1 data1;
12 private T2 data2;
13 public GenClass2(T1 data1,T2 data2){
14 this.data1=data1;
15 this.data2=data2;
16 }
17 public T1 getData1(){
18 return data1;
19 }
20 public T2 getData2(){
21 return data2;
22 }
23 }
View Code
③ 泛型類可以繼承泛型類;
1 public class GenericDemo2{
2 public static void main(String []args){
3 //一個泛型類繼承另一個泛型類
4 SubClass<String,Integer> sub=new SubClass<String,Integer>("張三",20);
5 System.out.println(sub.show1());
6 }
7 }
8
9 class SuperClass<T1>{
10 private T1 var1;
11 public SuperClass(T1 var1){
12 this.var1=var1;
13 }
14
15 public T1 show1(){
16 return var1;
17 }
18 }
19
20 class SubClass<T1,T2> extends SuperClass<T1>{
21 private T2 var2;
22 public SubClass(T1 var1,T2 var2){
23 super(var1);
24 this.var2=var2;
25 }
26 //重寫父類的方法
27 public T1 show1(){
28 return super.show1();
29 }
30 }
View Code
④泛型類可以實現泛型介面;
1 public class GenericDemo2{
2 public static void main(String []args){
3 //一個泛型類繼承另一個泛型類
4 SubClass<String,Integer> sub=new SubClass<String,Integer>("張三",20);
5 System.out.println(sub.show1());
6 //實現介面的方法
7 sub.show2(100);
8 }
9 }
10
11 class SuperClass<T1>{
12 private T1 var1;
13 public SuperClass(T1 var1){
14 this.var1=var1;
15 }
16
17 public T1 show1(){
18 return var1;
19 }
20 }
21
22 interface IInfo<T2>{
23 public void show2(T2 var3);
24 }
25
26 class SubClass<T1,T2> extends SuperClass<T1> implements IInfo<T2>{
27 private T2 var2;
28 public SubClass(T1 var1,T2 var2){
29 super(var1);
30 this.var2=var2;
31 }
32 //重寫父類的方法
33 public T1 show1(){
34 return super.show1();
35 }
36 //實現介面的方法
37 public void show2(T2 var3){
38 System.out.println(var3);
39 System.out.println(var2);
40 //雖然都是Integer類型，但泛型會先將其轉為Object類型，所以不能相加
41 //System.out.println(var2+var3);
42 }
43 }
View Code
