java泛型知识点总结

硅谷探秘者 2904 0 0

泛型

1.什么是泛型

        Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数

        优点:使用泛型时,在实际使用之前类型就已经确定了,不需要强制类型转换

        泛型主要使用在集合中


2.泛型类定义

package fanxing;
class Node<T>{
         private T t;
         Node(T t){
                  this.setT(t);
         }
         public T getT() {
                  return t;
         }
         public void setT(T t) {
                  this.t = t;
         }
}
public class Generics {
         public static void main(String[] args) {
                  Node<Integer> n=new Node<Integer>(1);
                  System.out.println(n.getT());
         }
}

注意:

    在使用的时候指定实际类型

    泛型不能使用在静态属性上

    泛型不能为基本类型,否则编译时异常


3.自定义接口泛型

interface List<T>{
         public boolean add(T t);
         public T get();
}
 
public class Generics {
         public static void main(String[] args) {
                  new List<Integer>() {
                          @Override
                          public boolean add(Integer t) {
                                   // TODO Auto-generated method stub
                                   return false;
                          }
                          @Override
                          public Integer get() {
                                   // TODO Auto-generated method stub
                                   return null;
                          }
                  };
         }
}

注意:

    接口中泛型字母只能使用在方法中,不能使用在全局常量中


4.定义泛型方法

class Node{
         public <T> T getT(T t){
                  return t;
         }
         public <T extends List<Integer>> void getTs(T t){
                  System.out.println(t);
         }
}
public class Generics {
         public static void main(String[] args) {
                  Node n=new Node();
                  n.getTs(new List<Integer>() {
                          @Override
                          public boolean add(Integer t) {
                                   // TODO Auto-generated method stub
                                   return false;
                          }
                          @Override
                          public Integer get() {
                                   // TODO Auto-generated method stub
                                   return null;
                          }
                  });
         }
}

注意:

    public <T> T getT(T t) 泛型方法,在返回类型前面使用泛型字母

    public <T extends List<Integer>> void getTs(T t) T 只能是List或者List的子类


5.泛型的继承

全部保留父类的泛型
abstract class A<K,V>{
         K k;
         V v;
         public abstract void add(K k,V v);
}
class B<K,V> extends A<K,V>{
         @Override
         public void add(K k,V v) {
                  super.k=k;
                  super.v=v;
         }
}
public class Generics {
         public static void main(String[] args) {
                  B<Integer,String> b=new B<Integer,String>();
         }
}
部分保留父类的泛型
abstract class A<K,V>{
         K k;
         V v;
         public abstract void add(K k,V v);
}
class B<K> extends A<K,String>{
         @Override
         public void add(K k,String v) {
                  super.k=k;
                  super.v=v;
         }
}
public class Generics {
         public static void main(String[] args) {
                  B<Integer> b=new B<Integer>();
         }
}
不保留父类泛型
abstract class A<K,V>{
         K k;
         V v;
         public abstract void add(K k,V v);
}
class B extends A<Integer,String>{
         @Override
         public void add(Integer k,String v) {
                  super.k=k;
                  super.v=v;
         }
}
public class Generics {
         public static void main(String[] args) {
                  B b=new B();
         }
}

6.通配符

    T、K、V、E 等泛型字母为有类型,类型参数赋予具体的值

    ?未知类型 类型参数赋予不确定值,任意类型

    只能用在声明类型、方法参数上,不能用在定义泛型类上

abstract class Node<T>{
         T t;
         abstract public void add(List<?> l);
}
public class Generics {
         public static void main(String[] args) {
                  Node<?> n;
                  n=new Node<Integer>() {
                          @Override
                          public void add(List<?> l) {
                          }
                  };
         }
}



7.extends/super


上限(extends)

    指定的类必须是继承某个类,或者实现了某个接口(不是implements),即<=

    ? extends List

 

下限(super)

    即父类或本身

    ? super List



