java中的泛型
泛型
-
定义格式：
修饰符 class 类名<代表泛型的变量> { } -
含有泛型的方法：
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ } -
含有泛型的接口：
修饰符 interface接口名<代表泛型的变量> { }
自定义泛型
/**
* 泛型（jdk5引入新特性）
* 编译期间检查类型
* 减少类型转换
* 泛型本质就是参数化类型，也就是所操作的基本数据类型被指定为一个参数
*/
/**
* 泛型类的定义
* @param 泛型标识一类型参数
* T 创建对象时指定具体的参数类型
*/
public class Generics<T> {
//T 是由外部使用类的时候来调用
//声明成员变量 生成get/set 构造方法 toString
private T key;
public Generics() {
}
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
public Generics(T key) {
this.key = key;
}
@Override
public String toString() {
return "Generics{" +
"key=" + key +
'}';
}
}
public class MainClass {
//泛型类，不支持基本数据类型
public static void main(String[] args) {
//泛型类在创建对象时，来指定具体数据类型
Generics<String> g1 = new Generics<String>("abc");
String key1 = g1.getKey();
System.out.println("key1:"+key1);
System.out.println("---------------------------------");
Generics<Integer> g2 = new Generics<Integer>(11);
Integer key2 = g2.getKey();
System.out.println("key2:"+key2);
System.out.println("---------------------------------");
//泛型类在创建对象时，没有来指定具体数据类型，将按照object类型来操作
Generics g3= new Generics("abc");
Object key3 = g3.getKey();
System.out.println("key3:"+key3);
System.out.println("---------------------------------");
//同一泛型类，根据不同数据类型创建任务，本质是同一类型
System.out.println(g1.getClass());
System.out.println(g2.getClass());
System.out.println(g3.getClass());
}
泛型注意
从泛型类派生子类
1.子类也是泛型类，子类要求和父类泛型类型一致
2.子类不是泛型类，父类的泛型类型要明确
从泛型接口派生子类
1.子类也是泛型类，子类要求和父类泛型类型一致
2.子类不是泛型类，父类的泛型类型要明确
可变参数&静态泛型方法
import java.util.ArrayList;
//泛型类中成员方法不能为static
//泛型方法能使方法独立于类而产生变化
//如果static方法要使用泛型能力，就必须使其成为泛型方法
public class Test {
public static void main(String[] args) {
ProudctGetter<Integer> p1= new ProudctGetter<>();
ArrayList<String> sl=new ArrayList<>();
sl.add("aaa");
sl.add("bbb");
sl.add("ccc");
//泛型方法的调用，类型是通过调用方法的时候来指定
String roudct = p1.getRoudct(sl);
System.out.println(roudct+"\t"+roudct.getClass().getSimpleName());
System.out.println("-------------------");
//静态泛型调用
ProudctGetter.pr(100,true,"sss");
System.out.println("-------------------");
//泛型可变参数调用
ProudctGetter.pr2(1,true,"ss");
}
}
import java.util.ArrayList;
import java.util.Random;
public class ProudctGetter<T> {
Random random=new Random();
//奖品
private T proudct;
//奖品集合
ArrayList<T> list=new ArrayList<>();
//添加奖品
public void addProudct(T t) {
list.add(t);
}
//抽奖
public T getRoudct(){
proudct= list.get(random.nextInt(list.size()));
return proudct;
}
//泛型方法 list 参数 E 泛型参数
/* public E getRoudct(ArrayList list){
return list.get(random.nextInt(list.size()));
}*/
public <T> T getRoudct(ArrayList<T> list){
return list.get(random.nextInt(list.size()));
}
//静态泛型方法
public static <T,E,K> void pr(T t,E e,K k){
System.out.println(t+"\t"+t.getClass().getSimpleName());
System.out.println(e+"\t"+e.getClass().getSimpleName());
System.out.println(k+"\t"+k.getClass().getSimpleName());
}
//泛型可变参数
public static <E> void pr2(E... e){
for (int i = 0; i <e.length ; i++) {
System.out.println(e[i]);
}
}
}
类型通配符
/**
* 类型通配符
*？ 类型代替是类型实参
* 所以，类型通配符是类型实参，而不是类型形参
* 类/接口
*/
/**
* 类形通配符上限
* 类/接口
*/
public class Test {
public static void main(String[] args) {
Box<Number> box=new Box<>();
box.setE(1000);
showbox(box);
Box<Integer> box1=new Box<>();
box.setE(2000);
showbox(box1);
}
public static void showbox(Box<? extends Number> box){
Object first=box.getE();
System.out.println(first);
}
}
public class Box<E> {
private E e;
public E getE() {
return e;
}
public void setE(E e) {
this.e = e;
}
}
类型通配符上限&下限
import java.util.ArrayList;
/**
* 类型通配符
*/
/**
* 类型通配符上限
* 类/接口
* 类型通配符下限
* 类/接口
*/
public class Test {
public static void main(String[] args) {
ArrayList<Animal> animal=new ArrayList<>();
ArrayList<Cat> cat=new ArrayList<>();
ArrayList<Min> min=new ArrayList<>();
/**上限通配符，
* //showAnimal(animal);
* showAnimal(cat);
* showAnimal(min);
*/
/*
下限通配符
showAnimal1(animal);
showAnimal1(cat);
showAnimal1(min);
*/
}
/**
* 泛型类上限通配符，传递集合类型，只能是cat或者cat子类类型
* @param list
*/
public static void showAnimal(ArrayList<? extends Cat> list){
for (int i = 0; i <list.size() ; i++) {
Cat cat = list.get(i);
System.out.println(cat);
}
}
/**
* 泛型类下限通配符，传递集合类型，只能是cat或者cat父类类型
* @param list
*/
public static void showAnimal1(ArrayList<? super Cat> list){
for (Object o:list) {
System.out.println(o);
}
}
}
public class Min extends Cat{
public int lave;
@Override
public String toString() {
return "Min{" +
"lave=" + lave +
'}';
}
public Min(String name, int age, int lave) {
super(name, age);
this.lave = lave;
}
}
public class Cat extends Animal{
public int age;
public Cat(String name, int age) {
super(name);
this.age = age;
}
@Override
public String toString() {
return "Cat{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
public class Animal{
public String name;
public Animal(String name) {
this.name = name;
}
@Override
public String toString() {
return "Animal{" +
"name='" + name + '\'' +
'}';
}
}
import java.util.Comparator;
import java.util.TreeSet;
public class Test2 {
public static void main(String[] args) {
TreeSet<Cat> tc=new TreeSet<>(new Comparatorl2());
//TreeSet tc=new TreeSet<>(new Comparatorl());
tc.add(new Cat("aa",31));
tc.add(new Cat("ab",1));
tc.add(new Cat("ac",33));
for (Cat cat : tc) {
System.out.println(cat);
}
}
}
class Comparatorl implements Comparator<Animal> {
@Override
public int compare(Animal o1, Animal o2) {
return o1.name.compareTo(o2.name);
}
}
class Comparatorl2 implements Comparator<Cat> {
@Override
public int compare(Cat o1, Cat o2) {
return o1.age-o2.age;
}
}
class Comparatorl3 implements Comparator<Min> {
@Override
public int compare(Min o1, Min o2) {
return o1.lave-o2.lave;
}
}
泛型擦除
import java.util.List;
public class Earsure<T extends Number> {
private T key;
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
/**
* 泛型方法
* @param t
* @param
* @return
*/
public <T extends List> T ss(T t){
return t;
}
}
public interface Info<T> {
T info(T var);
}
public class InfoImpl implements Info<Integer> {
@Override
public Integer info(Integer var) {
return var;
}
}
/**
* 泛型擦除
*/
public class Test {
public static void main(String[] args) {
ArrayList<Integer> integerArrayList=new ArrayList<>();
ArrayList<String> StringArrayList=new ArrayList<>();
System.out.println(integerArrayList.getClass().getSimpleName());
System.out.println(StringArrayList.getClass().getSimpleName());
}
}
/**
* 无限制类型擦除
* Earsure
*/
/**
* 有限制类型擦除
* Earsure
*/
/**
* 擦除方法中定义的参数
* 与上面类似
*/
public class Test2 {
public static void main(String[] args) {
Earsure<Integer> earsure=new Earsure();
//利用反射，获取Earsure的字节码文件的所有class对象
Class c=earsure.getClass();
//获取所有对象
Field[] declaredFields = c.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField.getName()+" >>"+declaredField.getType().getSimpleName());
}
System.out.println("------------------------------------------");
//利用反射获取方法
Method[] declaredMethods = c.getDeclaredMethods();
System.out.println("方法名"+" "+"返回值类型");
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod.getName()+" >>"+declaredMethod.getReturnType().getSimpleName());
}
System.out.println("------------------------------------------");
/**
* 桥接方法，为了保持接口和类的实现关系
*/
Class<InfoImpl> infoClass = InfoImpl.class;
Method[] declaredMethods1 = infoClass.getDeclaredMethods();
System.out.println("方法名"+" "+"返回值类型");
for (Method method : declaredMethods1) {
System.out.println(method.getName()+" >>"+method.getReturnType().getSimpleName());
}
}
}
创建泛型的数组
/**
* 泛型数组
*/
public class Test {
public static void main(String[] args) {
//1.0可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象
// ArrayList [] list=new ArrayList[5];
//不安全的
// ArrayList [] list=new ArrayList[5]; //不安全的
// ArrayList [] listArr=list; //不安全的
ArrayList<String> [] list=new ArrayList[5];
ArrayList<Integer> integerArrayList=new ArrayList<>();
integerArrayList.add(100);
ArrayList<String>list1=new ArrayList<>();
list1.add("adc");
list[0]=list1;
/* list[0]=integerArrayList;
String s = listArr[0].get(0);
System.out.println(s);*/
System.out.println(list[0].get(0));
System.out.println("----------------------------");
//通过import java.lang.reflect.Array的newInstance(Class clz,int length) 创建T数组
FruIt<String> fruIt=new FruIt<>(String.class,3);
fruIt.put(0,"水果");
fruIt.put(1,"手雷");
fruIt.put(2,"海洋");
//遍历
System.out.println(Arrays.toString(fruIt.getArry()));
String s = fruIt.get(2);
System.out.println(s);
}
}
import java.lang.reflect.Array;
public class FruIt<T>{
// 1.0 创建一个T类型的数组
private T[] arry;
public FruIt(Class<T> clz,int length) {
//2.0通过Array.newInstance 创建泛型数组
arry= (T[]) Array.newInstance(clz,length);
}
//3.0填充数组
public void put(int index,T item){
arry[index]=item;
}
//4.0获取数组
public T get(int index){
return arry[index];
}
public T[] getArry(){
return arry;
}
}