Java基础-----泛型与注解的总结

目录

1、泛型

1.1 什么是泛型

1.2 为什么使用泛型

1.3 如何使用泛型

1.4 泛型通配符在

2、泛型的限制

3、泛型接口

 4、泛型方法

 5、注解

5.1 什么是注解

5.2 注解的分类

 5.3  预定义注解

5.4  自定义注解

---

1、泛型

1.1 什么是泛型

• List<E>：这里的<E>就是泛型标志，Map<K,V>这里的<K,V>也是泛型标记。
• 泛型：就是类在定义时无法确认类中成员的类型（属性，方法），而是类在创建时指定具体的数据类型。

1.2 为什么使用泛型

例子：定义一个Point 点类，要求如下

1. 它的坐标值可以是整数。x=15,y=25

2. 它的坐标值也可以都是小数: x=15.5 y=25.5

3. 它的坐标值也可以都是字符串类型: x="北纬15度" y="东经258度"

public class Point {
    private Object x;
    private Object 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(25,36);
        //小数类型
        Point p2=new Point(25.5,36.6);
        //字符串类型
        Point p3=new Point("北纬25度","东经36度");
        //字符串和整型
        Point p4=new Point("北纬36度",15);
        String x = (String) p4.getX();
        //java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
        //如果使用Object定义类中属性类型，那么可能在后期会出现数据类型安全问题。
        String y = (String) p4.getY();
    }
}

上面使用Object接受任意参数，可能会出现数据类型安全问题。如何解决上述问题，由于我们无法再类定义时确定成员的数据类型，所以我们可以使用泛型来解决数据类型安全问题。

1.3 如何使用泛型

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

public class 类名<T,E,B>{
 private T a;
 public T getA(){}
 public void setA(T t){}
}

----- 注意: 泛型的类型必须指定为引用类型，不能使用基本类型【byte short int long float double boolean char】。--->包装类：Byte Short ...Integer .......Character
------我们我们在创建泛型类对象时没有指定泛型：--它就是Object类型

public class Point<T> {
    private T x;
    private T y;//因为Object是所有类的父类，而且多态，子类类型可以自动向父类类型转化。

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

import java.util.ArrayList;
import java.util.List;

/**
 * @program: qy165-Fanxing-Annotation
 * @description:
 * @author: 闫克起2
 * @create: 2023-06-06 08:58
 **/
public class Test {
    public static void main(String[] args) {
       Point<Integer> p1=new Point<>(15,25);

       Point<Double> p2=new Point<>(25.5,36.6);

       Point<String> p3=new Point<>("东经150度","北纬36度");

        String x = p3.getX();
        Integer x1 = p1.getX();//不会出现数据类型安全问题。
        // 注意: 泛型的类型必须指定为引用类型，不能使用基本类型【byte short int long float double boolean char】。--->包装类：Byte Short ...Integer .......Character
        //我们我们在创建泛型类对象时没有指定泛型：--它就是Object类型

    }
}

1.4 泛型通配符在

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

对象的引用传递和值传递。

public class Test04 {
    public static void main(String[] args) {
        Info<Integer> a=new Info<>(15);
        Info<String>  b=new Info<>("Hello");
        fun(a);
        fun(b);//泛型的引用传递，要求数据类型匹配而且泛型也要匹配。
    }
    //任意的泛型都可以传递过来。 使用泛型通配符。?
    public static void fun(Info<?> info){
         info.show();
    }
}

class Info<T>{
     private T var;

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

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

    public T getVar() {
        return var;
    }

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

2、泛型的限制

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

语法:
public  void 方法名(Info<? extends Number> info){
    //传递参数的泛型必须是Number或者Number的子类
}

public  void 方法名(Info<? super Number> info){
    //传递参数的泛型必须是Number或者Number的父类
}

限定泛型的上线:泛型的限制使用在方法的引用传递中。

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

    }

    //限定泛型的上线:泛型的限制使用在方法的引用传递中。
    public static void fun2(Info<? extends Number> info){
        info.show();
    }
    //限定泛型的下限
    public static void fun3(Info<? super Number> info){
        info.show();
    }


    //任意的泛型都可以传递过来。 使用泛型通配符。?
    public static void fun(Info<?> info){
         info.show();
    }

}

class Info<T>{
     private T var;

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

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

    public T getVar() {
        return var;
    }

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

3、泛型接口

在JDK1.5之后，不仅可以声明泛型类，也可以声明泛型接口，声明泛型接口和声明泛型类的语法类似，也是在接口名称后面加上<T>, 格式如下:

[访问权限] interface 接口名称<泛型标识>{

}

泛型接口的实现类的方式有两种:

(1)在创建类时也声明泛型而且该泛型的标识必须和接口的标识一致。

(2)在类实现泛型接口时，指明该泛型的数据类型。

 

public class Test {

}
interface USB<T>{
    public void show(T t);
}

//在创建类是，也要指定泛型，要求泛型必须和接口泛型标志一致
class Upan<T> implements USB<T>{
    @Override
    public void show(T t) {
    }
}
class Shu implements USB<String>{

    @Override
    public void show(String s) {

    }
}

 4、泛型方法

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

public class Test {

    public static void main(String[] args) {
        Test test = new Test();
        test.fun(20);
        test.fun("world");
    }
    //泛型方法：<T>在方法的返回值前面多加了个泛型标志
    public <T> T fun(T t){
        System.out.println("结果为"+ t);
        return t;
    }
}

 5、注解

5.1 什么是注解

注释：注释给开发人员看的。对你的代码加以解释，程序编译后该注解不可见。

注解：注解给程序看的，该注解在编译后仍然存在。

@Controller @RequestMapping() ---Spring程序看的。

@Override JVM虚拟机看。重写特点：方法名要和父类被重写的方法一致，参数列表要一
致，返回值要一致。访问修饰符不能小于父类访问修饰符。抛出的异常不能大于父类异常。

如果注解不被解析，那么注解就没有任何意义。

5.2 注解的分类

1.预定义注解:----JDK自带的一些常用注解。
2.自定义注解-----我们自己定义的注解
3.元注解:------注解上使用的注解。

 5.3  预定义注解

1. @Override: 表示方法重写，只要使用了该注解必须符合重写的规则
2. @Deprecated: 表示已过时。告诉调用者该方法已过时
2. @SuppressWarnings: 表示压制警告。
3. @FunctionInterface: 函数式接口注解。使用该注解表明接口中只能有一个抽象方法。

 

public class Test06 {

    public static void main(String[] args) {
        Son s=new Son();
        s.show();
    }
}
class Father{
    public void print(){
        System.out.println("这是father中的方法");
    }
}

class Son extends Father{

    @Override//检查该方法重写时是否符合重写规则
    public void print() {
        System.out.println("这是子类的方法");
    }

    @Deprecated //标记该方法过时，在调用该方法有个删除线
    public void show(){

    }
    public void showPrefect(){

    }
}


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

    }
}
@FunctionalInterface //该接口中有且仅有一个抽象方法 1.8以后
interface Usb{
    public void show();
}

5.4  自定义注解

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

public @interface My {
}

@My
class Hello{
    @My
    public void show(@My int a){
        
    }

    @My
    public String name;
}

自定义的注解默认对代码没有任务影响，如果想让注解有意义，必须解析该注解。后面可以通过反射，来解析这些注解。

 如有不足之处请指出, 转载请注明出处, 谢谢~!