泛型

1.什么是泛型？

List<E> :这里的<E>就是泛型标志，Map<E,V>这里<E,V>也是泛型标记.

泛型:就是类在定义时无法确认类中成员的类型（属性，方法），而是类在创建时指定具体的数据类

2.为什么使用泛型

例子:定义一个坐标类，要求如下

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

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

3.它的坐标也可能是字符串类型：x="北纬15度" y="东经263度"

package demo01;

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

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

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


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

3.如何使用泛型

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

语法:

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

使用泛型来解决Point类的安全问题：

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

    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类型

    }

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

}

5.泛型的限制

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

语法:

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

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

public static void main(String\[] args) {
//        Info<Integer> a=new Info<>(15);
//        Info<String>  b=new Info<>("Hello");
//        Info<Number>  c=new Info<>(25.5);
//        fun2(a);
//        fun2(b);//泛型的引用传递，要求数据类型匹配而且泛型也要匹配。
//
//        fun2(c);
//
//        Info<Object> d=new Info<>(258);
//        fun3(c);
//        fun3(a);
//        fun3(b);
//        fun3(d);

    }

    //限定泛型的上线:泛型的限制使用在方法的引用传递中。
    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;
    }

}

6.泛型接口

List<E> ArrayList<E>

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

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

}

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

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

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

public class Test05 {
}

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) {
        
    }

}

7.泛型方法

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

public class Test05 {

    public static void main(String[] args) {
        Test05 t=new Test05();
        String hello = t.fun("hello");
        Integer fun = t.fun(15);
    }

    //泛型方法: <T>在方法的返回值前面多了个泛型标志
    public <T> T fun(T t){
        System.out.println("结果为:"+t);
        return t;
    }

}

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

通配符: ?
限制泛型类型: ? super Number ? extends Number 引用传递
泛型接口: public interface 接口<标志,标志.....>{}
泛型方法: public <标志> 返回值方法名(参数列表){}

注解

什么是注解

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

注解: 注解给程序看，该注解编译后依然存在。

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

@Override JVM虚拟机看。重写特点。方法名要和父类被重写的方法一致，参数列表要一致，

返回值要一致。访问修饰符不能小于父类访问修饰。抛出的异常不能大于父类异常。

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

注解的分类:

1.预定义注解:----JDK自带的一些常用注解。

2.自定义注解-----我们自己定义的注解

3.元注解:------注解上使用的注解。

预定义注解:

@Override: 表示方法重写，只要使用了该注解必须符合重写的规则

@Deprecated: 表示已过时。告诉调用者该方法已过时

@SuppressWarnings: 表示压制警告。

@FunctionInterface: 函数式接口注解。使用该注解表明接口中只能有一个抽象方法。

package demo06;

import java.util.Date;

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

自定义注解：

格式:

public @Interface 注解名{//

//属性 }

public @interface My {
}

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

    }

    @My
    public String name;

}

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

@Controller注解是因为Spring框架解析了它 @Override JVM解析了它。而我们自定义的注解没有办法解析，这个时候就需要利用反射。

java的泛型--注解--反射（上）

泛型