泛型的注意事项

于 2022-09-11 19:30:29 发布
阅读量302 收藏
点赞数
分类专栏： 数据结构 文章标签： java jvm 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SCR1209/article/details/126808264
版权

文章目录

注意一：时间复杂度从小到大排列

O( 1 ) < O( log n ) < O( n ) < O( n log n ) < O( n^2 )

注意：

接口与接口之间的关系： extends

接口与类之间的关系： implements

注意二：泛型

泛型：泛型就是将类型进行参数化，将类型作为参数进行传递。

找一个数组可以存放所有数据类型的数据，那么这个数组的类型必然是Object 类型的数组，

  • 因为Object 是所有类的父类，并且它可以接受所有的数据类型包括：类，接口，数组。
  • 引用数据类型大部分都是类或接口，String类等，他们的父类是Object类
  • 基本数据类型，有拆箱和装箱的概念

在这里插入图片描述

public static void main(String[] args) {
        Object[] array = {1,2,3,"hello"};
        String[] array2 = (String[]) array; //现在不报错但是运行的时候报错 
        
    }
//只要是Object类型的数组，就不让强转成其他类型。但是单个类是可以转的。

package demo;

class Arrayer{

    Object[] array = new Object[10];  //数组中每个元素都是Object类型

    public void setArray(int pos, Object value){
        array[pos] = value;
    }

    public Object getArray(int pos){
        return array[pos];
    }
}

public class Test2 {
    public static void main(String[] args) {
       Arrayer arrayer = new Arrayer();
       arrayer.setArray(5,"hello");
       arrayer.setArray(4,20);

       //String str = arrayer.getArray(5); //error
        //getArray()方法返回的是Object 不会自动转化成String类型，要手动强转
        //注意区别这句话  ： 只要是Object类型的数组，就不让强转成其他类型。但是单个类是可以转的。
        String str = (String) arrayer.getArray(5);//right
        System.out.println(str);
        System.out.println(arrayer.getArray(1));
    }
}


// hello  null

这样我们会发现一个问题，向Object类型的数组中 传数据是比较方便的，但是取的时候是非常困难的，我们取的时候要找个变量来接收，

但是数组中元素的类型是Object类型，所以每次都要根据接受变量的类型进行强制类型转换，这样做是非常不智能的。低效的。

改进：（使用泛型）

package demo;

class Arrayer2<T>{  // T  类型形参列表 表示的是传递的类型 可以指定多个类型     < > 占位符 表示当前类是泛型类
    
    T[] array = (T[]) new Object[10]; //注意这个地方有问题

    public void setArray(int pos, T value){
        array[pos] = value;
    }

    public T getArray(int pos){
        return array[pos];
    }
}

public class Test3 {
    public static void main(String[] args) {
        Arrayer2<Integer> arrayer = new Arrayer2<Integer>();
        Arrayer2<String> arrayer2 = new Arrayer2<String>();

        arrayer.setArray(0,12);
        arrayer2.setArray(0,"nihao");
        arrayer2.setArray(1,"hhh");

        System.out.println(arrayer.getArray(0));
        System.out.println(arrayer2.getArray(0));
        System.out.println(arrayer2.getArray(1));
    }
}
/*
12
nihao
hhh
*/

我们之前传递的是变量的值，现在我们传递的是变量的类型了。

泛型存在的两个最大的意义：

  • 1：在存放元素的时候会进行类型的检查。
  • 2：在取出元素的时候会进行类型的转换，不用自己再强转了。
  • 这两步都是在编译的时候完成的，因为在程序运行的时候，没有泛型这个概念。泛型主要是程序编译时的一种机制 --》擦除机制。

注意：< 里面一定是类类型 ，不可以是基本数据类型 > < int > //error

在这里插入图片描述

在这里插入图片描述

java泛型机制是在编译时期实现的，编译器生成的字节码在运行期间并不包括泛型的类型信息

注意三：Object类型的数组是不可以强转成其他类型的会报错

package demo;

import java.util.Arrays;

class Arrayer2<T>{
    //T[] array1 = new T[10];    error
    T[] array = (T[]) new Object[10];                            //注意这个地方有问题

    public void setArray(int pos, T value){
        array[pos] = value;
    }

    public T getArray(int pos){
        return array[pos];
    }

    public T[] getArray(){
        return array;                                            //注意这是返回一个Object类型的数组
    }
}

