【java基础】泛型

最新推荐文章于 2021-11-10 15:23:11 发布
最新推荐文章于 2021-11-10 15:23:11 发布
阅读量202 收藏
点赞数
分类专栏： Java学习笔记 文章标签： java
原文链接：http://www.itheima.com/
版权

泛型

泛型类

  • 简单泛型类
public class Parent<E> {
    private E key;

    public Parent(E key) {
        this.key = key;
    }

     /**
     * 此方法并不是泛型方法，只是使用了类的泛型
     */
    public E getKey(){
        return key;
    }

    /**
     * 此方法并不是泛型方法，只是使用了类的泛型
     * @param key
     */
    public void setKey(E key) {
        this.key = key;
    }
}
子类继承泛型父类
  • 不指定父类泛型，默认为Object
public class Child<T> extends Parent{
    
    public Child(Object key) {
        super(key);
    }

    @Override
    public Object getKey() {
        return super.getKey();
    }
}
  • 不指定子类泛型，则需要直接指定父类泛型类型
/*
 * 子类不指定泛型，需直接指定父类泛型类型
 */
public class Child extends Parent<String>{
    public Child(String key) {
        super(key);
    }

    @Override
    public String getKey() {
        return super.getKey();
    }
}
  • 指定子类泛型需与父类泛型保持一致
/**
 * 父类泛型需和子类泛型一致，
 * 虽然Parent中泛型等于E，但这里子类定义泛型为T 也需把父类泛型写成T，
 * 定义子类继承父类时，泛型需保持一致，相当于把T当成类型传递给父类使用
 */
public class Child<T> extends Parent<T>{

    public Child(T key) {
        super(key);
    }

    @Override
    public T getKey() {
        return super.getKey();
    }
}
  • 指定多个子类泛型，指定的父类泛型时需包含在子类泛型列表中
/**
 * Parent<x>中的泛型需在 Child<...>泛型列表中
 */
public class Child<T,E> extends Parent<T>{

    private E value;

    public Child(T key,E value) {
        super(key);
        this.value = value;
    }

    @Override
    public T getKey() {
        return super.getKey();
    }

    public E getValue(){
        return value;
    }
}

泛型接口

  • 泛型类接口
public interface Generator<E> {
    E getKey();
}
  • 实现类不是泛型类，接口要明确数据类型
public class Apple implements Generator<String>{
    private String key;
    
    @Override
    public String getKey() {
        return key;
    }
}
  • 实现类也是泛型类，实现类和接口的泛型类型要一致
public class Pear<T> implements Generator<T>{
    private T key;
    
    @Override
    public T getKey() {
        return key;
    }
}

泛型方法

  • public与返回值中间非常重要，可以理解为声明此方法为泛型方法，只有声明了的方法才是泛型方法
  • 泛型类中的使用了泛型的成员方法并不是泛型方法。
  • 表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T，与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
public static <T> List<T> toList(T... arr) {
    List<T> lists = new ArrayList<T>();
    for (T element : arr) {
        lists.add(element);
    }
    return lists;
}

public static <T> T getOne(T... arr) {
    return arr[new Random().nextInt(arr.length)];
}

public static <T> T getOneRandom(List<T> lists) {
    return lists.get(new Random().nextInt(lists.size()));
}
  • 泛型方法的泛型与类的泛型是相互独立不影响的
public class Generic<T> {
    private T key;

    public Generic(T key) {
        this.key = key;
    }
    
    public T getKey() {
        return key;
    }
    
    public void setKey(T key) {
        this.key = key;
    }

    public <E> E getValue(E obj){
        return obj;
    }
}

// 调用可以发现泛型方法泛型和类泛型互不影响
public static void main(String[] args){
    Generic<Integer> generic = new Generic<>(111);
    Integer key = generic.getKey();
    String value = generic.getValue("xiaoai");
}

类型通配符

Integer 为 Number子类

  • 普通泛型类
public class Box<E> {
    private E first;

    public E getFirst() {
        return first;
    }

    public void setFirst(E first) {
        this.first = first;
    }
}
  • 报错
