Java高级--泛型和注解

小白N+1

已于 2022-07-14 19:14:50 修改

阅读量147

点赞数

文章标签： java

于 2022-07-14 10:52:58 首次发布

本文链接：https://blog.csdn.net/weixin_68507438/article/details/125770532

版权

一、Java高级--泛型

1、什么是泛型

泛型是 Java SE5 出现的新特性，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是类型参数化或参数化类型，在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型。

2、为什么要使用泛型

泛型类和泛型方法同时具备可重用性、类型安全和效率，这是非泛型类和非泛型方法无法具备的。泛型通常用与集合以及作用于集合的方法一起使用。 .NET Framework 2.0 版类库提供一个新的命名空间 System.Collections.Generic，其中包含几个新的基于泛型的集合类。建议面向 .NET Framework 2.0 及更高版本的所有应用程序都使用新的泛型集合类，而不要使用旧的非泛型集合类如 ArrayList。

例子: 要求定义一个Point点类，该类中属性有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;
    }
}

测试：

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

测试：

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

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

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

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

3、如何使用/定义泛型

定义泛型语法：

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

     //类成员
}

例子：

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

测试：

public 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);

    }
}

4、泛型通配符

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

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

        Person<String> p1 = new Person<>("你好");
        fun(p1);

        Person<Integer> p2 = new Person<>(111);
        fun(p2);
    }
    //问号？代表通配符，可以使用任意的数据类型
    public static void fun(Person<?> person){
        person.show();
    }
}
/*泛型类*/
class Person<T> {
    private T var;

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

    public Person() {
    }

    public Person(T var) {
        this.var = var;
    }

    public T getVar() {
        return var;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "var=" + var +
                '}';
    }
}

5、受限泛型

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

受限泛型语法：

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

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

例子：

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

        Person<Number> p1 = new Person<>(111);
        fun2(p1);

        Person<Integer> p2 = new Person<>(222);
        fun3(p2);
    }

    //传递的参数泛型类型必须为Number的父类或者Number类型
    public static void fun2(Person<? super Number> person){
        person.show();
    }
    //传递的参数泛型类型必须为Number的子类或者Number类型
    public static void fun3(Person<? extends Number> person){
        person.show();
    }
   
}
/*泛型类*/
class Person<T> {
    private T var;

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

    public Person() {
    }

    public Person(T var) {
        this.var = var;
    }

    public T getVar() {
        return var;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "var=" + var +
                '}';
    }
}

6、泛型接口

泛型接口在jdk1.5之后才可以定义在接口上。定义语法上和定义泛型的语法相似。

泛型接口的语法：

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

/*泛型接口*/
interface person<T>{
    T fun(T t);
}
/*第一种方式 直接在继承的泛型中定义好类型
* 子类在实现接口时，确定泛型类型*/
class persons implements person<Integer>{


    @Override
    public Integer fun(Integer integer) {
        return 111;
    }
}

/*第二种方式 子类也实现泛型和父类名相同的泛型
* 实现的类型自己定义 */
class pop<T> implements person<T>{

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

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


        persons persons = new persons();
        System.out.println(persons.fun(11));

        pop<Integer> mouse = new pop<>();
        Integer fun = mouse.fun(123);
        System.out.println(fun);
    }

7、泛型方法

语法：

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

class Tests {
    public static <T> T fun(T t) {
        return t;
    }
}
public class Test01 {
    public static void main(String[] args) {

        String hello = Tests.fun("hello");
        Integer fun1 = Tests.fun(250);
        Double fun2 = Tests.fun(250.0);
    }

二、Java高级--注解

1、预定义注解

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

2、自定义注解（初级）

语法：

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

使用自定义注解

类方法属性加@注解名

//自定义注解
@interface My{
    String [] name() default {"tom","jack"};
    String value() ;

}
//使用注解
@My(value = "",name = "")
class Person{

}

3、元注解

@Retention：指定其所修饰的注解的保留策略
@Document：该注解是一个标记注解，用于指示一个注解将被文档化
@Target：用来限制注解的使用范围
@Inherited：该注解使父类的注解能被其子类继承
@Repeatable：该注解是Java8新增的注解，用于开发重复注解
类型注解（Type Annotation）：该注解是Java8新增的注解，可以用在任何用到类型的地方

@Target(value=可以取下面这些内容): 作用限制注解使用得位置。

/** 表示可以作用在类,接口,枚举 */
TYPE,

/** 属性 */
FIELD,

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

/** 方法参数 */
PARAMETER,

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

/** 局部变量 */
LOCAL_VARIABLE

@Retention: 注解什么时候生效。默认时源码 java经历了那些阶段。

源码阶段-->字节码阶段--->运行阶段
/**
* 源码时生效
*/
SOURCE,

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

/**
* 运行时生效。
* 在JVM内存中还有该注解。
都会被设置为运行时有效
*/
RUNTIME

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

@Documented 当生产API文档时使用该注解

4、自定义注解（高级）

语法：

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

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

@interface MyAnnotation {
    String value(); //如果设置default默认值，那么在使用该注解时可以不为该属性赋值。
    int age() default 15;
}
//如果只有一个属性 value可以省略不写 但是该属性名必须为value
@MyAnnotation("zs")
class Base {
}


//多个属性时
@interface MyAnnotation {
    String value(); 
    int age() default 15;//设置default默认值，那么在使用该注解时可以不为该属性赋值。
    String[] hobby();
}
//如果只有一个属性 value可以省略不写 但是该属性名必须为value 如果存在多个属性必须要写value="" hobby=""
@MyAnnotation(value = "zs",hobby = {"游泳，唱歌"})
class Base {
}