Java——泛型(概念理解+应用举例)

简介: Java——泛型(概念理解+应用举例)

1.泛型的概念


泛型是一种末知的数据类型,当我们不知道使用什么数据类型的时候,可以使用泛型。泛型也可以看成是一个变量用来接收数据类型。E eElement元素,T tType类型。

集合中可以存储任意类型的对象元素,但是当把一个对象存入集合后,集合会忘记这个对象的类型,将该对象从集合中取出时,这个对象的编译类型就统一变成了 Object 类型。

换句话说,在程序中无法确定一个集合中的元素到底是什么类型,那么在取出元素时,如果进行强制类型转换就很容易出错。

 

2.是否使用泛型的对比 


2.1 不使用泛型 

创建集合对象,不使用泛型。     好处:集合不使用泛型,默认的类型就是Object类型,可以存储任意类型的数据。

                                              弊端:不安全,会引发异常。

2.1.1 好处 

import java.util.*;
public class GenericDemo01 {
  public static void main(String[] args) {
    ArrayList arraylist=new ArrayList();//集合不使用泛型
    //向集合中添加数据,用于测试,这里添加了String类型和int类型的数据
    arraylist.add("ABC");
    arraylist.add(123);
    Iterator iterator=arraylist.iterator();
    while(iterator.hasNext()) {//取出的元素的类型默认是Object类型
      System.out.print(iterator.next() + " ");
    }
  }
}

2.1.2 弊端

import java.util.*;
public class GenericDemo02 {
  public static void main(String[] args) {
    ArrayList arraylist=new ArrayList();
    arraylist.add("ABC");
    arraylist.add(123);
    Iterator iterator=arraylist.iterator();
    while(iterator.hasNext()) {
      //取出的数据,默认是Object类型
      Object obj=iterator.next();
      /*假如想使用String类特有的length()方法来获取字符串的长度,是不可以的
                          需要将Object类型向下转型为String类型才能使用它的特有方法
                          但是集合里面还有数据类型为Integer的数据,所以不能进行向下转型为String类型,
                          如果强行转换,那么在运行时会抛出ClassCastException异常*/
      String str=(String)obj;
      System.out.println("该元素的长度为:" + str.length());
    }
  }
}


2.2 使用泛型

2.2.1 好处及弊端 

import java.util.*;
public class GenericDemo03 {
  public static void main(String[] args) {
    //使用泛型限定数据类型为String类的字符串
    ArrayList<String> arraylist=new ArrayList<String>();
    arraylist.add("ABC");
    /*假如添加的数据的类型不是String类型
      arrayList.add(123);这条语句会抛出错误:
      方法java.util.Collection.add(java.lang.String)不适用*/
    Iterator<String> iterator=arraylist.iterator();
    while(iterator.hasNext()) {
      String str=iterator.next();
      System.out.print("该元素为:" + str + "\n" + 
                "长度为:" + str.length());
    }
  }
}


3.定义和使用含有泛型的类


3.1 说明 


泛型,用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

定义和使用含有泛型的类的格式如下:修饰符 class 类名称<代表泛型的变量类型> { . . . }

修饰符 class 类名称<代表泛型的变量类型> { . . . }

修饰符 class 类名称<代表泛型的变量类型> { . . . }


3.2 举例 


class GenericClass<E> {
  private E name;
  public void setName(E name) {
    this.name=name;
  }
  public E getName() {
    return this.name;
  }
}
public class GenericDemo04 {
  public static void main(String[] args) {
    //使用泛型,限定该类的数据类型为String类
    GenericClass<String> name1=new GenericClass<String>();
    name1.setName("使用泛型:这里只能添加指定类型的数据!");
    String str1=name1.getName();
    System.out.println(str1);
    //不使用泛型,该类的数据类型默认为Object类
    GenericClass name2=new GenericClass();
    name2.setName("不使用泛型:这里能添加不同类型的数据!");
    Object obj1=name2.getName();
    System.out.println(obj1);
  }
}

 

4.定义和使用含有泛型的方法 


4.1 说明 

定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间。

格式:修饰符 <泛型> 返回值类型方法名(参数列表(使用泛型)){ 方法体 };

