泛型的定义
泛型,即“参数化类型”。就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。
一些常用的泛型类型变量:
E:元素(Element),多用于java集合框架
K:关键字(Key)
N:数字(Number)
T:类型(Type)
V:值(Value)
泛型类的使用
定义一个泛型类:public class GenericClass{}
package com.jay.java.泛型.DefineGeneric;
/**
* Author:Jay On 2019/5/9 16:49
* <p>
* Description: 泛型类
*/
public class GenericClass<T> {
private T data;
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public static void main(String[] args) {
GenericClass<String> genericClass=new GenericClass<>();
genericClass.setData("Generic Class");
System.out.println(genericClass.getData());
}
}
泛型接口的使用
定义一个泛型接口:public interface GenericIntercace{}
/**
* Author:Jay On 2019/5/9 16:57
* <p>
* Description: 泛型接口
*/
public interface GenericIntercace<T> {
T getData();
}
实现泛型接口方式一:public class ImplGenericInterface1 implements GenericIntercace
/**
* Author:Jay On 2019/5/9 16:59
* <p>
* Description: 泛型接口实现类-泛型类实现方式
*/
public class ImplGenericInterface1<T> implements GenericIntercace<T> {
private T data;
private void setData(T data) {
this.data = data;
}
@Override
public T getData() {
return data;
}
public static void main(String[] args) {
ImplGenericInterface1<String> implGenericInterface1 = new ImplGenericInterface1<>();
implGenericInterface1.setData("Generic Interface1");
System.out.println(implGenericInterface1.getData());
}
}
实现泛型接口方式二:public class ImplGenericInterface2 implements GenericIntercace {}
/**
* Author:Jay On 2019/5/9 17:01
* <p>
* Description: 泛型接口实现类-指定具体类型实现方式
*/
public class ImplGenericInterface2 implements GenericIntercace<String> {
@Override
public String getData() {
return "Generic Interface2";
}
public static void main(String[] args) {
ImplGenericInterface2 implGenericInterface2 = new ImplGenericInterface2();
System.out.println(implGenericInterface2.getData());
}
}
泛型方法的使用
定义一个泛型方法: private static TgenericAdd(T a, T b) {}
/**
* Author:Jay On 2019/5/10 10:46
* <p>
* Description: 泛型方法
*/
public class GenericMethod1 {
private static int add(int a, int b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
}
private static <T> T genericAdd(T a, T b) {
System.out.println(a + "+" + b + "="+a+b);
return a;
}
public static void main(String[] args) {
GenericMethod1.add(1, 2);
GenericMethod1.<String>genericAdd("a", "b");
}
}
/**
1. Author:Jay On 2019/5/10 16:22
2. <p>
3. Description: 泛型方法
*/
public class GenericMethod3 {
static class Animal {
@Override
public String toString() {
return "Animal";
}
}
static class Dog extends Animal {
@Override
public String toString() {
return "Dog";
}
}
static class Fruit {
@Override
public String toString() {
return "Fruit";
}
}
static class GenericClass<T> {
public void show01(T t) {
System.out.println(t.toString());
}
public <T> void show02(T t) {
System.out.println(t.toString());
}
public <K> void show03(K k) {
System.out.println(k.toString());
}
}
public static void main(String[] args) {
Animal animal = new Animal();
Dog dog = new Dog();
Fruit fruit = new Fruit();
GenericClass<Animal> genericClass = new GenericClass<>();
//泛型类在初始化时限制了参数类型
genericClass.show01(dog);
// genericClass.show01(fruit);
//泛型方法的参数类型在使用时指定
genericClass.show02(dog);
genericClass.show02(fruit);
genericClass.<Animal>show03(animal);
genericClass.<Animal>show03(dog);
genericClass.show03(fruit);
// genericClass.<Dog>show03(animal);
}
}
限定泛型类型变量
- 对类的限定:public class TypeLimitForClass<T extends List & Serializable>{}
可以通过extends限定你是某某类的子类,或者实现了某个接口。如果有多个接口可以用&连接,比如<T extends Comparable & Serializable>,如果有多个泛型可以是这样<T extends OneObject, U extends TwoObject>
- 对方法的限定:public static<T extends Comparable>T getMin(T a, T b) {}
通配符类型
- <? extends Parent> 指定了泛型类型的上届
- <? super Child> 指定了泛型类型的下届
- <?> 指定了没有限制的泛型类型