public class Test3 {
    public static void main(String[] args) {
        Arrayer2<Integer> arrayer = new Arrayer2<Integer>();
        Arrayer2<String> arrayer2 = new Arrayer2<String>();

        arrayer.setArray(0,12);
        arrayer2.setArray(0,"nihao");
        arrayer2.setArray(1,"hhh");
        
        Integer[] ret = arrayer.getArray();                //Object类型的数组是不可以强转成其他类型的会报错
        
//ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;at demo.Test3.main(Test3.java:31)
    }
}


 //T[] array1 = new T[10];           error
    T[] array = (T[]) new Object[10]; //注意这个地方有问题
//你所实例化的一个数组不是具体类型的

import java.lang.reflect.Array;

public class Test4<T> {
    T[] array;
    public Test4(Class<T> clazz,int capicity){
        array = (T[])Array.newInstance(clazz,capicity);
    }
}

public class Test {
    public static void main(String[] args) {
        Test4<Integer> test4 = new Test4<Integer>(Integer.class ,10);
    }
}

//这样写是正确的，涉及到反射的知识，作为了解

//这样你所实例化的一个数组是具体类型的

注意四：泛型上界

在这里插入图片描述

在这里插入图片描述

你会发现只接受 Number 的子类型作为 E 的类型实参，别的都超出Number的边界了。

package demo1;

public class Alg<T extends Comparable<T>> { //特殊：泛型上界  T类型必须是实现了Comparable接口的
    //寻找数组中的最大值
    public T findMax(T[] array){
        T max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0){
                max = array[i];
            }
        }
        return max;
    }


}


class Person implements Comparable<Person> {
    private int age;
    private String name;

    public Person(int age, String name){
        this.name = name;
        this.age = age;
    }
    //重写compareT方法 ，你想比较啥就写啥
    @Override
    public int compareTo(Person o) {
        return this.age - o.age;
    }
   //重写toString方法
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}


class Test{
    public static void main(String[] args) {

        Integer[] array = {1,2,3,4,5,6};
        Alg<Integer> alg = new Alg<>();
        System.out.println(alg.findMax(array));
        
        
        Person[] person = {
                new Person(10,"xiaobai"),
                new Person(20,"xiaohong"),
                new Person(5,"xiaohuang"),
                new Person(30,"dabai")
        };

        Alg<Person> alg1 = new Alg<Person>();
        Person ret = alg1.findMax(person);
        System.out.println(ret);

    }
}


//6
//Person{age=30, name='dabai'}

注意五：泛型方法

（1）：泛型静态方法

package demo2;

public class Alg {
    public static<T extends Comparable<T>> T findmax(T[] array){
        T max = null;
        for(int i = 0; i < array.length - 1; i++){
            if(array[i].compareTo(array[i+1]) < 0){
                max = array[i + 1];
            }
        }
        return max;
    }
}

class Test{
    public static void main(String[] args) {
        Integer[] array = {1,2,3,4,5,6,7,8,9,10};
        Integer ret = Alg.findmax(array);
        //Integer ret = Alg.<Integer>findmax(array);    
        //这两种写法都是可以的，只不过第一种省去的类型参数是通过传参array来判断的.
        System.out.println(ret);
    }
}
// 10

（2）：泛型方法：

package demo2;

import java.util.Arrays;

public class Alg2 {
    public <T extends Comparable<T>> void func(T[] array){
        for (int i = 0; i < array.length - 1; i++) {
            if(array[i].compareTo(array[i+1]) < 0){ //会调用相应对象的compareTo方法
                T temp = array[i];
                array[i] = array[i+1];
                array[i+1] = temp;
            }
        }//泛型方法，对任意类型的数组进行排序
    }

}

class Person implements Comparable<Person> {
    private String name;

    public Person(String name){
        this.name = name;
    }

    @Override
    public int compareTo(Person o) {
        return this.name.length() - o.name.length();//重写了compareTo方法，以这个方式进行比较
    }

    @Override
    public String toString() {      //重写了toString方法，Arrays.toString(person)直接调用相应对象当中的toString方法
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}//Person类


class Test1{
    public static void main(String[] args) {
        Person[] person = {
                new Person("xiaohong"),
                new Person("xiaohuang"),
                new Person("xiaohua")
        };
        Alg2 alg2 = new Alg2();
        alg2.func(person);
        System.out.println(Arrays.toString(person));

    }
}

//[Person{name='xiaohuang'}, Person{name='xiaohong'}, Person{name='xiaohua'}]

泛型静态方法不用new对象直接调用。

注意六：通配符

package demo4;

public class Messager<T> {
    private T ret;

