Java的高级篇--泛型和注解

目录

1.java的高级--泛型

1.2.什么是泛型?

1.3. 为什么使用泛型?

1.4.如何定义泛型

 1.5.通配符

1.6.受限类型

1.7.泛型接口

1.8.泛型方法

1.9.案例

2. java高级--注解

2.1 预定义注解---了解

2.2 自定义注解。---初级

2.3 元注解

2.4 自定义注解---高级

---

1.java的高级--泛型

1. 什么是泛型?
2. 为什么使用泛型?
3. 如何使用泛型?
4. 泛型类
5. 泛型的通配符
6. 泛型的上限和下限
7. 泛型接口
8. 泛型方法

1.2.什么是泛型?

其实我们再使用集合时就用过泛型List<T> 创建一个List对象List<Student> list=new ArrayList();

<T>它就是泛型。

所谓的泛型就是在类定义时,不为类中属性和方法指定数据类型，而是在类对象创建时为其指定相应的数据类型。 

1.3. 为什么使用泛型?

例子: 要求定义一个Point点类，该类中属性有x坐标和y坐标。

要求: x和y的值可以都是整数类型。

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

​ x和y的值可以都是字符串类型。

如何定义该类呢? 如何确定属性的类型。----Object类型

package demo01;

/**
 * @program: java高级-泛型-qy151
 * @description:
 * @author: YSH
 * @create: 2022-07-13 14:16
 **/
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;
    }
}

package demo01;

/**
 * @program: java高级-泛型-qy151
 * @description:
 * @author: YSH
 * @create: 2022-07-13 14:18
 **/
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;
    }
}

 Point<Integer> p1=new Point<Integer>(10,20);//坐标为整数int--自动装箱->Integer--->Object(向上转型)
        p1.show();

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

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

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

使用泛型就保证了数据类型安全问题。

1.4.如何定义泛型

泛型可以定义在类上，接口上，方法上。 泛型类，泛型接口以及泛型方法。

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

格式:

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

     //类成员
}

package demo03;

/**
 * @program: java高级-泛型-qy151
 * @description:
 * @author: YSH
 * @create: 2022-07-13 14:34
 **/
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);

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

 1.5.通配符

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

package demo04;

/**
 * @program: java高级-泛型-qy151
 * @description:
 * @author: YSH
 * @create: 2022-07-13 14:34
 **/
public class Test04 {
    public static void main(String[] args) {
            Info<Integer> i=new Info<>();
            i.setVar(250);
            fun(i);

            Info<String> i2=new Info<>();
            i2.setVar("小李");
            fun(i2); //如果为泛型类型:不但要求数据类型相同之外还要求泛型类型也匹配。

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

            //能不能设置泛型类型可以接受任意的类型呢? 我们可以使用同配置?
    }

    //该方法的参数为Info而且它的泛型为Integer类型
    public static void fun(Info<?> info){
         info.show();
    }
}

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

1.6.受限类型

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

语法:

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

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

package demo5;

/**
 * @program: java高级-泛型-qy151
 * @description:
 * @author: YSH
 * @create: 2022-07-13 14:34
 **/
public class Test04 {
    public static void main(String[] args) {
         Info<Number> i=new Info<>();
         fun2(i);

         Info<Object> i3=new Info<>();
         fun2(i3);

         Info<Integer> i4=new Info<>();
         fun2(i4);
    }


    //传递的参数泛型类型必须为Number的父类或者Number类型
    public static void fun2(Info<? super Number> info){
        info.show();
    }
    //传递的参数泛型类型必须为Number的子类或者Number类型
    public static void fun(Info<? extends Number> info){
         info.show();
    }
}
//当创建该类对象时，泛型必须为Number的子类以及Number类型
class People<T extends  Number> {

}

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

1.7.泛型接口

上面那些例子都是使用泛型类。而在jdk1.5以后，泛型也可以定义在接口上了，定义接口的泛型和定义泛型类语法相似。

语法:

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

类如何实现泛型接口:

package demo06;

import java.util.List;

/**
 * @program: java高级-泛型-qy151
 * @description:
 * @author: YSH
 * @create: 2022-07-13 15:21
 **/
public class Test {
    public static void main(String[] args) {
        Upan u=new Upan();

        Mouse<Integer> mouse=new Mouse<>();

    }
}
//泛型接口
interface USB<T>{
     public static final String NAME=""; //常量的命名必须全部大写。
     T fun(); //抽象方法
}
//子类在实现接口时，确定泛型类型
class Upan implements USB<String>{

    @Override
    public String fun() {
        return "hello world";
    }
}

