JAVA高级(泛型和注解)

future_n

已于 2023-08-19 11:24:34 修改

阅读量153

点赞数 2

文章标签： java 开发语言

于 2023-08-09 21:02:40 首次发布

本文链接：https://blog.csdn.net/future_n/article/details/132194973

版权

JAVA高级

泛型
注解

泛型

1.什么是泛型

常见泛型:—>集合中

在定义类时，不给定类中成员【属性方法的返回类型方法的参数】的数据类型，而在类对象创建时为其指定相应的数据类型。

2.为什么使用泛型?

public class Point {
    private Object x; 
    private Object y;

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

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", 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 Test01 {
    public static void main(String[] args) {
        //x和y的值都是字符串类型
        Point p1=new Point("东经180度","北纬72度");
        //x和y的值都是整型
        Point p2=new Point(180,72);
        //x和y的值都是小数
        Point p3=new Point(180.6,72.6);

        //可以一个是字符串一个为整型。
        Point p4=new Point("东经180度",72);


        String x= (String) p4.getX();
        String y= (String) p4.getY();

        //数据类型不安全问题。---因为你在定义Point类型指定的属性类型为Object.

    }
}

所以导致我们在给Point类中属性赋值时可以赋值任意类型，在后面获取相应属性时，会出现数据类型安全问题。

我们可以使用泛型来解决上面的数据类型安全问题。

3.如何定义泛型

语法:
public class 类名<泛型标志，泛型标志…>{
public 泛型标志属性名;
}
–泛型标志可以是任意字符。习惯使用T

public class Point<T> {
    private T x;
    private T y;

    @Override
    public String toString() {
        return "Point{" +
                "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 Test01 {
    public static void main(String[] args) {
        Point<String> stringPoint = new Point<>("东经180", "西经150");
        String x =stringPoint.getX();
        String y = stringPoint.getY();
        System.out.println(x);
        System.out.println(y);

        Point<Integer> integerPoint = new Point<>(45, 25);
        Integer x1 = integerPoint.getX();;
        Integer y1 = integerPoint.getY();
        System.out.println(integerPoint);
    }
}

注意: 指定泛型类型时，这种泛型类型必须为引用类型。

4.通配符

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

public class Test {
    public static void main(String[] args) {
        Info<String> info = new Info<>();
        info.setVar("字符串");
        Info<Integer> info1 = new Info<>();
        info1.setVar(12);
        Info<Double> info2 = new Info<>();
        info2.setVar(25.5);
        fun(info);
        fun(info1);
        fun(info2);
    }
    public static void fun(Info<?> info){
        info.show();
    }
}
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;
    }
}

4.2 受限泛型

在引用传递中，在泛型操作中也可以设置一个泛型对象的范围上限和范围下限。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型或者此类型的父类型。
格式:
[设置上限]
声明对象: 类名称<? extends 类> 对象名称;
定义类: [访问权限] 类名称<泛型标识 extends 类>{}

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

public class Test {
    public static void main(String[] args) {
        Info<String> info = new Info<>();
        info.setVar("字符串");
        Info<Object> info3 = new Info<>();
        info3.setVar(25);
        Info<Integer> info1 = new Info<>();
        info1.setVar(12);
        Info<Double> info2 = new Info<>();
        info2.setVar(25.5);
        fun02(info);
        fun(info1);
        fun(info2);
        fun02(info3);
    }
    public static void fun02(Info<? super String> info){
        info.show();
    }
    public static void fun(Info<? extends Number> info) {
        info.show();
    }
}

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 interface 接口名<泛型标识,…>{

}
接口用来被类实现。一个类如何实现泛型接口。有两种方式

（1) 在实现泛型接口时为泛型接口指定类型。

(2) 该类也是一个泛型类，而且该类使用的泛型标志必须和接口的标志一致。

public class Test {
    public static void main(String[] args) {
        Phone p = new Phone();
        p.type("华为");

        Computer<Integer> integerComputer = new Computer<>();
        integerComputer.type(10000);
    }
}
/**
 * 定义泛型接口
 */