    public void setRet(T ret){
        this.ret = ret;
    }
    public T getRet(){
        return  this.ret;
    }
}

class test{
    public static void main(String[] args) {
        Messager<Integer> messager = new Messager<>();
        messager.setRet(10);
        func(messager);
        
        Messager<String> messager2 = new Messager<>();
        messager2.setRet("xiaobai");
        func(messager2);
        
    }
    public static void func(Messager<?> messager){
        //可以接收所有的泛型类型，但是又不能够让用户随意修改。这种情况就需要使用通配符"?"来处理
        System.out.println(messager.getRet());
        //messager.setRet("hhh")   error   不可以往里面放，因为也不知到放什么类型
    }
}

public static void func(Messager<Integer> messager){
        System.out.println(messager.getRet());
}

public static void func(Messager<String> messager){
        System.out.println(messager.getRet());
}
//这两段代码是一样的，擦除完之后如下
public static void func(Messager<Object> messager){
        System.out.println(messager.getRet());
}

public static void func(Messager<Object> messager){
        System.out.println(messager.getRet());
}
HackerTerry
关注
专栏目录
泛型注意事项和细节
Zhang122593332的博客
08-08 202
基本语法修饰符返回类型方法名(参数列表) {注意细节泛型方法，可以定义在普通类中，也可以定义在泛型类中2.当泛型方法被调用时，类型会确定3. public void eat(E e) {，修饰符后没有 eat方法不是泛型方法，而是使用了泛型。...
面向对象之16：一文 彻底搞懂Java中的泛型、泛型的 使用细节 及 注意事项：
随手记记，加深印象。
06-15 1046
what's Generic？ 泛型（广泛的类型）： 泛型就相当于是一个标签。形象一些就是：在生活中随处可见的类似于泛型的参考。比如：男卫生间门上贴的标签 --》 男 or boy ，女卫生间门上的标签 --》 女 or girl，能表示性别的标签 理解在Java中就叫做泛型。再 比如：垃圾分类的垃圾桶上面贴的标签，比如：厨余辣鸡、有害辣鸡、可回收辣鸡、其他辣鸡，……等等。 泛型的声明格式：<泛型标识符[,泛型标识符2,……]> 这个<>有的 因为像，也叫做钻石运算符。 Java中 泛型的
泛型注意的细节
yuer7916555的博客
09-29 147
1、不可以用一个本地类型（如int   float）来替换泛型.比如List&lt;Integer&gt;不能用List&lt;int&gt;型式 2、运行时类型检查，不同类型的泛型类是等价的（Pair&lt;String&gt;与Pair&lt;Employee&gt;是属于同一个 类型 Pair），这一点要特别注意:即如果a instanceo...
泛型注意点
weixin_49263647的博客
05-07 131
1.由于子类在继承泛型的父类时，指明了泛型类型，则是实例化子类对象时，不需要指明泛型 public static void main(String[] args) { SubOrder sub1=new SubOrder(); sub1.setOrderT(1212); SubOrder1<Object> sub2 = new SubOrder1<>(); sub2.setOrderT(234); }..
[泛型] 使用泛型的注意事项
Terry Zhang 的技术博客
04-16 290
在 Java 中有效地使用泛型，一定要注意以下限制： [b][size=x-large]不能使用原始数据类型实例化泛型类 [/size][/b] 考虑下面的泛型类： [code="java"]class Pair { private K key; private V value; public Pair(K key, V value) { ...
使用泛型的注意事项
阿送
08-09 605
对于在泛型中ArrayList类定义和ArrayList类引用中涉及如下术语 整个称为ArrayList泛型类型 ArrayList中的E称为类型变量或类型参数 整个ArrayList称为参数化的类型 ArrayList中的Integer称为类型参数的实例或实际类型参数 ArrayList中的 ArrayList称为原始类型
unity的泛型单例注意事项
最新发布
08-20
当使用泛型单例模式在Unity中创建单例对象时，有几个注意事项需要考虑： 1. 保证只有一个实例：泛型单例模式的目的是确保只有一个实例化的对象存在。为了实现这一点，你需要在泛型类中使用静态字段来保存实例，并在...
泛型的概述、类别及注意事项
成为一位优秀的职场人，我在路上
11-06 439
一、泛型概述 泛型指的是“参数化类型” 即把某些参数的数据类型使用一个泛型代替，在使用或调用的时候传入具体的数据类型赋值给泛型 使用方式 泛型定义在尖括号中，可以同时定义多种泛型，使用逗号隔开 如<T>、<T,V> 二、泛型的类别 1、泛型类 在定义类的时候，在类名后定义泛型 用的比较多 jdk1.7之后，new对象时后面的尖括号内的泛型可以省略，只需要在定义变量数据类型后定义泛型即可 举例 //定义一个类，使用泛型 public class T
【java】 泛型使用的注意事项
zcrazy的博客
12-08 459
什么是泛型？ 将数据类型参数化 泛型能够让同一份代码操作多种类型的数据。 1.定义泛型之后，尽量不要使用原生态类型，使用类文字时除外。 什么是原生态类型？ 例如List<String>中List就是原生态类型。所以要尽量使用List<Object>的方式去使用泛型。 使用原生态的情况有哪些？ List.class instanceof 上述两种情况都可以使用原生态类型，因为范类型信息会在运行时被擦除. 2.要尽可能的消除每一个非受检警告 ...
泛型及其注意事项
二丑的博客
03-21 770
泛型： import java.util.ArrayList; /*  泛型是jdk1.5使用的新特性。       泛型的好处：   1. 将运行时的异常提前至了编译时。   2. 避免了无谓的强制类型转换 。      泛型在集合中的常见应用：     ArrayList  list = new ArrayList();  true     推荐使用。
java泛型注意事项_java泛型总结
weixin_42629671的博客
02-27 159
1 说明1)Generics是对java语言类型系统的一种扩展，以支持创建可以按类型进行参数化的类或者方法。2)泛型的优点：1.类型安全(使用泛型时，编译器可以捕获附加类型信息，从而类型错误在编译时被捕获而不是运行时来进行检测)2. 消除强制类型转换，减少了代码出错的可能性，并且使代码更加可读2 泛型类实例不使用泛型，此种情况需要类型转换packagecom.wish.generic;publi...
Java泛型的注意事项以及使用
WillCold的专栏
10-18 1610
为什么要用泛型呢？JDK5以前，对象保存到集合中就会失去其特性，取出时通常要程序员手工进行类型的强制转换，这样不可避免就会引发程序的一些安全性问题。       比如：           泛型的作用：      JDK5中的泛形允许程序员在编写集合代码时，就限制集合的处理类型，从而把原来程序运行时可能发生问题，转变为编译时的问题，以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)
泛型的使用方法以及注意事项
zhyzh134的博客
02-26 428
/*1使用泛型可以解决类型转换的问题：在编译器发现问题，而不是运行期才发现  * 2泛型只能是引用类型，不能是基本类型  * 3方法中如果有泛型，那么传入的参数类型必须和方法中声明的类型完全一致  * 如果希望方法中的泛型可以接收任意类型那么不能使用object，可以使用通配符？(问号)  * 4一个泛型类的参数可以是一般的引用类型的参数，也可以是一个泛型类  * 5泛型类可以是继承泛型
java 泛型的应用及注意事项
Y_hahaha的博客
04-07 258
1、泛型指定的类型为引用类型，不能为基本类型；（如:Double，而不能用double） 注：如果使用了一个带有泛型的类，但没有指定明确的类型，则默认会使用Object描述 2、jdk1.7之后，声明带泛型的类时，后边的类型可以省略 如：Point<String> point = new Point<String>(); --->...
35.Java之泛型（泛型介绍，泛型的语法，泛型使用的注意事项和细节，自定义泛型类，自定义泛型接口，自定义泛型方法，泛型的继承和通配符）
qq_46656580的博客
01-30 1101
35.1 使用泛型的意义 使用传统集合的问题分析 不能对加入到集合 ArrayList 中的数据类型进行约束（不安全） 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响 泛型的好处 编译时，检查添加元素的类型，提高了安全性 减少了类型转换的次数，提高效率 不使用泛型 Dog -> 加入 -> Object -> 取出 -> Dog // 放入到 ArrayList 会先转成 Object，在取出时，还需要转换成 Dog 使用泛型 Dog -&gt
泛型使用注意事项
dashabiooo的博客
09-17 205
   参数化类型可以引用一个原始类型的对象，编译报告警告，例如，          Collection&lt;String&gt; c = new Vector();//可不可以，不就是编译器一句话的事吗？           原始类型可以引用一个参数化类型的对象，编译报告警告，例如，          Collection c = new Vector&lt;String&gt;();//...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HackerTerry

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值