//子类也实现泛型和父类名相同的泛型
class Mouse<T> implements USB<T>{

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

1.8.泛型方法

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

【泛型方法的简单定义】

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

public class Test {
    public static void main(String[] args) {
        String hello = Student.fun("hello");
        Integer fun = Student.fun(250);
        Double fun1 = Student.fun(250.0);
    }
}

class Student{

    //泛型方法: static静态成员，随着类的加载而被加载到JVM内存中。常量池
    public static <T> T fun(T t){

        return t;
    }
}

1.9.案例

第一题：开发一个泛型Apple类，要求有一个重量属性weight在测试类中实例化不同的泛型对象，要求对象a1的这一属性是String类型，对象a2的这一属性是Integer型，a3的这一属性是Double型。分别为a1，a2，a3的重量属性赋值为：”500克”，500,500.0，在测试类中通过对象调用访问器得到属性值并输出。

package zy;

/**
 * @unthor : YSH
 * @date : 20:35 2022/7/13
 */
public class Zy01 {
    public static void main(String[] args) {
        Apple<String> a1 = new Apple<>();
        a1.setWeight("500克");
        fun(a1);

        Apple<Integer> a2 = new Apple<>();
        a2.setWeight(500);
        fun(a2);


        Apple<Double> a3 = new Apple<>();
        a3.setWeight(500.0);
        fun(a3);
    }


    public static void fun(Apple<?>Apple){
        Apple.show();
    }
}

class Apple<Apple>{
    private Apple weight;

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


    public Apple() {
    }

    public Apple(Apple weight) {
        this.weight = weight;
    }

    public Apple getWeight() {
        return weight;
    }

    public void setWeight(Apple weight) {
        this.weight = weight;
    }
}

第二题：自己定义一个泛型接口，其中有一个eat方法。用一个Person类实现这个接口，传入的泛型实参是String类型，实现的方法内容自己定义，最后在main中调用eat方法。  

package zy;

/**
 * @unthor : YSH
 * @date : 20:45 2022/7/13
 */
public class Zy02 {
    public static void main(String[] args) {
        Person person = new Person();
        String eat = person.eat();
        System.out.println(eat);
    }
}


interface Eat<T>{
    T eat();
}

class Person implements Eat<String>{


    @Override
    public String eat() {
       return "我们每天都需要吃饭";
    }
}

 练习三：定义个泛型类 DAO，在其中定义一个 Map 成员变量，Map 的键为 String 类型，值为 T 类型。分别创建以下方法：public void save(String id,T entity)： 保存 T 类型的对象到 Map 成员变量中public T get(String id)：从 map 中获取 id 对应的对象public void update(String id,T entity)：替换 map 中 key 为 id 的内容,改为 entity 对象public List list()：返回 map 中存放的所有 T 对象public void delete(String id)：删除指定 id 对象定义一个 User 类：该类包含：private 成员变量（int 类型） id，age；（String 类型）name。定义一个测试类：创建 DAO 类的对象， 分别调用其 save、get、update、list、delete 方法来操作 User 对象，使用 Junit 单元测试类进行测试。

package zy;

import java.util.*;

/**
 * @unthor : YSH
 * @date : 20:56 2022/7/13
 */
public class Zy03 {
    public static void main(String[] args) {
        Dao<User> userDao = new Dao<>();


        userDao.save("1001",new User(1001,18,"张三"));
        userDao.save("1002",new User(1002,20,"李四"));
        userDao.save("1003",new User(1003,22,"王五"));
        userDao.save("1004",new User(1004,24,"赵六"));
        System.out.println("最初:"+userDao);


        //get()方法测试
        User u = userDao.get("1002");
        System.out.println("id=1002的值为：" + u);


        //update()方法测试
        userDao.update("1003", new User(1003, 51, "李一"));
        System.out.println("修改后：" +  userDao);

        //list()方法测试
        List<User> list =  userDao.list();
        System.out.println("返回 map 中存放的所有 T 对象：" + list);

        //delete()方法测试
        userDao.delete("1004");
        System.out.println("删除后：" +  userDao);

    }
}


class Dao<T>{
    private Map<String, T> map;

    //构造器
    public void DAO() {
    }

    //保存 T 类型的对象到 Map 成员变量中
    public void save(String id, T entity) {
        //判断Map是否为空，为空创建Map
        if (map == null) {
            map = new HashMap<String, T>();
        }
        //保存操作
        map.put(id, entity);
    }


    //从 map 中获取 id 对应的对象
    public T get(String id){
        return map.get(id);
    }

    //替换 map 中 key 为 id 的内容,改为 entity 对象
    public void update(String id,T entity){
        map.replace(id, entity);
    }

