泛型
泛型类派生子类
-
子类是泛型类，那么子类和父类的泛型类型要一致，也就是子类的泛型中必须存在父类的泛型，也就是子类的泛型可以进行扩展，子类的泛型数量多余父类。
-
public class Child<T> extends Father<T>{ @Override public T getMoney() { return super.getMoney(); } } -
public class Child<T,E,K> extends Father<T>{ @Override public T getMoney() { return super.getMoney(); } }
-
-
子类不是泛型类，父类就要明确泛型的数据类型，不能再用T,E,K等字母，因为这是没有明确的。
-
父类不写泛型，默认为Object
public class Child extends Father{ @Override public Object getMoney() { return super.getMoney(); } } -
父类写了明确的泛型，那么子类的类型会和他一样
public class Child extends Father<String>{ @Override public String getMoney() { return super.getMoney(); } }
-
泛型接口
-
泛型接口语法定义
interface 接口名称 <泛型标识，泛型标识......> { 泛型标识 方法名（）； } -
泛型接口的使用（和泛型类的派生类相似）
-
实现类不是泛型类，接口要明确数据类型。
public class son implements Father{ @Override public Object getKey() { return null; } }public class son implements Father<String>{ @Override public String getKey() { return null; } } -
实现类也是泛型类，实现类和接口类的泛型要一致，同样也可以进行扩充
public class son<T> implements Father<T>{ @Override public T getKey() { return null; } }public class son<T,K> implements Father<T>{ private T Key; private K Value; @Override public T getKey() { return Key; } public K getValue(){ return Value; } }
-
泛型方法
泛型类和泛型方法有什么区别呢？
- 泛型类，是在实例化类的时候指明泛型的具体类型。
- 泛型方法，是在调用方法的时候指明泛型的具体类型。
语法：
修饰符<T,K,...>返回值类型 方法名（形参列表）{
方法体
}
- public 和返回值中间 非常重要，可以理解为生命此方法为泛型方法
- 只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法
- 表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T
- 与泛型类的定义一样，此处T可以写成任意标识，常见的如K，T，V，E等形式的参数常用于表示泛型。
public class Product<T> {
Random ran = new Random();
ArrayList<T> list = new ArrayList<>();
public<E> E getProduct(ArrayList<E> list){ //如果不加<E> 其他两个E就会报错，因为这不是一个泛型方法，只能加了<E> 才能表明这是一个泛型方法，其余的两个E才不会报错
return list.get(ran.nextInt(list.size()));
}
public void addList(T item){
list.add(item);
}
public void getProduct(){
System.out.println(list.get(ran.nextInt(list.size())));
}
}
public class demo01{
public static void main(String[] args) {
Product<String> objectProduct = new Product<>();
objectProduct.addList("苹果电脑");
objectProduct.addList("华为手机");
objectProduct.addList("扫地机器人");
objectProduct.getProduct();
ArrayList<Integer> list = new ArrayList<>();
list.add(100);
list.add(200);
System.out.println(objectProduct.getProduct(list));
}
}
类型通配符
什么是类型通配符？
- 类型通配符一般是使用“？”代替具体的类型实参。
- 所以，类型通配符是类型实参，而不是类型形参。
多态作为面向对象的三大特征之一，是不是在泛型上也可以使用多态的做法呢？？（错的）
public class getBox {
public static void main(String[] args) {
Box<Integer> box1 = new Box<>();
box1.setNum(200);
showBox(box1); //报错
Box<Number> box2 = new Box<>();
box2.setNum(100.0);
showBox(box2);
}
public static void showBox(Box<Number> box){
box.getNum();
}
}
通过上面两个例子可以发现，Integer 是Number 的 子类，但是这样写的话，会报错的，也就是泛型不支持多态的写法。
那既然上面这种办法不行，那按照我们之前学习java中学过的重载思想去做这题，我们写好几个相同的方法，只要里面的参数不一样不就行了吗，我把泛型改改是不是就能解决这种问题呢？？？？？？？（错的）
public class getBox {
public static void showBox(Box<Integer> box){ //报错
box.getNum();
}
public static void showBox(Box<Number> box){ //报错
box.getNum();
}
}
咱们之前学过方法的重载，认为只要参数不一样，相同的方法名他就是可以同时存在的，但放到泛型上面，用类似的方法去写，这是不可以的，虽然他们是泛型类型不同，但他们本质上都是相同类型。上面两个例子的本质上都是Box类型，因此他们不能够重载。
以上两种方法 多态和重载 都行不通，这样就大大的限制了泛型的灵活性，那么这个时候 类型通配符 就完美的解决了上面的两个问题。
我们只需要改成 下面这个样子就好
public class getBox {
public static void main(String[] args) {
Box<Integer> box1 = new Box<>();
box1.setNum(200);
showBox(box1);
Box<Number> box2 = new Box<>();
box2.setNum(100.0);
showBox(box2);
}
public static void showBox(Box<?> box){
box.getNum();
}
}
这个样子程序是能够完美运行的，通配符解决了刚刚的两个问题
为什么super叫下限？因为要从指定的参数往上看，extends为何叫上限，因为要从参数往下看。
类型通配符上限
- 语法
类/接口<? extends 实参类型>
要求该泛型类型，只能是实参类型，或实参类型的子类类型
public class getBox {
public static void main(String[] args) {
Box<Integer> box1 = new Box<>();
box1.setNum(200);
showBox(box1);
Box<Number> box2 = new Box<>();
box2.setNum(100.0);
showBox(box2);
}
public static void showBox(Box<? extends Number> box){
box.getNum();
}
}
类型通配符下限
-
语法
类/接口<? super 实参类型> 要求该泛型的类型，只能是实参类型，或实参类型的父类类型。
要求该泛型的类型，只能是实参类型，或实参类型的父类类型。
public class getBox {
public static void main(String[] args) {
Box<Integer> box1 = new Box<>();
box1.setNum(200);
showBox(box1);
Box<Number> box2 = new Box<>();
box2.setNum(100.0);
showBox(box2);
}
public static void showBox(Box<? super Integer> box){
box.getNum();
}
}
类型擦除
概念
泛型是Java1.5版本才引进的概念，在这之前是没有泛型的，但是，泛型代码能够很好的和之前版本的代码兼容，那是因为，泛型信息只存在代码编译阶段，再进去JVM之前，与泛型相关的信息会被擦除掉，我们称之为–类型擦除。
下面就是一个简单的类型擦除
public class demo01 {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
ArrayList<Integer> list2 = new ArrayList<>();
System.out.println(list1.getClass().getSimpleName());//ArrayList
System.out.println(list2.getClass().getSimpleName());//ArrayList
}
}
无限制类型擦除
public class demo01 {
public static void main(String[] args) {
Erasure<Integer> erasure = new Erasure<>();
Class<? extends Erasure> aClass = erasure.getClass();
Field[] declaredFields = aClass.getDeclaredFields();
for(Field i : declaredFields){
System.out.println(i.getName() + ":" + i.getType().getSimpleName());
}
Method[] declaredMethods = aClass.getDeclaredMethods();
for (Method j : declaredMethods){
System.out.println(j.getName() + ":" + j.getReturnType().getSimpleName());
}
}
}
class Erasure<T>{
public T key;
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
}
//key:Object
//getKey:Object
//setKey:void
有限制的类型擦除
public class demo01 {
public static void main(String[] args) {
Erasure<Integer> erasure = new Erasure<>();
Class<? extends Erasure> aClass = erasure.getClass();
Field[] declaredFields = aClass.getDeclaredFields();
for(Field i : declaredFields){
System.out.println(i.getName() + ":" + i.getType().getSimpleName());
}
Method[] declaredMethods = aClass.getDeclaredMethods();
for (Method j : declaredMethods){
System.out.println(j.getName() + ":" + j.getReturnType().getSimpleName());
}
}
}
class Erasure<T extends Number>{
public T key;
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
}
//key:Number
//getKey:Number
//setKey:void
类型擦除，他只会往高处擦除，他不会往低处擦除，如果是用了super，他照样会转换成Obejct
方法的类型擦除
public class demo01 {
public static void main(String[] args) {
Erasure<Integer> erasure = new Erasure<>();
Class<? extends Erasure> aClass = erasure.getClass();
Method[] declaredMethods = aClass.getDeclaredMethods();
for (Method j : declaredMethods){
System.out.println(j.getName() + ":" + j.getReturnType().getSimpleName());
}
}
}
class Erasure<T extends Number>{
public <T extends List> T show(T t){
return t;
}
}
//show:List
桥接方法
不好描述，直接上代码示例
public interface Info<T>{
T info(T var0;
}
public class InfoImpl implements Info<Integer>{
@Overrdie
public Integer info(Integer var){
return var;
}
}
过了编译以后
public interface Info{
Object info(Object var);
}
public class InfoImpl implements Info{
public Integer info(Integer var){
return var;
}
//桥接方法，保持接口和类的实现关系
@Override
public Object info(Object var){
retturn info((Integer)var);
}
}
咱们看一个案例
public interface Box<T> {
T info(T var);
}
public class Tom implements Box<Integer>{
@Override
public Integer info(Integer var) {
return null;
}
}
public class demo01 {
public static void main(String[] args) {
Tom tom = new Tom();
Class<? extends Tom> aClass = tom.getClass();
Method[] declaredMethods = aClass.getDeclaredMethods();
for (Method j : declaredMethods){
System.out.println(j.getName() + ":" + j.getReturnType().getSimpleName());
}
}
}
//info:Integer
//info:Object
泛型与数组
-
可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象
-
可以通过java.lang.reflect.Array的newInstance<Class,int> 创建T[] 数组
-
针对第一句话：可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象
代码如下
public class demo01 {
public static void main(String[] args) {
ArrayList<String>[] arrList = new ArrayList<String>[6]; //报错的
}
}
因为一个数组对象的类型是一直保存下去的，然而泛型是在编译的时候消除掉，他两个相互矛盾，所以就会报错。
那我们怎么去使用泛型数组呢，在使用过程中，我们可能会遇到下面的情况。下面情况就是抛出异常的。
Exception in thread “main” java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
public class demo01 {
public static void main(String[] args) {
ArrayList[] list = new ArrayList[5];
ArrayList<String>[] arrList = list;
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(100);
list1.add(200);
list[0] = list1;
String s = arrList[0].get(0);//在这我们就会发现，他怎么使用String类型接收的，那是因为我们是通过arrList这个引用去拿的，arrList引用是String类型的，所以才会产生这种情况，然而这种情况不是我们想要的结果。此时，在编译阶段，是不会报错的，只有运行后，才会发现错误
System.out.println(s);//在这程序就会报错
}
}
//代码就会报错
//Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot //be cast to java.lang.String
// at demo05.demo01.main(demo01.java:15)
那我们怎么去解决这个问题呢，我们就不要把ArrayList数组的原生引用给暴露出来，因为这样是无法展现泛型的特点（在编译阶段，将错误展现出来）改后的代码如下。
public class demo01 {
public static void main(String[] args) {
ArrayList<String>[] arrList = new ArrayList[5];
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(100);
list1.add(200);
arrList[0] = list1; //报错 因为ArrayList数组是String类型，然而你传入了一个Integer类型的集合，在编译阶段就会检查出来，大大的避免了程序的出错。
String s = arrList[0].get(0);
}
}
因为ArrayList数组是String类型，然而你传入了一个Integer类型的集合，在编译阶段就会检查出来，大大的避免了程序的出错
- 可以通过java.lang.reflect.Array的newInstance<Class,int> 创建T[] 数组
public class Fruit<T> {
private T[] array;
public Fruit(Class<T> clz, int length){
array = (T[]) Array.newInstance(clz,length);
}
public void put(int index,T item){
array[index] = item;
}
public T get(int index){
return array[index];
}
public T[] getArray(){
return array;
}
}
public class demo01 {
public static void main(String[] args) {
Fruit<String> fruit =new Fruit<>(String.class,3);
fruit.put(0,"苹果");
fruit.put(1,"西瓜");
fruit.put(2,"香蕉");
System.out.println(Arrays.toString(fruit.getArray()));
}
}
//[苹果, 西瓜, 香蕉]
169
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
