Java基础语法90-泛型

最新推荐文章于 2024-03-26 02:20:46 发布
最新推荐文章于 2024-03-26 02:20:46 发布
阅读量119 收藏
点赞数
分类专栏： JAVA基础 文章标签： java 编程 开发语言 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A1066223647/article/details/123805819
版权

Java基础语法90-泛型

文章目录

一、泛型的使用

public class GenericTest {


    //在集合中使用泛型之前的情况：
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        //需求：存放学生的成绩
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);
        //问题一：类型不安全
//        list.add("Tom");

        for(Object score : list){
            //问题二：强转时，可能出现ClassCastException
            int stuScore = (Integer) score;

            System.out.println(stuScore);

        }

    }

    //在集合中使用泛型的情况：以ArrayList为例
    @Test
    public void test2(){
       ArrayList<Integer> list =  new ArrayList<Integer>();

        list.add(78);
        list.add(87);
        list.add(99);
        list.add(65);
        //编译时，就会进行类型检查，保证数据的安全
//        list.add("Tom");

        //方式一：
//        for(Integer score : list){
//            //避免了强转操作
//            int stuScore = score;
//
//            System.out.println(stuScore);
//
//        }
        //方式二：
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            int stuScore = iterator.next();
            System.out.println(stuScore);
        }

    }

    //在集合中使用泛型的情况：以HashMap为例
    @Test
    public void test3(){
//        Map<String,Integer> map = new HashMap<String,Integer>();
        //jdk7新特性：类型推断
        Map<String,Integer> map = new HashMap<>();

        map.put("Tom",87);
        map.put("Jerry",87);
        map.put("Jack",67);

//        map.put(123,"ABC");
        //泛型的嵌套
        Set<Map.Entry<String,Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

        while(iterator.hasNext()){
            Map.Entry<String, Integer> e = iterator.next();
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key + "----" + value);
        }

    }


}

1.jdk 5.0新增的特性
2.在集合中使用泛型：
总结：
① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
② 在实例化集合类时，可以指明具体的泛型类型
③ 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。
比如：add(E e) —>实例化以后：add(Integer e)
④ 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
⑤ 如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型。

public class GenericTest {


    //在集合中使用泛型之前的情况：
    @Test
    public void test1(){
        ArrayList list = new ArrayList();
        //需求：存放学生的成绩
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);
        //问题一：类型不安全
//        list.add("Tom");

        for(Object score : list){
            //问题二：强转时，可能出现ClassCastException
            int stuScore = (Integer) score;

            System.out.println(stuScore);

        }

    }

    //在集合中使用泛型的情况：以ArrayList为例
    @Test
    public void test2(){
       ArrayList<Integer> list =  new ArrayList<Integer>();

        list.add(78);
        list.add(87);
        list.add(99);
        list.add(65);
        //编译时，就会进行类型检查，保证数据的安全
//        list.add("Tom");

        //方式一：
//        for(Integer score : list){
//            //避免了强转操作
//            int stuScore = score;
//
//            System.out.println(stuScore);
//
//        }
        //方式二：
        Iterator<Integer> iterator = list.iterator();
        while(iterator.hasNext()){
            int stuScore = iterator.next();
            System.out.println(stuScore);
        }

    }

    //在集合中使用泛型的情况：以HashMap为例
    @Test
    public void test3(){
//        Map<String,Integer> map = new HashMap<String,Integer>();
        //jdk7新特性：类型推断
        Map<String,Integer> map = new HashMap<>();

        map.put("Tom",87);
        map.put("Jerry",87);
        map.put("Jack",67);

//        map.put(123,"ABC");
        //泛型的嵌套
        Set<Map.Entry<String,Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

        while(iterator.hasNext()){
            Map.Entry<String, Integer> e = iterator.next();
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key + "----" + value);
        }

    }


}

3.如何自定义泛型结构：泛型类、泛型接口；泛型方法。见 GenericTest1.java

public class GenericTest1 {

    @Test
    public void test1(){
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型类型为Object类型
        //要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建议：实例化时指明类的泛型
        Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");

        order1.setOrderT("AA:hello");

    }

    @Test
    public void test2(){
        SubOrder sub1 = new SubOrder();
        //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
        sub1.setOrderT(1122);

        SubOrder1<String> sub2 = new SubOrder1<>();
        sub2.setOrderT("order2...");
    }

    @Test
    public void test3(){

        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = new ArrayList<Integer>();
        //泛型不同的引用不能相互赋值。
//        list1 = list2;

        Person p1 = null;
        Person p2 = null;
        p1 = p2;


    }