含有泛型的方法,在调用方法的时候确定泛型的数据类型,传递什么类型的参数,泛型就是什么类型

4.2 举例 

class GenericMethod {
  public <W> String method1(W w) {
    return "一个使用泛型的普通方法:" + w;
  }
  public static <Z> String method2(Z z) {
    return "一个使用泛型的静态方法:" + z;
  }
}
public class GenericDemo05 {
  public static void main(String[] args) {
    GenericMethod use=new GenericMethod();//创建一个类对象
    /*调用包含泛型的普通方法
      对应的普通方法为:public <Integer> String method1(Integer 666),w=666*/
    System.out.println(use.method1(666));
    //对应的普通方法为:public <String> String method1(String LOVE),w=LOVE
    System.out.println(use.method1("LOVE"));
    /*调用包含泛型的静态方法
      虽然可以通过对象来调用,但还是推荐使用类进行调用
      对应的静态方法为:public static <String> String method2(String ABC),z=ABC*/
    System.out.println(GenericMethod.method2("ABC"));
    //对应的静态方法为:public static <Double> String method2(Double 521.1314),z=521.1314
    System.out.println(GenericMethod.method2("521.1314"));
  }
}

5.定义和使用含有泛型的接口


5.1 说明 


含有泛型的接口第一种使用方式:通过定义接口的实现类,实现接口,指定接口的泛型。

含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走。就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型。


5.2 举例 


5.2.1 含有泛型的接口第一种使用方式

//博主在这里有点懒,将接口和实现接口的类都写在了一个.java源文件中
//推荐大家将接口和其他的类都单独的写在一个.java源文件中
interface GenericInterface<I> {
  public void method(I i);//接口中的一个抽象方法
}
class Genericing implements GenericInterface<String> {
  public void method(String s) {
    System.out.println("通过定义接口的实现类,实现接口,指定接口的泛型\n" + 
              "这个方法传入指定类型参数是:" + s);
  }
}
public class GenericDemo06 {
  public static void main(String[] args) {
    Genericing generic=new Genericing();
    generic.method("定义和使用接口的第一种方式!");
  }
}

5.2.2 含有泛型的接口第二种使用方式

interface GenericInterface01<I> {
  public void method(I i);
}
class Genericing01<I> implements GenericInterface01<I> {
  public void method(I i) {
    System.out.println("接口使用什么泛型,实现类就使用什么泛型,类跟着接口走\n" + 
              "创建对象的时候传入指定类型参数是:" + i);
  }
}
public class GenericDemo07 {
  public static void main(String[] args) {
    Genericing01 generic=new Genericing01();
    generic.method(2020);
  }
}


6.泛型通配符


6.1 说明 


通配符基本使用泛型的通配:不知道使用什么类型来接收的时候,此时可以使用 ?? 表示未知通配符,即:表示任意的数据类型。

使用方式:不能创建对象使用,只能作为方法的参数使用。

注意:一但使用泛型的通配符,那么,只能使用Object类中的共性方法,集合中元素的自身方法无法使用。 


6.2 举例 


import java.util.*;
class IteratorArrayList {
  //由于不确定接收的ArrayList集合中的元素是什么类型,所以使用泛型通配符 ?
  //array1的元素为Integer类型,array2的元素为String类型
  public static void printing(ArrayList<?> array1) {
    Iterator<?> iterator=array1.iterator();
    while(iterator.hasNext()) {
      Object obj=iterator.next();//next()方法取出的元素类型是Object,可以接收任意的数据类型
      System.out.print(obj + " ");
    }
  }
}
public class GenericDemo08 {
  public static void main(String[] args) {
    //array1集合限定数据类型为Integer
    ArrayList<Integer> array1=new ArrayList<Integer>();
    array1.add(111);
    array1.add(222);
    array1.add(333);
    array1.add(444);
    array1.add(555);
    System.out.print("遍历Integer数据类型的array1集合:");
    IteratorArrayList.printing(array1);
    System.out.println();
    System.out.println("====================================");
    //array2集合限定数据类型为String
    ArrayList<String> array2=new ArrayList<String>();
    array2.add("一号元素");
    array2.add("二号元素");
    array2.add("三号元素");
    array2.add("四号元素");
    array2.add("五号元素");
    System.out.print("遍历String数据类型的array2集合:");
    IteratorArrayList.printing(array2);
  }
}