    //返回map中 存放的所有T对象
    public List<T> list(){
        ArrayList<T> list = new ArrayList<>();
        Collection<T> values = map.values();
        for (T t : values){
            list.add(t);
        }
        return list;
    }


    //删除指定id对象
    public void delete(String id){
        map.remove(id);
    }

    @Override
    public String toString() {
        return "Dao{" +
                "map=" + map +
                '}';
    }
}



 class User {
    private int id;
    private int age;
    private String name;

    public User() {
    }

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

}

2. java高级--注解

注释: java不会编译注释的内容，注释给程序员看的。

注解: 它是程序看，当程序看到这个注解时，就应该解析它。

譬如: @Controller @Override

注解的分类:

1. 预定义注解
2. 自定义注解
3. 元注解

2.1 预定义注解---了解

预定义注解就是JDK自带的一些注解，该注解被JVM而解析。

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

2.2 自定义注解。---初级

语法:

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

使用自定义注解:

类 方法  属性 加@注解名         

package demo09;

/**
 * @program: java高级-泛型-qy151
 * @description:
 * @author: YSH
 * @create: 2022-07-13 16:24
 **/
public class Test {
    public static void main(String[] args) {
        Info i=new Info();
        i.name="小周";
        i.show();
    }
}
//定义好注解了
@interface My{
   //注解属性
}

//使用注解
@My
class Info{
    @My
    public String name;

    @My
    public void show(){
        System.out.println("show================="+name);
    }
}

注意: 使用注解和不使用注解没有区别？

注解本身没有任何意义，它只有被解析了，才会赋予真正的意义。

我们后会使用反射来对象注解进行解析。

像:@Override 它被JVM解析，从而使其具有相应的意义。

​ @Controller @RequestMapping 它被Spring框架解析，所以具有相应的意义

2.3 元注解

1. 定义在注解上的注解称为元注解。

@Controller它只能加在类上 @Override它只能加在方法上。

原因它使用了元注解可以设置注解使用的位置

1. @Target(value=可以取下面这些内容): 作用限制注解使用得位置。
    /** 表示可以作用在类,接口,枚举 */
    TYPE,

    /** 属性 */
    FIELD,

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

    /** 方法参数 */
    PARAMETER,

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

    /** 局部变量 */
    LOCAL_VARIABLE

2. @Retention:  注解什么时候生效。默认时源码 java经历了那些阶段。
      源码阶段-->字节码阶段--->运行阶段
      /**
     * 源码时生效
     */
    SOURCE,

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

    /**
     * 运行时生效。
     * 在JVM内存中还有该注解。
     都会被设置为运行时有效
     */
    RUNTIME
    
3. @Documented 当生产API文档时该注解还存在。

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

package demo09;

import java.lang.annotation.*;

/**
 * @unthor : YSH
 * @date : 9:37 2022/7/14
 */
public class Test09 {
    public static void main(String[] args) {
        Info i = new Info();
        i.name="小周";
        i.show();
    }
}
//@Target(value=可以取下面这些内容): 作用限制注解使用得位置。
//    /** 表示可以作用在类,接口,枚举 */
//    TYPE,
//
//    /** 属性 */
//    FIELD,
//
//    /** 普通方法上 */
//    METHOD,
//
//    /** 方法参数 */
//    PARAMETER,
//
//    /** 构造方法上 */
//    CONSTRUCTOR,
//
//    /** 局部变量 */
//    LOCAL_VARIABLE
表示该注解可以使用的位置
@Target(value = {ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})

/* @Retention:  注解什么时候生效。默认时源码 java经历了那些阶段。
      源码阶段-->字节码阶段--->运行阶段
      /**
     * 源码时生效
     */
    //SOURCE,

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

            /**
             * 运行时生效。
             * 在JVM内存中还有该注解。
             都会被设置为运行时有效
             */
           //RUNTIME*/
//表示注解什么时候生效--source--class[默认字节码有效]---runtime[反射时验证]
@Retention(value = RetentionPolicy.RUNTIME)

//是否在生成api文档时存在该注解
@Documented

//子类是否能继承该注解，如果注解在定义时使用了下面这个元注解则能被子类继承。
@Inherited

/*定义好注解*/
@interface My{
    //注解属性
    String value() ;//如果设置default默认值，那么在使用该注解时可以不为该属性赋值。
    int age() default 15;

    String[] hobby() default {};//
}


/*使用自定义注解  如果使用注解时有且仅有一个属性没有赋值，而且该属性的名字value那么在给该属性赋值值，可以省略value*/
@My(value = "张三",hobby = {"看书","游泳"})
class Info{


    public String name;

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

class Student extends Info{

}

2.4 自定义注解---高级

思考: @RequestMapping("/hello") 因为它定义@RequestMaping注解中有属性。

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

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