public class BoxTest {
    public static void main(String[] args){  
         Box<Number> box1 = new Box<>();
         box1.setFirst(100);
         showBox(box1);

        Box<Integer> box2 = new Box<>();
        box1.setFirst(200);
        showBox(box2);  // 报错，方法参数泛型不同
    }
    private static void showBox(Box<Number> box1) {
        System.out.println(box1.getFirst());
    }
}
通配符【?】
public class BoxTest {
    public static void main(String[] args){  
         Box<Number> box1 = new Box<>();
         box1.setFirst(100);
         showBox(box1);

        Box<Integer> box2 = new Box<>();
        box1.setFirst(200);
        showBox(box2);  // 不报错
    }
    
    // 使用泛型通配符"?" 接收任意类型
    private static void showBox(Box<?> box1) {
        System.out.println(box1.getFirst());
    }
}
通配符上限【? extents】
  • 要求该泛型的类型，只能是实参类型，或实参类型的子类类型。
public class BoxTest {
    public static void main(String[] args){  
         Box<Number> box1 = new Box<>();
         box1.setFirst(100);
         showBox(box1);

        Box<Integer> box2 = new Box<>();
        box1.setFirst(200);
        showBox(box2);  // 不报错
    }
    
    // 使用泛型通配符"?" 只能接收Number及其子类型
    private static void showBox(Box<? extends Number> box1) {
        System.out.println(box1.getFirst());
    }
}
  • 使用通配符上限修饰，如果是列表则不能添加元素，因为【?】上限限定子类也能接收，所以无法确定接收的是何种类型。
public static void main(String[] args){
    List<? extends Number> list = new ArrayList<>();
    list.add(222);  // 报错

    // 确定类型可以添加子类型
    List<Number> listNumber = new ArrayList<>();
    List<Integer> listInteger = new ArrayList<>();
    listInteger.add(111); // 不报错
    listNumber.add(111); // 不报错
    listNumber.addAll(listInteger); // 不报错
}
通配符下限【? super】
  • 要求该泛型的类型，只能是实参类型，或实参类型的父类类型。
public class BoxTest {
    public static void main(String[] args){  
         Box<Number> box1 = new Box<>();
         box1.setFirst(100);
         showBox(box1);

        Box<Integer> box2 = new Box<>();
        box1.setFirst(200);
        showBox(box2);  // 报错
    }
    
    // 使用泛型通配符"?" 只能接收Number及其父类型
    private static void showBox(Box<? super Number> box1) {
        System.out.println(box1.getFirst());
    }
}
  • 下限通配符，如果是列表可以添加数据，但不保证数据类型。

类型擦除

类型擦除：泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是，泛型代码能够很好地和之前版本的代码兼容。那是因为，泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉。

public class myTest {
    public static void main(String[] args){
        ArrayList<Integer> intList = new ArrayList<>();
        ArrayList<String> strList = new ArrayList<>() ;

        System.out.println(intList.getClass().getSimpleName());   // ArrayList
        System. out.println(strList.getClass().getSimpleName ()); // ArrayList

        System. out. println(intList.getClass() == strList.getClass()); // true
    }
}
无限制类型擦除

在这里插入图片描述

有限制类型擦除

在这里插入图片描述

擦除方法中类型定义的参数

在这里插入图片描述

桥接方法

在这里插入图片描述

泛型数组

  • 可以声明带泛型的数组引用，但是不能直接创建带泛型的数组对象
public static void main(String[] args){
    ArrayList<String>[] listArr1 = new ArrayList<>[5];         //报错
    ArrayList<String>[] listArr2 = new ArrayList<String>[5];   //报错

    ArrayList[] list = new ArrayList[5];
    ArrayList<String>[] listArr3 = list;  //不报错 但有弊端
}

// 弊端例如：
public static void main(String[] args){
    ArrayList[] list = new ArrayList[5];
    ArrayList<String>[] listArr3 = list;  //不报错

    ArrayList<Integer> intList = new ArrayList<>();
    intList.add(100);
    list[0] = intList;
    System.out.println(listArr3[0].get(0)); // 类型转换异常，因为存入Integer类型 取的时候用泛型String取
}