那么,以上就是我对 Java 泛型的理解,欢迎大家留言评论,一起学习,共同进步!!!😄😄😄 

相关文章
|
29天前
|
缓存 Java 开发者
Java字面量详解:概念、分类与使用实例
本文介绍了Java字面量的概念、分类及应用。
49 11
|
29天前
|
Java 编译器 开发者
Java中的this关键字详解:深入理解与应用
本文深入解析了Java中`this`关键字的多种用法
120 9
|
29天前
|
Java 应用服务中间件 API
【潜意识Java】javaee中的SpringBoot在Java 开发中的应用与详细分析
本文介绍了 Spring Boot 的核心概念和使用场景,并通过一个实战项目演示了如何构建一个简单的 RESTful API。
41 5
|
29天前
|
人工智能 自然语言处理 搜索推荐
【潜意识Java】了解并详细分析Java与AIGC的结合应用和使用方式
本文介绍了如何将Java与AIGC(人工智能生成内容)技术结合,实现智能文本生成。
58 5
|
29天前
|
SQL Java 数据库连接
【潜意识Java】深入理解MyBatis,从基础到高级的深度细节应用
本文详细介绍了MyBatis,一个轻量级的Java持久化框架。内容涵盖MyBatis的基本概念、配置与环境搭建、基础操作(如创建实体类、Mapper接口及映射文件)以及CRUD操作的实现。此外,还深入探讨了高级特性,包括动态SQL和缓存机制。通过代码示例,帮助开发者更好地掌握MyBatis的使用技巧,提升数据库操作效率。总结部分强调了MyBatis的优势及其在实际开发中的应用价值。
32 1
|
2月前
|
存储 Java 程序员
Java的基础概念一
### Java编程基础简介 #### 一、注释 注释用于解释代码,不会参与编译和运行。Java支持三种注释: - **单行注释**:以 `//` 开头。 - **多行注释**:以 `/* ... */` 包围。 - **文档注释**:通常用于生成开发文档。 #### 二、关键字 关键字是被Java赋予特定含义的英文单词,全部小写,且在代码编辑器中有特殊颜色标记。常用的如 `class` 表示定义一个类。
Java的基础概念一
|
1月前
|
Java 数据安全/隐私保护
Java的基础概念(二)
本文介绍了Java编程语言中的运算符和表达式,涵盖算术运算符、赋值运算符、关系运算符、逻辑运算符、三元运算符等。重点讲解了算术运算符的使用,如加减乘除取余,并强调了整数除法和取余的特殊性。同时,详细说明了隐式转换与强制转换的概念及应用场景,以及字符串和字符的拼接规则。通过多个案例演示了不同运算符的实际应用,包括数值拆分、自增自减、三元表达式的使用等。最后简要提及了运算符的优先级,指出小括号具有最高优先级。
|
2月前
|
安全 算法 Java
Java CAS原理和应用场景大揭秘:你掌握了吗?
CAS(Compare and Swap)是一种乐观锁机制,通过硬件指令实现原子操作,确保多线程环境下对共享变量的安全访问。它避免了传统互斥锁的性能开销和线程阻塞问题。CAS操作包含三个步骤:获取期望值、比较当前值与期望值是否相等、若相等则更新为新值。CAS广泛应用于高并发场景,如数据库事务、分布式锁、无锁数据结构等,但需注意ABA问题。Java中常用`java.util.concurrent.atomic`包下的类支持CAS操作。
83 2
|
2月前
|
监控 Java 数据库连接
Java线程管理:守护线程与用户线程的区分与应用
在Java多线程编程中,线程可以分为守护线程(Daemon Thread)和用户线程(User Thread)。这两种线程在行为和用途上有着明显的区别,了解它们的差异对于编写高效、稳定的并发程序至关重要。
64 2
|
8月前
|
Java API 容器
Java泛型的继承和通配符
Java泛型的继承和通配符
50 1

热门文章

最新文章