    //测试泛型方法
    @Test
    public void test4(){
        Order<String> order = new Order<>();
        Integer[] arr = new Integer[]{1,2,3,4};
        //泛型方法在调用时，指明泛型参数的类型。
        List<Integer> list = order.copyFromArrayToList(arr);

        System.out.println(list);
    }
}

public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是泛型类
}

二、注意：

  1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：
    <E1,E2,E3>
  2.  泛型类的构造器如下：public GenericClass(){}。而下面是错误的：public GenericClass<E>(){}
  3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
  4. 泛型不同的引用不能相互赋值。
    尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有
    一个ArrayList被加载到JVM中。
    @Test
    public void test3(){

        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = new ArrayList<Integer>();
        //泛型不同的引用不能相互赋值。
//        list1 = list2;

        Person p1 = null;
        Person p2 = null;
        p1 = p2;


    }
    //测试泛型方法
    @Test
    public void test4(){
        Order<String> order = new Order<>();
        Integer[] arr = new Integer[]{1,2,3,4};
        //泛型方法在调用时，指明泛型参数的类型。
        List<Integer> list = order.copyFromArrayToList(arr);

        System.out.println(list);
    }

  1. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。经验：泛型要使用一路都用。要不用，一路都不要用。

  2. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。

  3. jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>();

  4. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。

  5. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。

  6. 异常类不能是泛型的

  7. 不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];

参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。

  1. 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

子类不保留父类的泛型：按需实现

​ 没有类型 擦除

​ 具体类型

子类保留父类的泛型：泛型子类

​ 全部保留

​ 部分保留

class Father<T1, T2> {
}

// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}

// 2)具体类型
class Son2 extends Father<Integer, String> {
}

// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}

// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}

结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型

三、自定义泛型方法

泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。
换句话说，泛型方法所属的类是不是泛型类都没有关系。
泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。

public static <E>  List<E> copyFromArrayToList(E[] arr){

    ArrayList<E> list = new ArrayList<>();

    for(E e : arr){
        list.add(e);
    }
    return list;

}

四、泛型在继承方面的体现

虽然类A是类B的父类，但是G 和G二者不具备子父类关系，二者是并列关系。
补充：类A是类B的父类，A 是 B 的父类 

@Test
public void test1(){
    Object obj = null;
    String str = null;
    obj = str;
    Object[] arr1 = null;
    String[] arr2 = null;
    arr1 = arr2;
    //编译不通过
      Date date = new Date();
      str = date;
    List<Object> list1 = null;
    List<String> list2 = new ArrayList<String>();
    //此时的list1和list2的类型不具有子父类关系
    //编译不通过
      list1 = list2;
    /*
    反证法：
    假设list1 = list2;
       list1.add(123);导致混入非String的数据。出错。
     */
    show(list1);
    show1(list2);
}
public void show1(List<String> list){
}
public void show(List<Object> list){
}
@Test
public void test2(){
    AbstractList<String> list1 = null;
    List<String> list2 = null;
    ArrayList<String> list3 = null;
    list1 = list3;
    list2 = list3;
    List<String> list4 = new ArrayList<>();
}

五、通配符的使用

通配符：?
类A是类B的父类，G和G是没有关系的，二者共同的父类是：G<?>

@Test
public void test3(){
    List<Object> list1 = null;
    List<String> list2 = null;
    List<?> list = null;
    list = list1;
    list = list2;
    //编译通过
      print(list1);
      print(list2);
    //
    List<String> list3 = new ArrayList<>();
    list3.add("AA");
    list3.add("BB");
    list3.add("CC");
    list = list3;
    //添加(写入)：对于List<?>就不能向其内部添加数据。
    //除了添加null之外。
      list.add("DD");
      list.add('?');
    list.add(null);
    //获取(读取)：允许读取数据，读取的数据类型为Object。
    Object o = list.get(0);
    System.out.println(o);
}
public void print(List<?> list){
    Iterator<?> iterator = list.iterator();
    while(iterator.hasNext()){
        Object obj = iterator.next();
        System.out.println(obj);
    }
}

有限制条件通配符使用

? extends A:
G<? extends A> 可以作为G和G的父类，其中B是A的子类

