泛型与注解

最新推荐文章于 2022-12-09 17:36:30 发布
最新推荐文章于 2022-12-09 17:36:30 发布
阅读量181 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huyulong0612/article/details/125777829
版权

        

1. java高级--泛型

1. 什么是泛型?
2. 为什么使用泛型?
3. 如何使用泛型?
4. 泛型类
5. 泛型的通配符
6. 泛型的上限和下限
7. 泛型接口
8. 泛型方法

2.什么是泛型?

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

<T>它就是泛型。

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

3. 为什么使用泛型?

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

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

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

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

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

public class Point {
    //x坐标
    private Object x;
    //y坐标
    private Object 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 Object getX() {
        return x;
    }

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

    public Object getY() {
        return y;
    }

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

ublic class Test {
    public static void main(String[] args) {
        Point p1=new Point(10,20);//坐标为整数int--自动装箱->Integer--->Object(向上转型)
        p1.show();

        Point p2=new Point(25.5,36.6);//坐标为小数
        p2.show();

        Point p3=new Point("东经180度","北纬25度");//坐标为字符串
        p3.show();
    }

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

Point p4=new Point(25,"北纬50度");
        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>(25.5,36.6);//坐标为小数
        p2.show();

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

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

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

4. 如何定义泛型

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

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

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

     //类成员
}
ublic class Test03 {
    public static void main(String[] args) {
        Info<String> info=new Info<>();
        info.setVar("hello");
        info.show();

        Info<Integer> info1=new Info<>();
        info1.setVar(15);
        info1.show();

        //如果没有指定泛型类型默认为Object,
        Info  info2=new Info();
        info2.setVar("杨坤想睡不?");

        String o = (String) info2.getVar();//如果想使用真正的类型接受，那么必须进行强制
        System.out.println(o);

    }
}
//T标志可以任意起名.----> 那么在创建对象时，必须为每个泛型指定数据类型。
class Info<T>{
    private T var;
    public void show(){
        System.out.println("var========"+var);
    }

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }

5. 通配符

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

public class Test04 {
    public static void main(String[] args) {
            Info<Integer> i=new Info<>();
            i.setVar(250);
            fun(i);

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

           Info<Double> i3=new Info<>();
           i3.setVar(25.5);
           fun(i3);

            //能不能设置泛型类型可以接受任意的类型呢? 我们可以使用同配置?
    }

    //该方法的参数为Info而且它的泛型为Integer类型
    public static void fun(Info<?> info){
         info.show();
    }
}

//T标志可以任意起名.----> 那么在创建对象时，必须为每个泛型指定数据类型。
class Info<T>{
    
    private T var;
    public void show(){
        System.out.println("var========"+var);
    }

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }

6. 受限泛型

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

语法:

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

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

public class Test04 {
    public static void main(String[] args) {
         Info<Number> i=new Info<>();
         fun2(i);

         Info<Object> i3=new Info<>();
         fun2(i3);

         Info<Integer> i4=new Info<>();
         fun2(i4);
    }


    //传递的参数泛型类型必须为Number的父类或者Number类型
    public static void fun2(Info<? super Number> info){
        info.show();
    }
    //传递的参数泛型类型必须为Number的子类或者Number类型
    public static void fun(Info<? extends Number> info){
         info.show();
    }
}
//当创建该类对象时，泛型必须为Number的子类以及Number类型
class People<T extends  Number> {

}

//T标志可以任意起名.----> 那么在创建对象时，必须为每个泛型指定数据类型。
class Info<T>{
    
    private T var;
    public void show(){
        System.out.println("var========"+var);
    }

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}

7. 泛型接口

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

语法:

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

 类如何实现泛型接口:

public class Test {
    public static void main(String[] args) {
        Upan u=new Upan();

        Mouse<Integer> mouse=new Mouse<>();

    }
}
//泛型接口
interface USB<T>{
     public static final String NAME=""; //常量的命名必须全部大写。
     T fun(); //抽象方法
}
//子类在实现接口时，确定泛型类型
class Upan implements USB<String>{

    @Override
    public String fun() {
        return "hello world";
    }
}

//子类也实现泛型和父类名相同的泛型
class Mouse<T> implements USB<T>{

    @Override
    public T fun() {
        return null;
    }
}

8. 泛型方法

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

【泛型方法的简单定义】

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

public class Test {
    public static void main(String[] args) {
        String hello = Student.fun("hello");
        Integer fun = Student.fun(250);
        Double fun1 = Student.fun(250.0);
    }
}

class Student{

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

        return t;
    }
}

2. java高级--注解

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

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

譬如: @Controller @Override

注解的分类:

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

2.1 预定义注解---了解

 语法:

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

使用自定义注解:

 类 方法  属性 加@注解名

public class Test {
    public static void main(String[] args) {
        Info i=new Info();
        i.name="周世玉";
        i.show();
    }
}
//定义好注解了
@interface My{
   //注解属性
}

