java高级--泛型

已于 2022-07-23 16:06:14 修改
阅读量177 收藏
点赞数
文章标签： java
于 2022-07-19 11:20:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JAVA_SR/article/details/125866707
版权

1.什么是泛型？

其实我们再使用集合时就用过泛型List<T> 创建一个List对象List<Student> list=new ArrayList();

<T>它就是泛型。

所谓的泛型就是在类定义时,不为类中属性和方法指定数据类型，而是在类对象创建时为其指定相应的数据类型。

2.为什么使用泛型?

例子: 要求定义一个Point点类，该类中属性有x坐标和y坐标。

要求: x和y的值可以都是整数类型。

​ x和y的值可以都是小数类型。

​ x和y的值可以都是字符串类型。

如何定义该类呢? 如何确定属性的类型。----Object类型

代码：

public class Point {
    //x轴坐标
    private T x;
    //y轴坐标
    private T y;

    public void show(){
        System.out.println("x轴坐标:"+x+" y轴坐标:"+y);
    }

    public Point() {
    }

    public Point(Object x, object y) {
        this.x = x;
        this.y = y;
    }

    public T getX() {
        return x;
    }

    public void setX(Object x) {
        this.x = x;
    }

    public T getY() {
        return y;
    }

    public void setY(Object y) {
        this.y = y;
    }
}

 测试：

public class Test01 {
    public static void main(String[] args) {
        Point p1 = new Point(10,20);
        p1.show();

        Point p2 = new Point(23.5,45.8);
        p2.show();

        Point p3 = new Point("东经60度","北纬120度");
        p3.show();
    }
}

如果我们为坐标一个赋值整数，一个赋值为字符串，这时会不会报错。

Point p4 = new Point(20,"南纬30度");//它违背了我们设计的要求，属于数据类型安全问题。
p4.show();

但是它违背了我们设计的要求，这就是我们提到的数据类型安全问题。如何解决数据类型安全问题?我们可以使用泛型来解决问题。

代码:

public class Point<T> {
    //x轴坐标
    private T x;
    //y轴坐标
    private T y;

    public void show(){
        System.out.println("x轴坐标:"+x+" y轴坐标:"+y);
    }

    public Point() {
    }

    public Point(T x, T y) {
        this.x = x;
        this.y = y;
    }

    public T getX() {
        return x;
    }

    public void setX(T x) {
        this.x = x;
    }

    public T getY() {
        return y;
    }

    public void setY(T y) {
        this.y = y;
    }
}
Point<Integer> p1 = new Point<Integer>(10,20);//坐标为整数int--自动装箱->Integer--->object(向上转型)
p1.show();

Point<Double> p2 = new Point<Double>(23.5,45.8);//坐标为小数
p2.show();

Point<String> p3 = new Point<String>("东经60度","北纬120度");//坐标为字符串
p3.show();

上面的泛型类型必须都是引用类型。不能是基本类型。

使用泛型就保证了数据类型安全问题。

3.如何定义泛型

泛型可以定义在类上，接口上，方法上。 泛型类，泛型接口以及泛型方法。

泛型可以解决数据类型的安全性问题，其主要原理是在类声明时通过一个标识表示类中某个属性的数据类型或者是某个方法的返回值及参数类型。这样在类声明或者实例化时只要指定好需要的类型即可。

格式：

public class 类名<泛型标志,泛型标志....>{

     //类成员
}

代码：

//T标志可以任意起名.----> 那么在创建对象时，必须为每个泛型指定数据类型
public class Info<T> {
    private T val;

    public void show(){
        System.out.println("val====================="+val);
    }
    public T getVal() {
        return val;
    }

