java implement 泛型_Java 中的泛型

泛型的概念

泛型：

泛型是一种末知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型

泛型也可以看成是一个变量用来接收数据类型

E e：Element元素

T t：Type类型

是否使用泛型的对比

不使用泛型

/*** 创建集合对象，不使用泛型

* 好处：

* 集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据。

* 弊端：

* 不安全，会引发异常*/

好处(举例)：

public classDemo01Generic {public static voidmain(String[] args) {//集合不使用泛型

ArrayList arrayList = newArrayList();//向集合中添加数据，用于测试，这里添加了String类型的数据，和int类型的数据

arrayList.add("ABC");

arrayList.add(123);//使用迭代器遍历集合//第一步：获取送代器的实现类对象，并使用Iterator接口接收

Iterator ite =arrayList.iterator();//第二步：使用hasNext方法和next方法遍历集合，取出的元素的类型默认是Object类型

while(ite.hasNext()) {

System.out.println(

ite.next()

);

}

}

}

输出结果：

ABC123

弊端(举例)：

public classDemo02Generic {public static voidmain(String[] args) {

ArrayList arrayList= newArrayList();

arrayList.add("ABC");

arrayList.add(123);

Iterator ite=arrayList.iterator();while(ite.hasNext()) {//取出的数据，默认是Object类型

Object object =ite.next();//假如想使用String特有的length方法来获取字符串的长度，是不可以的//需要将Object类型向下转型为String类型才能使用它的特有方法//但是集合里面还有数据类型是Integer的数据，所以不能进行向下转型为String类型，//如果强行转换，那么在运行是会抛出ClassCastException异常

String string =(String)object;

System.out.println(string.length());

}

}

}

抛出错误：

Exception in thread"main"java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

at XXXXXX.main(Demo02Generic.java:36)

使用泛型

/*** 创建集合对象，使用泛型

* 好处：

* 1、避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型

* 2、把运行期昇常，提升到了编译期

* 弊端：

* 泛型是什么类型,只能存储什么类型的数据*/

好处及弊端(举例)：

importjava.util.ArrayList;importjava.util.Iterator;public classDemo03Generic {public static voidmain(String[] args) {

ArrayList arrayList = new ArrayList<>();

arrayList.add("ABC");//假如添加的数据的类型不是String类型，//那么会抛出错误：方法 java,util.Collection.add(java.lang.String)不适用//arrayList.add(123);

Iterator ite =arrayList.iterator();while(ite.hasNext()) {

String string=ite.next();

System.out.println(

string.length()

);

}

}

}

输出结果：3

定义和使用含有泛型的类

说明

/*** 泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

*

* 定义和使用含有泛型的类：

* 定义格式：

* 修饰符 class 类名称 { . . . }*/

举例

创建一个含有泛型的类

public class GenericClass{privateE name;publicE getName() {returnname;

}public voidsetName(E name) {this.name =name;

}

}

使用这个类

public classDemoGenericClass {public static voidmain(String[] args) {//使用泛型

GenericClass name1 = new GenericClass<>();

name1.setName("使用泛型：这里只能添加指定类型的数据");

String string=name1.getName();

System.out.println(string);//不使用泛型，默认是Object类型

GenericClass name2 = newGenericClass();

name2.setName("不使用泛型：这里能添加不同类型的数据");

Object object=name2.getName();

System.out.println(object);

}

}

输出结果：

使用泛型：这里只能添加指定类型的数据

不使用泛型：这里能添加不同类型的数据

定义和使用含有泛型的方法

说明

/*** 定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间

* 格式:

* 修饰符 返回值类型 方法名(参数列表(使用泛型)){

* 方法体

* };

*

* 含有泛型的方法,在调用方法的时候确定泛型的数据类型

* 传递什么类型的参数,泛型就是什么类型*/

举例

定义含有泛型的方法

public classGenericMethod {/*** 定义一个含有泛型的方法*/

public String method1(W w) {return "一个含有泛型的方法：" +w;

}/*** 定义一个含有泛型的静态方法*/

public static String method2(Z z) {return "一个含有泛型的静态方法：" +z;

}

}