//使用注解
@My
class Info{
    @My
    public String name;

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

注意: 使用注解和不使用注解没有区别？

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

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

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

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

2.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 是否运行被子类继承。

2.4 自定义注解---高级

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

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

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

梦@回忆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专题学习（泛型，注解）
m0_47782122的博客
09-23 109
这是一个专题学习
Java泛型基础与注解
最新发布
cccy的博客
08-09 130
泛型可以解决数据类型的安全性问题，其主要原理是在类声明时通过一个表示类中某个属性的数据类型或者是某个方法的返回值及参数类型。这样在类声明或者实例化时只要指定好需要的类型即可。语法:public class 类名{泛型标志可以是任意字符。习惯使用Tthis.x = x;this.y = y;return x;this.x = x;return y;this.y = y;
泛型，注解
m0_48950672的博客
09-14 211
泛型注解小总结
泛型
再来一块红烧肉
03-24 222
我们为什么需要泛型？ 泛型 泛型方法 泛型类
反射、注解、泛型项目中结合案例
weixin_45759284的博客
12-09 340
反射注解泛型项目结合案例
Java基础加强
走在技术路上的初学者的博客
08-03 437
Java基础加强之一  一：jdk1.5 增加的java中的新特性: 自动装箱拆箱  Integer i = 10;   i = 10 + i; 静态导入 import static  可变参数  (int i...) 内省  反射 剖析类,分析类的成员 二：泛型 Generic 1.集合泛型:在没有泛型之前,集合中存入的数据,类型就会丢失掉,在取出数据时,需要做强制类型转
java泛型反射注解
08-18
先说一下遇到的问题：通过使用GSON泛型进行报文转换的时候想要对部分关键字段加密，发现在封装好的方法中，对个别字段的加密满足不了。 解决过程：首先通过反射获取到bean下的对象名称。 对象名称获取到了之后需要...
泛型和注解--高级
Tboy_的博客
07-14 418
目录一.泛型1.什么是泛型2.为什么使用泛型3.通配符4.受限泛型 5.泛型接口 6.泛型方法 二.注解1. 预定义注解2. 元注解3.自定义注解 所谓的泛型就是在类定义时,不为类中属性和方法指定数据类型，而是在类对象创建时为其指定相应的数据类型。定义一个Point点类，该类中属性有x坐标和y坐标。要求: x和y的值可以都是整数类型。​ x和y的值可以都是小数类型。​ x和y的值可以都是字符串类型。如何定义该类呢? 此时发现可以满足我们的要求，但也有一个问题，如果我们为坐标一个赋值整数，一个赋值为字符
java反射、泛型、注解、代理精讲
06-10
本课程是《 java就业班》系统课程的第24章，全套课程精细讲解，该课程超过其他机构30%的课程量，经过我们全套课程系统学习的同学，可轻松从事Java高级工程师或系统架构师岗位，课程提供全套代码笔记其它相关素材及...
Java基础入门四泛型反射注解.pdf
08-28
注解是Java SE 5中的另一个新特性，它提供了一种机制，用于将任何信息或元数据与程序中的元素（如类、方法、变量等）关联起来。注解不会直接影响代码的操作，但可以被编译器读取，以执行某些特定任务，比如生成额外...
泛型和注解
m0_58380757的博客
07-14 177
泛型hezhujie
Java泛型&注解
m0_46938055的博客
12-20 1808
泛型 1. 什么是泛型? **泛型**:类在定义时不为类中的属性，方法[返回值，参数]设置数据类型。在创建该类的对象时为其指定相应的数据类型。 2. 为什么要使用泛型？ 解决数据类型一致性的安全问题。使用泛型。 消除强制类型转换。泛型的一个附带好处是，消除源代码中的许多强制类型转换。这使得代码更加可读，并且减少了出错机会。 潜在的性能收益。 泛型为较大的优化带来可能。在泛型的初始实现中，编译器将强制类型转换（没有泛型的话，程序员会指定这些强制类型转换）插入生成的字节码中。但是更多类型信息可用于编译
java泛型和注解
不积跬步无以至千里
06-03 541
泛型和注解笔记一．基本注解       @Override：指定方法重写，强制一个子类必须重写父类的方法。只能作用于方法，不能作用于其他元素。   @Override    public String toString() {       // TODO Auto-generated method stub       returnsuper.toString();    }       ...
JAVA List泛型限制
jifengnan的博客
08-21 4326
相信有很多朋友已经发现在JAVA中下面的代码会报错，但却不知道为什么，百度搜来搜去也都没有一个完全能够让人信服的解释。 public class Tester{ public static void main(String[] args) { List&lt;? extends Chinese&gt; list = new ArrayList&lt;ZhangSan&g...
Java初学笔记（四）：注解和泛型
Qngcken的博客
04-13 410
文章目录注解泛型泛型技术: 擦拭法extends通配符super通配符`extends`与`super`对比:PECS原则无限定通配符泛型和反射关于使用泛型 注解 所有注解都继承自java.lang.annotation.Annotation 自定义注解 public @interface XXX { // 使用@interface声明注解，public指定作用域 int type(...
Java基础知识-泛型、反射、注解
weixin_46025531的博客
01-16 870
一、泛型 泛型是 Java 中另一个使用非常广泛的特性，泛型中的「泛」指的是参数类型不固定， 也就是说什么数据类型都可以，它还有另一个名字，就是「参数化类型」——也就是说不仅 数据本身是参数，数据类型也可以被指定为参数——类、接口或者方法可以被不同类型的参数所重用。 ...
（黑马程序员）学习笔记，简单注解和泛型
jzxyhjl的专栏
06-18 339
package demo; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /* * 注解(Annotation):
java 自定义注解 & 泛型
limonero
11-19 1689
一、自定义注解 1、定义注解使用@inteface,基本注解的定义 package com.lemon.self.annotation.zhujie; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * 自定义注解
JavaWeb学习笔记：Eclipse使用、断点调试到泛型与注解
此外，还涉及了泛型、注解、类加载器的工作原理以及XML解析技术。" 在这个JavaWeb开发的学习资源中，首先讲解了Eclipse IDE的基本使用，包括如何进行程序的断点调试，理解Debug窗口和Breakpoints窗口的功能，以及在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值