interface TypeC<T>{
    public abstract void type(T t);
}
/**
 * 第一种实现泛型接口时为其指定泛型类型
 */
class Phone implements TypeC<String>{

    @Override
    public void type(String s) {
        System.out.println("手机实现类:"+s);
    }
}
/**
 * 第二种:类实现接口时该类也设置为泛型类,标志必须和接口一致
 */
class Computer<T> implements TypeC<T>{

    @Override
    public void type(T t) {
        System.out.println("电脑实现类:"+t);
    }
}

6.泛型方法

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

【泛型方法的简单定义】

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

}

  public static void main(String[] args) {
        Test test = new Test();
        test.fun(23);
        test.fun("hello");
    }
    public <T> T fun(T t){
        System.out.println("111111111"+t);
        return t;
    }

注解

1.预定义注解

@Override: 当方法使用该注解时，表示该方法是一个重写的方法，那么该方法必须符合重写的规则【子类重写的方法名必须和父类的方法名一致，参数也要一致，返回值也要一致访问修饰不能小于父类的<public protected 默认 private> 抛出的异常不能大于父类】。

@Deprecated: 标记该方法已经过时。JVM

@FuncationInterface: 函数式接口.—要求接口钟有且仅有一个抽象方法

2.自定义注解

语法:
public @interface 注解名{

}
如何使用
@注解名

ublic class Test {
    public static void main(String[] args) {
        Test01 test01 = new Test01();
        test01.show("ok");
    }
}
@interface qy{

}
class Test01{
    @qy
    private String name;

    @qy
    public void show(@qy String s){
        System.out.println("查看效果:"+s);
    }
}

使用了自定义注解并没有任何意思，要想让他有意义，必须结合后反射来解析这些注解，并赋予相应的作用。

@Override:----JVM解析了该注解

@Controller:—spring框架解析了该注解。

3.元注解

思考: @Controller只能使用在类上。 @GetMapping只能使用在方法。为什么这些注解可以限制它的使用范围。因为它们用来元注解来限制。

@Retention: 限制注解什么时候生效。【源码—javac—字节码----运行】

 SOURCE,源码时生效

 
 CLASS,字节码时生效

 
 RUNTIME,运行时生效。反射

@Target: 该注解可以使用在哪些地方


 TYPE,使用在类上

 FIELD,使用在属性上

 METHOD,使用在方法上

 PARAMETER,使用在参数

 CONSTRUCTOR,使用在构造方法上

@Documented: 在生成api文档是是否含有该注解。中文需要添加编码解析器
在这里插入图片描述

4.自定义注解–[属性]

语法:

public @interface 注解名{

         数据类型 属性名() default 默认值; 

      //如果没有设置默认值，那么在使用该注解时必须为该属性指定值。

}
基本数据类型, 字符串类型，枚举类型，注解类型，以及上面这些类型的数组类型。

MyAnnotation注解代码块

//注解只能运用在类上
@Target(ElementType.TYPE)
//这个使用最多。运行有效
@Retention(value = RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation {
    //基本类型
    int age() default 18;

    //字符串类型
    String name();

    //枚举类型
    MyEnum address();

    //注解类型
    Qy qy();

    //基本数组类型
    int[] ages();

    //字符串数组类型
    String[] names();

   /* //枚举数组类型
    MyEnum[] addresss();

    //注解数组类型
    Qy[] qys();*/


}

Qy注解代码块

@Target(ElementType.TYPE)
@interface Qy {
    int value();
    String name();
}

实体类代码块

//如果属性为数组类型，给数组类型赋值时如果只有一个值那么可以省略{}
//如果该注解中只使用value属性，那么value属性名可以省略 如果需要使用两个属性则value不能省略
@MyAnnotation(name = "张三",address = MyEnum.BEIJING,qy=@Qy(value = 0, name = ""),ages={15,25,35},names="hello")
@Qy(value = 18,name = "黎明")
public class Student {
    public void show(){
        System.out.println("hello");
    }
}