java高级--泛型

淚、只爲妳而流

已于 2022-07-21 11:07:43 修改

阅读量130

点赞数

文章标签：大数据

于 2022-07-17 20:44:49 首次发布

本文链接：https://blog.csdn.net/w_13579ww/article/details/125836185

版权

一、什么是泛型

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

二、如何定义泛型

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

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

格式:

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

//类成员

}

private T value;

    public Info() {

    }


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


    public Info(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

Info<String> info1=new Info<>();
       info1.setValue("你好");
       info1.show();

       Info<Integer> info2=new Info<>();
       info2.setValue(13);
       info2.show();

        //如果没有指定泛型类型默认为Object
       Info info3=new Info();
       info3.setValue("早安");

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

三、通配符

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

 Info<Double> info1=new Info<>();
        info1.setValue(13.4);
        fun(info1);

        Info<Integer> info2=new Info<>();
        info2.setValue(125);
        fun(info2);
//如果为泛型类型:不但要求数据类型相同之外还要求泛型类型也匹配
        Info<String> info3=new Info<>();
        info3.setValue("你好");
        fun(info3);
    }
    //该方法的参数为Info而且它的泛型为Integer类型
    private static void fun(Info<?> info) {
        info.show();
    }

四、受限泛型

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

语法:

[设置上限]

声明对象: 类名称<? extends 类> 对象名称;

定义类: [访问权限] 类名称<泛型标识 extends 类>{}

[设置下限]

声明对象: 类名称<? super 类> 对象名称;

定义类: [访问权限] 类名称<泛型标识 super 类>{}

 private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

 Info<Number> i=new Info<>();
        fun2(i);

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

        Info<Integer> i3=new Info<>();
        fun(i3);
    }


    //传递的参数泛型类型必须为Number的子类或者Number类型
    public static void fun(Info<? extends Number>info){
        info.show();
    }

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

    }

五、泛型接口

上面那些例子都是使用泛型类。而在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;
    }
}

六、泛型方法

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

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;
    }
}

七、预定义注解

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

1. @Override: 重写得注解。符合重写得规则。

2. @Deprecated: 表示已过时。

3. @SuppressWarnings: 表示压制警告。

4. @FunctionInterface: 表示函数式接口。表示该接口中有且仅有一个抽象方法

八、自定义注解

语法:

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框架解析，所以具有相应的意义。

九、元注解

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

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

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

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

    /** 属性 */
    FIELD,

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

    /** 方法参数 */
    PARAMETER,

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

    /** 局部变量 */
    LOCAL_VARIABLE

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

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

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

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

淚、只爲妳而流

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java高级--泛型

在引用传递中，在泛型操作中也可以设置一个泛型对象的==范围上限==和==范围下限==。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型或者此类型的父类型。在开发中对象的==引用传递==是最常见的，但是如果在泛型类的操作中，在进行==引用传递时泛型类型必须匹配才可以传递，否则是无法传递的==。而在jdk1.5以后，泛型也可以定义在接口上了，定义接口的泛型和定义泛型类语法相似。声明对象类名称.....
复制链接

扫一扫