? super A:
G<? super A> 可以作为G和G的父类，其中B是A的父类

 @Test
 public void test4(){
     List<? extends Person> list1 = null;
     List<? super Person> list2 = null;
     List<Student> list3 = new ArrayList<Student>();
     List<Person> list4 = new ArrayList<Person>();
     List<Object> list5 = new ArrayList<Object>();
     list1 = list3;
     list1 = list4;
       list1 = list5;
       list2 = list3;
     list2 = list4;
     list2 = list5;
     //读取数据：
     list1 = list3;
     Person p = list1.get(0);
     //编译不通过
     //Student s = list1.get(0);
     list2 = list4;
     Object obj = list2.get(0);
     编译不通过
       Person obj = list2.get(0);
     //写入数据：
     //编译不通过
       list1.add(new Student());
     //编译通过
     list2.add(new Person());
     list2.add(new Student());
 }
1 = list3;
     list1 = list4;
       list1 = list5;
       list2 = list3;
     list2 = list4;
     list2 = list5;
     //读取数据：
     list1 = list3;
     Person p = list1.get(0);
     //编译不通过
     //Student s = list1.get(0);
     list2 = list4;
     Object obj = list2.get(0);
     编译不通过
       Person obj = list2.get(0);
     //写入数据：
     //编译不通过
       list1.add(new Student());
     //编译通过
     list2.add(new Person());
     list2.add(new Student());
 }