extends:泛型的上限
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
class Fish extends Animal{}
class SmallDog extends Dog{}
class Node{
         public void add(List<? extends Animal> l) {}
}
public class Generics {
         public static void main(String[] args) {
                  new Node().add(new ArrayList<Animal>());
                  new Node().add(new ArrayList<Dog>());
                  new Node().add(new ArrayList<Cat>());
                  new Node().add(new ArrayList<Fish>());
                  new Node().add(new ArrayList<SmallDog>());
                  //new Node().add(new ArrayList<Object>());
         }
}
supper:泛型的上限
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
class Fish extends Animal{}
class SmallDog extends Dog{}
class Node{
         public void add(List<? super Dog> l) {}
}
public class Generics {
         public static void main(String[] args) {
                  new Node().add(new ArrayList<Animal>());
                  new Node().add(new ArrayList<Dog>());
                  //new Node().add(new ArrayList<SmallDog>());
         }
}



评论区
请写下您的评论...
暂无评论...
猜你喜欢
java基础 1648 参数 抽象类 接口 默认的方法实现 它可以有默认的方法实现 接口完全是抽象的。它根本不存在方法的实现 实现 子类使用extends关键字来继承抽象类。如果子类不是抽象类的话,它需要提供抽象类中所有声明的方法的实现。 子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现 构造器 抽象类可以有构造
算法基础 1978 如果一个类实现了一个接口,如何获取接口中的实际类importjava.lang.reflect.ParameterizedType; importjava.lang.reflect.Type
weblog 1160 成为java架构师需要学习那些原文:https://blog.csdn.net/zuiyingong6567/article/details/80285827既然java架构师,首先你要是一个高
java基础 2528 Java集合框架数据构是以某种形式将数据组织在一起的集合,它不仅存储数据,还支持访问和处理数据的操作。Java提供了几个能有效地组织和操作数据的数据构,这些数据构通常称为Java集合框架。在平
java基础 2869 java常用反射方法以及用法packagereflect;importjava.lang.annotation.ElementType
java基础 2590 走向可分为输入流和输出流,这个走向是以内存为基准的,即往内存中读数据是输入流,从内存中往外写是输出流。根据处理的数据类可分为字节流和字符流1.字节流可以处理所有数据类的数据,在java中以Strea
weblog 3528 本篇文章为红黑树的预备,暂且不涉及节颜色。 二叉树左旋 左旋的过程是将x的右子树绕x逆时针旋转,使得x的右子树成为x的父节,同时修改相关节的引用。旋转之后,二叉查找树的属性仍然满足
official 942 了5、6、7、8号房间。四个人的编号0、1、2、3其实是一个“相对位置”,而各自入住的房间号是一个“绝对位置”。只要道О号同学住的是房号为N的房间,那么M号同学的房号一定是N+M。也就是说,只要道各
归档
2018-11  12 2018-12  33 2019-01  28 2019-02  28 2019-03  32 2019-04  27 2019-05  33 2019-06  6 2019-07  12 2019-08  12 2019-09  21 2019-10  8 2019-11  15 2019-12  25 2020-01  9 2020-02  5 2020-03  16 2020-04  4 2020-06  1 2020-07  7 2020-08  13 2020-09  9 2020-10  5 2020-12  3 2021-01  1 2021-02  5 2021-03  7 2021-04  4 2021-05  4 2021-06  1 2021-07  7 2021-08  2 2021-09  8 2021-10  9 2021-11  16 2021-12  14 2022-01  7 2022-05  1 2022-08  3 2022-09  2 2022-10  2 2022-12  5 2023-01  3 2023-02  1 2023-03  4 2023-04  2 2023-06  3 2023-07  4 2023-08  1 2023-10  1 2024-02  1 2024-03  1 2024-04  1
标签
算法基础 linux 前端 c++ 数据结构 框架 数据库 计算机基础 储备知识 java基础 ASM 其他 深入理解java虚拟机 nginx git 消息中间件 搜索 maven redis docker dubbo vue 导入导出 软件使用 idea插件 协议 无聊的知识 jenkins springboot mqtt协议 keepalived minio mysql ensp 网络基础 xxl-job rabbitmq haproxy srs 音视频 webrtc javascript
目录
没有一个冬天不可逾越,没有一个春天不会来临。最慢的步伐不是跬步,而是徘徊,最快的脚步不是冲刺,而是坚持。