    public void setVal(T val) {
        this.val = val;
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        Info<String> info1 = new Info<>();
        info1.setVal("mark");
        info1.show();

        Info<Integer> info2 = new Info<>();
        info2.setVal(10);
        info2.show();

        Info info3 = new Info();
        info3.setVal("今晚打老虎");
        String val = (String) info3.getVal();//如果想使用真正的类型接受，那么必须进行强制转换
        System.out.println(val);
    }
}

 4.通配符

 在开发中对象的引用传递是最常见的，但是如果在泛型类的操作中，在进行引用传递时泛型类型必须匹配才可以传递，否则是无法传递的。如果想传递，可以定义泛型为?通配符。

代码：

//T标志可以任意起名.----> 那么在创建对象时，必须为每个泛型指定数据类型
public class Info<T> {
    private T val;

    public void show(){
        System.out.println("val====================="+val);
    }
    public T getVal() {
        return val;
    }

    public void setVal(T val) {
        this.val = val;
    }
}

 测试：

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

        Info<Integer> i1 = new Info<>();
        i1.setVal(10);
        fun(i1);

        Info<String> i2 = new Info<>();
        i2.setVal("张三");//如果为泛型类型:不但要求数据类型相同之外还要求泛型类型也匹配。

        fun(i2);

        Info<Double> i3 = new Info<>();
        i3.setVal(23.5);
        fun(i3);
    }

    public static void fun(Info<?> info){
        info.show();
    }
}

5.受限泛型

在引用传递中，在泛型操作中也可以设置一个泛型对象的范围上限和范围下限。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型或者此类型的父类型。

语法：

[设置上限]
声明对象: 类名称<? extends 类> 对象名称;
定义类:  [访问权限] 类名称<泛型标识 extends 类>{}

[设置下限]
声明对象: 类名称<? super 类> 对象名称;
定义类:  [访问权限] 类名称<泛型标识 super 类>{}

代码：

//T标志可以任意起名.----> 那么在创建对象时，必须为每个泛型指定数据类型
public class Info<T> {
    private T val;

    public void show(){
        System.out.println("val====================="+val);
    }

    public T getVal() {
        return val;
    }

    public void setVal(T val) {
        this.val = val;
    }
}

 测试：

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

        Info<Object> i1 = new Info<>();
        i1.setVal(10);
        fun(i1);

        Info<Number> i3 = new Info<>();
        i3.setVal(23.5);
        fun2(i3);
    }

    /**
     *[设置下限]
     *声明对象: 类名称<? super 类> 对象名称;
     *定义类:  [访问权限] 类名称<泛型标识 super 类>{}
     * @param info
     */
    public static void fun(Info<? super Number> info){
        info.show();
    }
    /**
     * [设置上限]
     * 声明对象: 类名称<? extends 类> 对象名称;
     * 定义类:  [访问权限] 类名称<泛型标识 extends 类>{}
     * @param info
     */
    public static void fun2(Info<? extends Number> info){
        info.show();
    }
}

6.泛型接口

上面那些例子都是使用泛型类。而在jdk1.5以后，泛型也可以定义在接口上了，定义接口的泛型和定义泛型类语法相似。

语法：

public interface 接口名<泛型标志,泛型标志....>{
   //静态常量
   //抽象方法。
}

 类如何实现泛型接口:

//泛型接口
public interface USB<T> {
    public static final String NAME="";//常量的命名必须全部为大写。
    T fun();//抽象方法
}

 子类在继承接口的时，确定泛型类型：

public class KeyBoard implements USB<String>{
    @Override
    public String fun() {
        return "霹雳舞王赵四";
    }
}

子类也实现泛型和父类名相同的泛型：

//子类也实现泛型和父类名相同的泛型
public class Mouse<T> implements USB<T> {
    @Override
    public T fun() {
        return null;
    }
}

 测试：

public class Test {
    public static void main(String[] args) {
        KeyBoard k = new KeyBoard();
        String fun = k.fun();
        System.out.println(fun);

        Mouse<Integer> m = new Mouse<>();
        Integer fun1 = m.fun();
        System.out.println(fun1);
    }
}

 7.泛型方法