MarxistVive
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java基础教程----精华版
09-22
这个"java基础教程----精华版"显然是一份精心整理的资料，旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java语言的核心概念和关键知识点。 1. **Java语法基础**： - **变量**：在Java中，变量是存储...
java基础---PPT讲稿.zip
02-15
这份"java基础---PPT讲稿.zip"压缩包包含了对Java基础知识的深入讲解，旨在帮助学习者掌握Java的核心概念，为更高级的学习阶段打下坚实的基础。 在PPT中，我们可能会涵盖以下几个关键知识点： 1. **Java简介**：...
12、Java基础之泛型的使用
xiaosuxueJava的博客
01-09 989
Java泛型的使用
Java基础：泛型的使用
weixin_50835087的博客
08-11 1057
集合、类、方法中泛型的使用以及泛型在继承中的体现
Java泛型详解（史上最全泛型知识详解）
m0_70325779的博客
07-25 8393
泛型是在JDK5之后引入的一个新特性，可以在编译阶段约束操作的数据类型，并进行检查。泛型的格式为用大白话来说，泛型就好比是给一个标签，通常情况下我们会在开发过程中或者个人学习或练习的过程中使用到泛型；就拿数组的泛型举例来说，我们把数组比作一个药瓶子，我们药瓶子贴上了什么标签，就只能放什么药，如果不管什么药都放在一个药瓶子里，那不得出大事吗？同样容器(数组)写上什么泛型，就只能存放什么数据；这样就不会导致我们存取数据的混乱。这样就解决了我们引言中提到的问题，也就解释了什么是泛型。
Java泛型：定义、使用与实战
最新发布
Jz_Stu的博客
03-26 1296
泛型是Java SE 5.0中引入的一个新特性，它提供了编译时类型安全，减少了类型转换的代码，并提高了代码的可重用性。泛型，顾名思义，就是广泛的数据类型。在Java中，泛型允许我们在定义类、接口和方法时使用类型参数。这些类型参数在类、接口或方法被实例化时（即创建对象时）被具体的类型替换。这样，我们可以编写更加通用的代码，提高代码的可重用性。当我们需要自定义一些数据结构（如栈、队列等）时，泛型可以帮助我们编写更加通用的代码。通过使用泛型，我们可以使这些数据结构支持任意类型的元素。
Java---＞toString方法
Mrrr_Li的博客
10-04 117
toString 是源自java Object类，在Object 内定义为：返回一个 类名@hashcode的字符串，可以overridden 用来返回 你认为有用的信息， toStrng 没有arguments override：public String toString（）{ // insert you code return “informations” } 因为在java中 Object类是基类，所以每个类都会有toString方法。 System.out.println（Object）实际上就是
黑马程序员----泛型与反射的小运用
04-04
泛型的基本语法是在类、接口或方法声明前加上尖括号`<>`，并在其中指定一个或多个类型参数。例如，一个简单的泛型列表类可以定义为`List<T>`，其中`T`就是类型参数，代表任意类型。使用泛型，我们可以创建一个能够...
详解Java中的 枚举与泛型
08-31
泛型的基本语法是在类型名称后加上尖括号`<T>`，其中`T`代表一个类型参数。 1. 泛型类：如`ArrayList<T>`，`T`是类型参数，可以在使用时替换为具体的类型，如`ArrayList<String>`或`ArrayList<Integer>`。 2. 泛型...
java 泛型基础简单事例
06-16
Java 泛型是Java编程语言中的一个重要特性，它在Java SE 5.0版本中引入，极大地提高了代码的类型安全性和重用性。泛型允许我们在定义类、接口和方法时，使用一种类型参数，而不是具体的类型。这样做的好处在于，我们...
【Java基础】泛型（一）-基础使用
couthz
02-16 512
本文以Java的官方文档为参考，辅以代码示例，尽可能详尽的叙述泛型的每一个特性 泛型（Generics）也称为参数化类型（parameterized types），也就是将类型本身作为接口、类、方法中的参数，相应地声明泛型接口、泛型类、泛型方法，在具体调用时再传入类型参数。从而实现同一种接口、类、方法适用于不同的类型。
Java 泛型的简介和使用
it_xushixiong的博客
04-27 322
Java 泛型是一项非常重要的特性，它可以使代码更加类型安全、可读性更高、可维护性更好。在编写 Java 程序时，我们应该尽可能地使用泛型，以提高代码的质量和效率。同时，也需要注意泛型的局限性，避免在使用泛型时出现不必要的问题。
泛型的用法
weixin_57197500的博客
12-20 2654
泛型的一些简单的用法和实现
Java中泛型的各种使用
dyy_gusi的博客
12-12 128
Java中的泛型的使用：1.普通的泛型使用 在使用类的时候后面的&lt;&gt;中的类型就是我们确定的类型。 public class MyClass1&lt;T&gt; {//此处定义的泛型是T private T var; public T getVar() { return var; } public void set...
Java中泛型的使用
weixin_49329785的博客
08-22 2440
一、泛型的意义 二、泛型的使用 1.jdk 5.0新增特性 2.在集合中使用泛型： 总结： A.集合接口或集合类在jdk5.0时都修改为带泛型的结构。 B.在实例化集合类时，可以指明具体的泛型类型。 C.指明完以后，在集合类或接口中凡是定义类或接口时，内部结构(比如：方法、构造器、属性等)使用类的泛型的位置， 都指定为实例化的泛型类型。比如：add(E e) --->实例化以后：add(Integer e) D.注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数...
java泛型怎么使用_Java泛型该怎么使用
weixin_39973518的博客
02-12 659
具体使用方法~1、定义泛型类在定义带泛型的类时，在紧跟类命之后的 < >内，指定一个或多个泛型的名字，同时也可以对泛型的取值范围进行限定，多个泛型之间用,号分隔。定义完泛型后，可以在定义位置之后的类的几乎任意地方(静态块，静态属性，静态方法除外)使用泛型，就像使用普通的类型一样。注意，父类定义的泛型不能被子类继承。例：//自定义一个泛型publicclassMyGenerics...
泛型的说明以及使用
瘾力的博客
11-13 1470
一、泛型 （一）泛型的概述和使用 1、泛型：广泛的类型。在定义类的时候，某些方法的参数列表或者返回值类型不确定，就使用一个符号，来表示那些尚未确定的类型，这个符号就是泛型。 2、使用：对于具有泛型的类型，在类名的后面加上尖括号，尖括号里面写上泛型的确定类型（在使用某个类型创建对象的时候，对象的泛型确定为什么类型，泛型就是什么类型） 3、泛型的好处： (1)提高了数据的安全性，将运行期的问题提前暴露在了编译期 (2)避免了强转的麻烦 4、注意事项： (1)泛型必须书写成引用数据类型，不能写基本数据类型 (2)
Java 中泛型的详解
路宇的博客
03-28 2503
泛型介绍： 泛型又称参数化类型，是JDK5.0出现的新特性，解决数据类型的安全性问题。 在类声明或者实例化时，只需要指定好需要的具体类型即可。 Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCaseException异常，同时代码更加简洁，健壮。 泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值类型，又或者是参数类型。 （这个具体演示代码如下） public class Generic03 { public static voi
Java 泛型详解(超详细的java泛型方法解析)
热门推荐
qq_66912832的博客
06-14 1万+
超详细的java泛型方法解析
JAVA基础：深入理解泛型与集合类
在Java中，定义泛型类的语法如下： ```java public class Demo<T> { T attribute; T method(T t) {} } ``` 这里的`T`被称为类型参数或类型占位符，代表了一种未知的数据类型。在实例化泛型类时，我们可以指定`T`的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

MarxistVive

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

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

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

打赏作者

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

抵扣说明：

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

余额充值