/*
泛型是一个未知的数据类型
创建对象的时候确定泛型的数据类型
*/
public class GenericExercise<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
public class Test {
public static void main(String[] args) {
// 不写泛型默认为object类型
GenericExercise<String> genericExercise = new GenericExercise<>();
genericExercise.setName("亚索");
String name = genericExercise.getName();
System.out.println(name);
}
}
/*
定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间
在传入参数时确定泛型的数据类型
*/
public class GenericExercise<E>{
private E value;
public GenericExercise(E value){
this.value = value;
}
public E getValue() {
return value;
}
public void setValue(E value) {
this.value = value;
}
public void methodOne(E e){
System.out.println(e);
}
// 创建一个静态方法
public static <E> void methodTwo(E e){
System.out.println(e);
}
}
public class Test {
public static void main(String[] args) {
GenericExercise<Integer> genericExercise = new GenericExercise<>(123);
int num = genericExercise.getValue();
GenericExercise.methodTwo("盖伦");
System.out.println(num);
}
}
public interface GenericInterface<E> {
public abstract void methodOne(E e);
}
/*
1、定义接口的实现类,实现接口,指定接口的泛型
2、接口使用寿命泛型,实现类就使用什么泛型,在创建对象的时候确定泛型的数据类型
*/
//public class GenericInterfaceImpl implements GenericInterface<String> {
// @Override
// public void methodOne(String s) {
// System.out.println(s);
// }
//}
public class GenericInterfaceImpl<E> implements GenericInterface<E>{
@Override
public void methodOne(E e) {
System.out.println(e);
}
}
public class Test {
public static void main(String[] args) {
// GenericInterfaceImpl genericInterface = new GenericInterfaceImpl();
// genericInterface.methodOne("亚索");
GenericInterfaceImpl<Integer> genericInterface = new GenericInterfaceImpl<>();
genericInterface.methodOne(123456);
}
}
当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示,但是一旦使用泛型的通配符后,只能使用object类中的共性方法,集合中元素自身方法无法使用。
不能创建对象使用,只能作为方法的参数使用
定义的时候不能使用
import java.util.ArrayList;
import java.util.Iterator;
public class GenericInterrogationExercise {
public static void main(String[] args) {
ArrayList<String> strings = new ArrayList<>();
strings.add("盖伦");
strings.add("亚索");
strings.add("剑圣");
ArrayList<Integer> integers = new ArrayList<>();
integers.add(123);
integers.add(456);
integers.add(789);
printArrayList(strings);
printArrayList(integers);
}
private static void printArrayList(ArrayList<?> list) {
Iterator<?> iterator = list.iterator();
while (iterator.hasNext()){
// 取出的元素是object可以接受任意的数据类型的数据
Object o = iterator.next();
System.out.println(o);
}
}
}
/*
泛型的上限限定 ? extends E 使用的泛型只能是E类型的子类/本身
泛型的下限限定 ? super E 使用的泛型只能是E类型的父类/本身
*/
import java.util.ArrayList;
import java.util.Collection;
public class GenericInterrogationExercise {
public static void main(String[] args) {
Collection<Integer> integersOne = new ArrayList<>();
Collection<String> integersTwo = new ArrayList<>();
Collection<Number> integersThree = new ArrayList<>();
Collection<Object> integersFour = new ArrayList<>();
getElementOne(integersOne);
// getElementOne(integersTwo); // Error
getElementOne(integersThree);
// getElementOne(integersFour); // Error
// getElementTwo(integersOne); // Error
// getElementTwo(integersTwo); // Error
getElementTwo(integersThree);
getElementTwo(integersFour);
/*
Integer extends Number extends Object
String extends Object
*/
}
public static void getElementOne(Collection<? extends Number> collection){ }
public static void getElementTwo(Collection<? super Number> collection){ }
}
原文:https://www.cnblogs.com/saonian450/p/12549578.html