1. JAVA的高级

1、什么是泛型？
2. 为什么使用泛型？
3. 如何定义类的泛型？
4. 泛型的限制。
5. 如何定义泛型接口?
6. 如何定义泛型方法。
7. 注解
8. 预定义注解
9. 自定义注解
10.元注解

2. 什么是泛型？

常见泛型:--->集合中

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

3. 为什么使用泛型?

例子: 定义一个点类。x坐标和y坐标。

要求: x和y的值可以都是字符串类型

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

​ x和y的值都可以是整型。

package com.demo;

public class Point {
    private Object x; //为什么使用Object类型。因为Object是所有类的父类，--自动向上转型
    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;
    }
}

package com.demo;

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类中属性赋值时可以赋值任意类型，在后面获取相应属性时，会出现数据类型安全问题。

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

4. 如何定义泛型类

语法:

public class 类名<泛型标志，泛型标志.....>{
    public 泛型标志 属性名;

}
--泛型标志可以是任意字符。习惯使用T

package com.demo02.demo;

//点类
public class Point<T> {
    private T x; //为什么使用Object类型。因为Object是所有类的父类，--自动向上转型
    private T y;

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

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", 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;
    }
}

package com.demo02.demo;

public class Test01 {
    public static void main(String[] args) {
         Point<String> p1=new Point<String>("东经180度","北纬35度");
         String x = p1.getX();
         String y = p1.getY();


        Point<Integer> p2=new Point<Integer>(15,25);
        Integer x1 = p2.getX();
        Integer y1 = p2.getY(); //出现数据类型转换问题----不会出现数据类型安全问题。

    }
}

5.通配符

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

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 Test {
    public static void main(String[] args) {
        Info<String> i=new Info<String>();
        i.setVar("今天项目结束了");

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

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

        fun(i);
        fun(i2); //引用传递--泛型   必须类型相同，而且泛型也要项目
        fun(i3);

    }
    //
    public static void fun(Info<?> info){ //能否该方法让它可以接受任意的泛型类型。必须使用通配符 ?为泛型的通配符
        info.show();
    }
  }

6分钟

5.2 受限泛型

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

格式:

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

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

package com.aaa.entety;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
public class a {
    public static void main(String[] args) {
        a a = new a();
        //创建一个c对象，存入值，调用c类里的show方法
        c<Integer,String,Double> c = new c<Integer,String,Double>();
        c.setA(12);
        c.setD("a");
        c.setC(1.5);
        c.show();
        //新建一个c对象，存入值，调用fun方法
        c<Number,String,Double> d = new c<Number,String,Double>();
        d.setA(1);
        d.show();
        fun(c);
        fun(d);
        //新建一个d类，存入值， 调用fun方法
        d<Number> numberd = new d<Number>();
        numberd.setA(1);
        fun2(numberd);
    }

    public static void fun(c<?,?,?>  a) {
        System.out.println(a);
    }

    public static void fun2(d<? super Number> a) {
        System.out.println(a);
    }

}
@Data
@AllArgsConstructor
@NoArgsConstructor
 class c<t extends Number,b extends String,e extends Number>{
         private t a;
         private b d;
         private e c;
         public void show(){
             System.out.println("========"+a);
             System.out.println("========"+d);
             System.out.println("========"+c);
         }
}
@Data
@AllArgsConstructor
@NoArgsConstructor
class d<t>{
    private t a;

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

    }
}

6. 泛型接口

语法:

public interface 接口名<泛型标识,....>{

}

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

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

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

package com.aaa.entety;

public class b {
    public static void main(String[] args) {
        mouse mouse = new mouse();
        mouse.use("a");
        upan<Integer> i = new upan<>();
        i.use(1);
    }
}
//定义了泛型接口
interface usb<T>{
public abstract void use(T t);
}
//第一种 类实现泛型接口时为其指定泛型类型。
class mouse implements usb<String>{

    @Override
    public void use(String s) {
        System.out.println(s);
    }
}
//第二种 类实现接口时该类也设置为泛型类，标志必须和接口的泛型标志一致  List   ArrayList
class  upan<T> implements usb<T>{

    @Override
    public void use(T t) {
        System.out.println(t);
    }
}

7. 泛型方法

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

【泛型方法的简单定义】

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

}

  public static <T> upan  use(upan<T> a){
        System.out.println(a);
        return a;
    }

9. 注解

9.1 预定义注解

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

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

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

9.2 自定义注解

语法:

public @interface 注解名{

}

如何使用:

@注解名

package com.aaa.entety;

public class zs {
    public static void main(String[] args) {
        Hello h = new Hello();
        h.show("a");
    }
}
@interface My{

}
@My
class Hello{
    @My
    private String name;
    @My
    public void show(@My String n){
        System.out.println("~~~~~~~~~~~~~~~~~~~"+n);
    }
}

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

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

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

9.3 元注解

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

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

    //源码时生效
    SOURCE,

    //字节码时生效
    CLASS,

    //运行时生效。反射。
    RUNTIME

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

    //使用在类上
    TYPE,

    //使用在属性上
    FIELD,

    //使用在方法上
    METHOD,

    //使用在参数
    PARAMETER,

    //使用在构造方法上
    CONSTRUCTOR

@Documented: 在生成api文档是是否含有该注解。

在自定义的注解上使用元注解。

9.4 自定义注解--【属性】

思考: @GetMaping(value="/info") 这里的value它就是注解钟的属性。

语法:

public @interface 注解名{

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

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

}

数据类型可以用哪些类型: 基本类型[8个] 字符串类型 上面这些类型的数组

//自定义注解
@Target(value= {ElementType.TYPE,ElementType.METHOD,ElementType.FIELD,ElementType.PARAMETER}) //My注解只能使用在类和方法上.默认可以在任何位置使用
@Retention(value = RetentionPolicy.RUNTIME) //这个使用最多。运行有效  Source--->Class--->Runtime 默认在字节码生效
@interface My{
    String value() default "";
    int age() default 18;
    String[] hobby() default {};
}
//如果只为value赋值，那么可以省略value属性名
@My(value = "Hello") //给定的数组值只有一个那么可以省略{},如果数组值有多个必须给定{}.
class Hello{
    private String name;
    public void show( String n){
        System.out.println("~~~~~~~~~~~~~~~~~~~"+n);
    }
}