前面学习的所有泛型操作都是将整个类进行泛型化，但同样也可以在类中定义泛型化的方法。泛型方法的定义与其所在的类是否是泛型类是没有任何关系的，所在的类可以是泛型类，也可以不是泛型类。

【泛型方法的简单定义】

[访问权限]  <泛型标识>  泛型标识 方法名称(泛型标识 参数名称)

代码：

public class Student {
    //泛型方法: static静态成员，随着类的加载而被加载到JVM内存中。常量池
    public static <T> T fun(T t){
        return t;
    }
}

测试：

public class Test {
    public static void main(String[] args) {
        String fun = Student.fun("王五");
        Integer fun1 = Student.fun(10);
        Double fun2 = Student.fun(23.5);
        System.out.println(fun);
        System.out.println(fun1);
        System.out.println(fun2);
    }
}

8.java高级--注解

注释: java不会编译注释的内容，注释给程序员看的。

注解: 它是程序看，当程序看到这个注解时，就应该解析它。

注解的分类:

1. 预定义注解
2. 自定义注解
3. 元注解 

8.1预定义注解---了解

预定义注解就是JDK自带的一些注解，该注解被JVM而解析。

1. @Override: 重写得注解。符合重写得规则。
2. @Deprecated: 表示已过时。
3. @SuppressWarnings: 表示压制警告。
4. @FunctionInterface: 表示函数式接口。表示该接口中有且仅有一个抽象方法

8.2自定义注解。---初级

 语法：

public @interface 注解名{
   //注解属性
}

使用自定义注解：

类 方法  属性 加@注解名 

@My
public class Student {
    @My
    public String name;

    @My
    public void show(){
        System.out.println("name==================="+name);
    }
}


public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.name="张三";
        student.show();
    }
}

注解本身没有任何意义，它只有被解析了，才会赋予真正的意义。

我们后会使用反射来对象注解进行解析。

像:@Override 它被JVM解析，从而使其具有相应的意义。

​ @Controller @RequestMapping 它被Spring框架解析，所以具有相应的意义。

8.3元注解 

1.定义在注解上的注解称为元注解。

@Controller它只能加在类上 @Override它只能加在方法上。

原因它使用了元注解可以设置注解使用的位置。

1. @Target(value=可以取下面这些内容): 作用限制注解使用得位置。
    /** 表示可以作用在类,接口,枚举 */
    TYPE,

    /** 属性 */
    FIELD,

    /** 普通方法上 */
    METHOD,

    /** 方法参数 */
    PARAMETER,

    /** 构造方法上 */
    CONSTRUCTOR,

    /** 局部变量 */
    LOCAL_VARIABLE

2. @Retention:  注解什么时候生效。默认时源码 java经历了那些阶段。
      源码阶段-->字节码阶段--->运行阶段
      /**
     * 源码时生效
     */
    SOURCE,

    /**
     * 字节码时生效
     */
    CLASS,

    /**
     * 运行时生效。
     * 在JVM内存中还有该注解。
     都会被设置为运行时有效
     */
    RUNTIME
    
3. @Documented 当生产API文档时该注解还存在。 

4. @Inherited 是否运行被子类继承。

函数式接口：

@FunctionalInterface //函数式接口---那么就可以使用Lambda表达式
public interface USB {
    public void show();
}

 抑制警告：

@SuppressWarnings(value = "all") //抑制警告 一般不用
public class Test02 {
    public static void main(String[] args) {
        int i = 5;
    }
}

代码： 

public class Info {
    @Override //重写的注解:特点 该放啊必须与父类中的方法名相同，参数相同，返回类型相同，修饰符不能小于父类方法的修饰符。
    public String toString() {
        return "Info{}";
    }

    /**
     * replace by Info-->fun2();
     */
    @Deprecated //方法已过时
    public void fun(){

    }
    public void fun2(){

    }
}

测试： 

public class Test {
    public static void main(String[] args) {
        Info info = new Info();
        info.fun();

        Date date = new Date();
        date.getDate();
    }
}

