泛型

泛型方法

需求：写一个函数，调用者传递什么类型的变量，该函数就返回什么类型的变量？

实现一:

由于无法确定具体传递什么类型的数据.那么方法的形参就定义为Object类型.返回值也就是Object类型.但是使用该函数时需要强制类型转换.

private Object getDate(Object obj) { return obj; }

 

当不进行强制类型转换能否写出该功能.?

 

目前所学的知识无法解决该问题

就需要使用泛型类解决

使用的泛型的自定义来解决以上问题。

泛型： 就是将类型当作变量处理。规范泛型的定义一般是一个大写的任意字母。

 

 函数上的泛型定义

   当函数中使用了一个不明确的数据类型，那么在函数上就可以进行泛型的定义。

public <泛型的声明> 返回值类型  函数名( 泛型 变量名  ){}

 

public static void main(String[] args) { int[] arr = { 1, 2, 3, 4, 5 };   new Demo6().getData(5);   }   public <T> T getData(T data) { return data; }

 

细节：

使用泛型方法前需要进行泛型声明，使用一对尖括号 <泛型>，声明的位置在static后返回值类型前。

当一个类中有多个函数声明了泛型，那么该泛型的声明可以声明在类上。

格式

 类上的泛型声明

 修饰符 class 类名<泛型>{}

 

import java.util.Arrays;   public class Demo6<T> { public static void main(String[] args) { // 使用泛型类，创建对象的时候需要指定具体的类型 new Demo6<Integer>().getData(5); }   public T getData(T data) { return data; }   // 反序任意类型数组 public void reverse(T[] arr) { int start = 0; int end = arr.length - 1; for (int i = 0; i < arr.length; i++) { if (start < end) { T temp = arr[start]; arr[start] = arr[end]; arr[end] = temp; } }   }

 

在泛型类中定义一个静态方法

public class Demo6<T> { public static void main(String[] args) { System.out.println(getData2(100)); }   public T getData(T data) { return data; }   //静态方法 public static T getData2(T data) { return data; }   }

 

注意：静态方法不可以使用类中定义的泛型

因为类中的泛型需要在对象初始化时指定具体的类型，而静态优先于对象存在。那么类中的静态方法就需要单独进行泛型声明，声明泛型一定要写在static后，返回值类型之前

泛型类细节：

1、创建对象的时候要指定泛型的具体类型 2、创建对象时可以不指定泛型的具体类型(和创建集合对象一眼)。默认是Object，例如我们使用集合存储元素的时候没有使用泛型就是那么参数的类型就是Object 3、类上面声明的泛型只能应用于非静态成员函数，如果静态函数需要使用泛型，那么 需要在函数上独立声明。 4、如果建立对象后指定了泛型的具体类型，那么该对象操作方法时，这些方法只能操作一种数据类型。 5、所以既可以在类上的泛型声明，也可以在同时在该类的方法中声明泛型。

 

泛型练习：

定义泛型成员

public class Demo7 { public static void main(String[] args) { Father<String> f = new Father<String>("jack"); System.out.println(f.getT()); Father<Integer> f2 = new Father<Integer>(20); System.out.println(f2.getT()); }   }   class Father<T> { private T t;   public Father() {   }   public Father(T t) { super(); this.t = t; }   public T getT() { return t; }   public void setT(T t) { this.t = t; }   }

 

如果Father类有子类，子类该如何实现

public class Demo7 { public static void main(String[] args) { Father<String> f = new Father<String>("jack"); System.out.println(f.getT()); Father<Integer> f2 = new Father<Integer>(20); System.out.println(f2.getT()); }   }   class Father<T> { private T t;   public Father() {   }   public Father(T t) { super(); this.t = t; }   public T getT() { return t; }   public void setT(T t) { this.t = t; }   } //子类指定了具体的类型 class Son extends Father<String>{   } //子类也需要使用泛型 class Son3<T> extends Father<T>{   } //错误写法，父类上定义有泛型需要进行处理 class Son2 extends Father<T>{   }

 

泛型接口

public class Demo8 { public static void main(String[] args) { MyInter<String> my = new MyInter<String>(); my.print("泛型");   MyInter2 my2 = new MyInter2(); my.print("只能传字符串"); } }   interface Inter<T> { void print(T t); }   // 实现不知为何类型时可以这样定义 class MyInter<T> implements Inter<T> { public void print(T t) { System.out.println("myprint:" + t); } } //使用接口时明确具体类型。 class MyInter2 implements Inter<String> {   @Override public void print(String t) { System.out.println("myprint:" + t);   }   }

 

转载于:https://www.cnblogs.com/lb1988/p/6125002.html