// 建议
public static void main(String[] args){
    ArrayList<String>[] listArr3 = new ArrayList[5];  //不报错

    ArrayList<Integer> intList = new ArrayList<>();
    intList.add(100);
    listArr3[0] = intList;  // 编译时即会报错
   
    ArrayList<String> strList = new ArrayList<>();
    intList.add("xiaoai");
    listArr3[0] = strList;  // 不会报错
    System.out.println(listArr3[0].get(0)); 
    
}
  • 可以通过java.lang.reflect.Array的newInstance (Class,int)创建T[]数组
public class Fruit<T> {
	private T[] array;

	public Fruit(Class<T>clz,int length){
		//通过Array.newInstance创建泛型数组
		array = (T[]) Array.newInstance(clz,length);
	}

	/**
	 * 添加元素
	 * @param index
	 * @param item
	 */
	public void put(int index,T item){
		array[index] = item;
	}

	/**
	 * 获取元素
	 * @param index
	 * @return
	 */
	public T get(int index){
		return array[index];
	}

	/**
	 * 获取数组
	 * @return
	 */
	public T[] getArray(){
		return array;
	}
}

反射与泛型

  • Person类
public class Person {
    private String name;
    private String age;
}
  • 反射指定泛型
public static void main(String[] args)throws Exception {
    // 使用泛型
    Class<Person> personClass = Person.class;
    Constructor<Person> constructor = personClass.getConstructor();
    Person person = constructor. newInstance ();
    
    // 不使用泛型
    Class personClass = Person.class;
    Constructor constructor = personClass. getConstructor();
    Object p = constructor. newInstance() ;
}
小艾影
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c#之泛型详解(Generic)
weixin_33671935的博客
11-12 560
这篇文章主要来讲讲c#中的泛型，因为泛型在c#中有很重要的位置，对于写出高可读性，高性能的代码有着关键的作用。 一、什么是泛型？ 泛型是 2.0 版 C# 语言和公共语言运行库 (CLR) 中的一个非常重要的新功能。 我们在编程程序时，经常会遇到功能非常相似的模块，只是它们处理的数据不一样。但我们没有办法，只能分别写多个方法来处理不同的数据类型。这个时候，那么问题来了，有没有一种办法，用同一...
Java泛型：泛型类、泛型接口、泛型方法
AlbenXie的博客
09-24 761
文章目录 泛型类 泛型类的继承 泛型与内部类 泛型接口 泛型接口的实现 泛型方法 形参的类型参数通过实参确定 泛型方法被多个形参推断 返回值的类型参数通过方法返回值赋值的对象确定 形参和返回值用了同一个类型参数 泛型方法定义中的类型推断 静态方法不可以使用泛型类定义的类型参数 泛型方法返回值赋值给形参 可变参数和泛型方法 泛型类和泛型方法 泛型类中的成员泛型方法和静态泛型方法 匿名内部类和泛型 个人理解总结 ...
泛型
LemonCake的博客
02-09 194
今天在博客上看到一篇非常好的文章，关于泛型的：http://www.importnew.com/24029.html本篇基本搬运（其实就是抄袭了- -、）链接中的内容。红色部分是我个人的见解。一、泛型基础1，泛型类定义一个简单的Box类：public class Box { private String object; public void set(String object) { this...
10.25第九周java作业
xx的博客
11-07 765
课堂练习1：教材160页4.编程题 设计一个动物声音“模拟器”，希望模拟器可以模拟许多动物的叫声，要求如下。 编写接口Animal  Animal接口有两个抽象方法cry()和getAnimalName()，即要求实现该接口的各种具体的动物类给出自己的叫声和种类名称。 编写模拟器类Simulator  该类有一个playSound(Animal animal)方法，该
20200805Java泛型练习
buruore的博客
08-05 285
一、选择 以下语句正确的是：（多选） AB A. List list=new ArrayList(); B. List list=new ArrayList<>(); C. 已知Cat是Animal类的子类，则List list=new ArrayList(); D. List list=new ArrayList(); 二、编程 通过练习，掌握泛型作为方法参数的应用，具体内容见任务要求。运行效果如下： 任务： public abstract class Animal { private
Java 基础泛型.pdf
最新发布
07-26
Java泛型概念 Java泛型是一种在编译时进行类型检查和类型推断的机制，它可以让我们编写更加通用、可重用的代码，提高了代码的可读性和可维护性，同时保证了类型安全。 Java泛型的核心思想是类型参数化，即在类、接口...
java基础泛型 学习全文件
01-23
java基础泛型 学习全文件
关于java基础的泛型的练习
04-24
关于java基础的泛型的练习
java基础学习笔记之泛型
09-02
所谓泛型，就是变量类型的参数化。泛型是JDK1.5中一个最重要的特征。通过引入泛型，我们将获得编译时类型的安全和运行时更小的抛出ClassCastException的可能。在JDK1.5中，你可以声明一个集合将接收/返回的对象的...
java 泛型基础简单事例
06-16
java 泛型基础简单事例
泛型类定义和泛型方法以及泛型限定
q9104422999的博客
02-09 805
1、泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。2、为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。3、特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。[java] view plain copypackage tan;  //定义泛型...
Java 泛型详解：泛型类、泛型接口和泛型方法
风尘博客
07-05 3315
Java 泛型 一、概述 Java 泛型（generics）是 JDK 1.5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。 1.1 什么是泛型？ 泛型，即参数化类型。 一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化
Java基础-泛型类、泛型接口、泛型方法
Eistert
10-20 1427
1. 概述 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类
Java 泛型详解：泛型类、泛型接口、泛型方法
anlian523的博客
09-09 5661
泛型允许我们使用类型参数Type parameter，它用一个自定义的标识符(T、V、E)来代表一个类型，用< >括住，放在类名后面。然后在类定义中所有使用该类型的地方都用这个标识符来代替，因为在定义这个类的时候还不知道这个具体类型到底是哪个类型。 可使用类型参数Type parameter的地方：声明变量、形参、返回值、强制类型转换。注意不可以用于构造器。 在使用泛型类时（区别于定义泛型类时 泛型允许我们使用类型参数Type parameter，它用一个自定义的标识符(T、V、E)来代表一个类型，...
Java中的泛型概念学习
ACfranky的博客
03-07 361
Java中的泛型概念学习 泛型的意义 个人认为泛型的意义有2个： -数据类型的检查 -代码的复用 类型检查 下面的代码中 public class Test { public static void main(String[] args){ List list = new ArrayList(); `list.add("111");`
java泛型
qq_44072222的博客
11-10 279
java泛型 T、E、？、K、V Java源码中的Class代表这个类型所对应的类，而Class<？>表示类型不确定的类。 T：表示确定的Java类型 E：Element (在集合中使用，因为集合中存放的是元素，也表示Collection容器中的类型) ？：是一种无限的符号，代表任何类型都可以 K、V：java中的键值对key、value 泛型的好处 1、提供编译时的类型检查机制。 2、减少数据类型转换 泛型类中常用的泛型标识：T、E、K、V K、V通常联合使用，用到hashmap中 泛型类 使
java 泛型Generic
chengyu0726的博客
05-09 187
1. 背景 泛型技术诞生之前（JDK5以前），创建集合的类型都是Object 类型的元素，存储内容没有限制，编译时正常，运行时容易出现ClassCastException 异常。 public class Test { public static void main(String[] args) { ArrayList list = new ArrayList(); list.add("java"); list.add(100); list.add(true); for(int i =
类与对象--课后作业2
weixin_30802273的博客
10-19 175
一、 1、ClassAndObjectTest.java 代码： publicclassClassAndObjectTest { publicstaticvoidmain(String[] args) { //创建类的实例，定义一个对象变量引用这一实例 MyClass obj= newMyClass(); //通过对象变量调用类的公有方法 obj.myMetho...
java传入泛型参数_Java 基础（一）| 使用泛型的正确姿势
05-13
Java中使用泛型可以使代码更加灵活和安全，但是在传入泛型参数时需要注意以下几点： 1. 泛型参数不能是基本数据类型，只能是对象类型。如果需要使用基本数据类型，可以使用对应的包装类，如Integer、Double等。 2....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值