泛型
- 【java|java中的泛型】定义格式：
修饰符 class 类名<代表泛型的变量> {}
- 含有泛型的方法：
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){}
- 含有泛型的接口：
修饰符 interface接口名<代表泛型的变量> {}
/**
* 泛型（jdk5引入新特性）
* 编译期间检查类型
* 减少类型转换
* 泛型本质就是参数化类型，也就是所操作的基本数据类型被指定为一个参数
*//**
* 泛型类的定义
* @param 泛型标识一类型参数
*T 创建对象时指定具体的参数类型
*/
public class Generics {//T 是由外部使用类的时候来调用
//声明成员变量生成get/set 构造方法 toString
privateT 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 g1 = new Generics("abc");
String key1 = g1.getKey();
System.out.println("key1:"+key1);
System.out.println("---------------------------------");
Generics g2 = new Generics(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 p1= new ProudctGetter<>();
ArrayList 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 {
Random random=new Random();
//奖品
privateT proudct;
//奖品集合
ArrayList list=new ArrayList<>();
//添加奖品
publicvoid 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){
returnlist.get(random.nextInt(list.size()));
}*/public T getRoudct(ArrayList list){
returnlist.get(random.nextInt(list.size()));
}
//静态泛型方法
public static 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 void pr2(E... e){for (int i = 0;
i 类型通配符
/**
* 类型通配符
*？ 类型代替是类型实参
* 所以，类型通配符是类型实参，而不是类型形参
* 类/接口
*//**
* 类形通配符上限
* 类/接口
*/
public class Test {
public static void main(String[] args) {
Box box=new Box<>();
box.setE(1000);
showbox(box);
Box box1=new Box<>();
box.setE(2000);
showbox(box1);
}public static void showbox(Box box){
Object first=box.getE();
System.out.println(first);
}
}
public class Box {
privateE 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=new ArrayList<>();
ArrayList cat=new ArrayList<>();
ArrayList min=new ArrayList<>();
/**上限通配符，
* //showAnimal(animal);
*showAnimal(cat);
* showAnimal(min);
*/
/*
下限通配符
showAnimal1(animal);
showAnimal1(cat);
showAnimal1(min);
*/
}/**
* 泛型类上限通配符，传递集合类型，只能是cat或者cat子类类型
* @param list
*/
public static void showAnimal(ArrayList list){
for (int i = 0;
i list){
for (Object o:list) {
System.out.println(o);
}}
}
public class MinextendsCat{
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 CatextendsAnimal{
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 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 {
@Override
public int compare(Animal o1, Animal o2) {
return o1.name.compareTo(o2.name);
}
}
class Comparatorl2 implements Comparator {
@Override
public int compare(Cat o1, Cat o2) {
return o1.age-o2.age;
}
}
class Comparatorl3 implements Comparator {
@Override
public int compare(Min o1, Min o2) {
return o1.lave-o2.lave;
}
}
泛型擦除
import java.util.List;
public class Earsure {
private T key;
public T getKey() {
return key;
}public void setKey(T key) {
this.key = key;
}/**
* 泛型方法
* @param t
* @param
* @return
*/
public T ss(T t){
return t;
}
}
public interface Info {
T info(T var);
}
public class InfoImpl implementsInfo {@Override
public Integer info(Integer var) {
return var;
}
} /**
* 泛型擦除
*/
public class Test {
public static void main(String[] args) {
ArrayList integerArrayList=new ArrayList<>();
ArrayList 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 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 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 [] list=new ArrayList[5];
ArrayListintegerArrayList=new ArrayList<>();
integerArrayList.add(100);
ArrayListlist1=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 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{
// 1.0 创建一个T类型的数组
privateT[] arry;
public FruIt(Class clz,int length) {
//2.0通过Array.newInstance 创建泛型数组
arry= (T[]) Array.newInstance(clz,length);
}
//3.0填充数组
publicvoidput(int index,T item){
arry[index]=item;
}
//4.0获取数组
public T get(int index){
return arry[index];
}
public T[] getArry(){
return arry;
}
} 推荐阅读
- YY|【C语言】计算器
- Java中for(;;)和while(true)的区别
- MongoDB 分片规则
- java动态构建数据库复杂查询教程
- JAVA难点理解|（JAVA）: 自定义枚举和enum枚举类型------详解。
- 计算机网络（王道考研）|3.4计算机网络（局域网基本概念和体系结构 以太网 ）
- 大数据|前后端分离架构中的接口安全_如何立即确保您的应用架构安全（分离，配置和访问）
- 操作系统（王道考研）|2.7操作系统（读者—写者问题 哲学家进餐问题 管程 ）
- CSC1001编程方法