使用这两个方法

public classDemoGenericMethod {public static voidmain(String[] args) {//创建类对象

GenericMethod gm = newGenericMethod();//调用含有泛型的普通方法

System.out.println(

gm.method1(666)

);

System.out.println(

gm.method1("ABC")

);

System.out.println(

gm.method1(0.999)

);//调用含有泛型的静态方法//可以使用gm.method2()来调用静态方法//不推荐使用创建对象来调用静态方法，推荐直接用类名称来调用

System.out.println(

GenericMethod.method2(666)

);

System.out.println(

GenericMethod.method2("ABC")

);

System.out.println(

GenericMethod.method2(0.999)

);

}

}

输出结果：

一个含有泛型的普通方法：666一个含有泛型的普通方法：ABC

一个含有泛型的普通方法：0.999一个含有泛型的静态方法：666一个含有泛型的静态方法：ABC

一个含有泛型的静态方法：0.999

定义和使用含有泛型的接口

说明

/*** 1、含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型

*

* 2、含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走

* 就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型*/

举例1

定义一个含有泛型的接口

public interface GenericInterface{/*** 接口的抽象方法

*@parami 泛型参数*/

public abstract voidmethod(I i);

}

创建接口实现类

public class GenericInterfaceImplement implements GenericInterface{

@Overridepublic voidmethod(String s) {

System.out.println("含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型\n"

+ "这个方法传入指定类型参数是：" +s

);

}

}

测试含有泛型的接口

public classDemoGenericInterfaceImplement {public static voidmain(String[] args) {

GenericInterfaceImplement gii= newGenericInterfaceImplement();

gii.method("666999");

}

}

输出结果：

含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型

这个方法传入指定类型参数是：666999

举例2

创建一个含有泛型的接口

public interface GenericInterface{/*** 接口的抽象方法

*@parami 泛型参数*/

public abstract voidmethod(I i);

}

创建接口的实现类

public class GenericInterfaceImplement implements GenericInterface{

@Overridepublic voidmethod(I i) {

System.out.println("含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走\n"

+ "创建对象的时候传入指定类型参数是：" +i

);

}

}

测试含有泛型的接口

public classDemoGenericInterfaceImplement {public static voidmain(String[] args) {

GenericInterfaceImplement01 gii = new GenericInterfaceImplement01<>();

gii.method(2020);

}

}

泛型通配符

说明

/*** 通配符基本使用泛型的通配：不知道使用什么类型来接收的时候，此时可以使用?，?表示未知通配符，即：表示任意的数据类型。

* 使用方式：

* 不能创建对象使用，只能作为方法的参数使用。

* 注意：

* 一但使用泛型的通配符，那么，只能使用Object类中的共性方法，集合中元素的自身方法无法使用。

**/

举例

创建一个遍历集合的方法

public classIteratorArrayList {//由于不知道接收的ArrayList的数据是什么类型，所以使用泛型通配符?

public static void printArrayList(ArrayList>arrayList) {//使用迭代器遍历集合

Iterator> ite =arrayList.iterator();while(ite.hasNext()) {//next()方法取出的元素是Object，可以接收任意的数据类型

Object object =ite.next();

System.out.println(object);

}

}

}

测试这个方法

public classDemoIteratorArrayList {public static voidmain(String[] args) {//Integer类型数据

ArrayList arrayList1 = new ArrayList<>();

arrayList1.add(1);

arrayList1.add(2);

arrayList1.add(3);

arrayList1.add(4);

arrayList1.add(5);//遍历Integer数据类型的集合

IteratorArrayList.printArrayList(arrayList1);

System.out.println("==========================================");//String数据类型

ArrayList arrayList2 = new ArrayList<>();

arrayList2.add("一号元素");

arrayList2.add("二号元素");

arrayList2.add("三号元素");

arrayList2.add("四号元素");

arrayList2.add("五号元素");//遍历String数据类型的集合

IteratorArrayList.printArrayList(arrayList2);

}

}

输出结果：1

2

3

4

5

==========================================一号元素

二号元素

三号元素

四号元素

五号元素