8.4自定义注解---高级

思考: @RequestMapping("/hello") 因为它定义@RequestMaping注解中有属性。

@interface 注解名{
     数据类型 属性名() default 默认值;
}

数据类型: 基本类型，字符串类型，枚举类型【常量】，注解类型，数组类型【必须是上面这些类型的数组】

自定义注解：

//该注解可以使用的位置
@Target(value = {ElementType.TYPE,ElementType.METHOD})
//表示注解什么时候生效--source--class[默认字节码有效]--runtime[反射时验证]
@Retention(value = RetentionPolicy.RUNTIME)
//当生产API文档时该注解还存在。
@Documented
//子类是否能继承该注解，如果注解在定义时使用了下面这个元注解则能被子类继承
@Inherited
@interface My {

}

 使用自定义注解：

@My
public class Student {

    public String name;

    @My
    public void show(){
        System.out.println("name==================="+name);
    }
}

测试： 

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.name="张三";
        student.show();
    }
}

吃不饱肉的猫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
后端研究-泛型机制在Apla-Java程序生成系统中实现的方法研究.pdf
06-23
后端研究-泛型机制在Apla-Java程序生成系统中实现的方法研究 泛型机制是一种高级编程语言的重要机制，它可以提高软件的可靠性和生产效率。近年来，软件行业对泛型机制的研究和实现达到了新的高度。本文将研究在Apla...
Java高级篇-----泛型和注解
BUG专业户
07-13 272
Java泛型(泛型方法,泛型接口，泛型方法) 注解
Java反射获取方法泛型信息以及注解信息
weixin_44359124的博客
05-11 697
1. 通过反射获取泛型信息 定义两个方法 一个方法有泛型形参，没有返回值test01 一个方法没有形参，有泛型返回值test02 public void test01(Map<String, User> map, List<User> list) { System.out.println("test01"); } public Map<String, User> test02() { System.out.println("test02");
泛型方法
热门推荐
Rachel_pan的博客
11-27 1万+
文章目录一 、泛型方法二 、定义泛型方法三 、通过泛型方法返回泛型类实例四 、使用泛型统一传入的参数类型 一 、泛型方法 泛型方法的定义与其所在的类是否是泛型类是没有任何关系的，所在的类可以是泛型类，也可以不是泛型类 二 、定义泛型方法 class Demo{ public <T> T fun(T t){ //可以接收任意类型的数据 return t;...
Java泛型&注解
m0_46938055的博客
12-20 1740
泛型 1. 什么是泛型? **泛型**:类在定义时不为类中的属性，方法[返回值，参数]设置数据类型。在创建该类的对象时为其指定相应的数据类型。 2. 为什么要使用泛型？ 解决数据类型一致性的安全问题。使用泛型。 消除强制类型转换。泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。 潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译
java的泛型有哪些_Java 泛型
weixin_42528974的博客
02-25 802
1、泛型的由来我们先看下面这段代码：报错信息如下：也就是 集合中第二个数据是 Integer，但是我们取出来的时候将其转换为 String 了，所以报错。那么这个如何解决呢？①、我们在遍历的时候，根据每个数据的类型判断，然后进行强转。那么我们说这个集合只有两条数据，我们可以进行判断强转，如果数据有成千上万条呢，我们都通过这样判断强转肯定不可取②、在往集合中加入数据的时候，我们就做好限制，比如这个集...
Java高级特性-笔记.pdf
10-04
在Java编程语言中，高级特性包括了集合框架、泛型、实用类等多个重要概念。这些特性极大地增强了Java的灵活性和可维护性，是每个熟练Java开发者必备的知识。 首先，集合框架是Java中用于存储和操作对象的核心组件。...
Java泛型与数据库应用实例详解
08-25
Java泛型是Java SE 5.0引入的一个重要特性，它允许在定义类、接口以及方法时使用类型参数，从而增强了代码的复用性、安全性和可读性。在数据库应用中，泛型的运用可以使得数据库操作更加灵活且类型安全。 在上述...
Java高级特性 第一章 集合框架和泛型
10-23
"Java高级特性：集合框架和泛型" Java高级特性系列第一章：集合框架和泛型 Collections Framework是Java语言中一个基础的数据结构.framework，它提供了多种类型的数据结构，包括List、Set、Map等，帮助开发者更...
Java高级之—泛型的使用
12-21
一、泛型的概念 1.什么是泛型，看表面的意思，泛型就是指广泛的、普通的类型 2. 所谓泛型，就允许在定义类、接口时通过圆滚滚标识表示类中的某个属性的类型或者某个方法的返回值及参数类型。 这个参数类型将在使用的...
泛型的用法
m0_69715573的博客
07-21 374
泛型如何使用
JAVA高级篇----泛型
莫绝岚的小屋
07-13 293
泛型的详细使用及简单介绍
Java泛型、泛型类、泛型方法详解
weixin_43896829的博客
05-22 2945
一、泛型 泛型是Java 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java泛型被引入的好处是安全简单。在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是
java高级-泛型
塘枫蒲的博客
07-23 585
Java高级泛型
Java高级之---泛型的使用
weixin_43244120的博客
04-18 1595
一、泛型的概念 1.什么是泛型，看表面的意思，泛型就是指广泛的、普通的类型 2. 所谓泛型，就允许在定义类、接口时通过圆滚滚标识表示类中的某个属性的类型或者某个方法的返回值及参数类型。 这个参数类型将在使用的时候就确定了。 使用泛型有哪些好处 （1）首先就像上面那个例子一样，使用泛型能够限定集合中，如List, Set中元素的类型，保证一个集合中只有一个类型。 （2）程序也能更加健壮（只要在编译时...
Java高级-泛型
weixin_45900005的博客
10-26 951
12.泛型 1.泛型的概念 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时确定（即传入实际的类型参数，也称为类型实参)。 12.1.为什么要用泛型 泛型与File中使用泛型举例 泛型的使用 泛型即传入实际的参数类型,也称类型实参 1.jdk5.0新增的特性 2.在集合中使用泛型: 总结: ①集合接口或集合类在jdk5.0时都修改为带泛型的就够. ②在实例化集合类时
Java高级编程——泛型
qq_61524266的博客
06-12 679
Java高级编程——泛型
Java语言高级特性之——泛型详解
qq_43262128的博客
08-02 292
Java语言高级特性之——泛型 一、泛型的概念及主要作用 定义：泛型即参数化类型，将数据类型作为参数传入，例如List、List等等。 泛型的作用有： （1）适用于多种数据类型执行相同的代码； （2）指定容器（Map、List、Set等）的类型，不需要进行强制转换。 二、泛型的使用 可以定义泛型类、泛型接口和泛型方法。 泛型类的定义： class 类名 { } 其中T为泛型参数，常用大写字母T、K、V或E表示，也可使用字符串表示，泛型参数允许有多个，如下例： public class A<T>{
【Java高级编程】泛型
孙不坚1208
06-29 189
泛型
Java高级特性：泛型
最新发布
07-29
回答: 泛型是Java的一种高级特性，它允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。\[1\]在集合中使用泛型可以提供类型安全性，避免了强制类型转换的问题。例如，在不使用泛型的情况下，我们需要将元素从集合中取出时进行强制类型转换，而使用泛型后，我们可以直接获取到指定类型的元素，无需进行强制类型转换。\[2\]此外，泛型还可以在编译时进行类型检查，保证数据的安全性。\[3\]因此，泛型是Java中一种非常有用的高级特性。 #### 引用[.reference_title] - *1* *3* [Java高级编程：泛型](https://blog.csdn.net/soulmate______/article/details/107880754)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [Java高级特性 - 集合框架（1）第4关：泛型](https://blog.csdn.net/weixin_46019348/article/details/124988774)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值