Java学习笔记（10）——枚举和注解和泛型

最新推荐文章于 2023-03-14 21:04:29 发布
最新推荐文章于 2023-03-14 21:04:29 发布
阅读量410 收藏 1
点赞数
分类专栏： Java基础知识 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_42506939/article/details/119927013
版权

Java学习笔记（10）——枚举和注解和泛型

1 枚举

1.1. 枚举类的说明：

  1. 枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类
  2. 当需要定义一组常量时，强烈建议使用枚举类
  3. 如果枚举类中只一个对象，则可以作为单例模式的实现方式。

1.2 如何自定义枚举类？步骤：

//自定义枚举类
class Season{
    //1.声明Season对象的属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;
    //2.私化类的构造器,并给对象属性赋值
    private Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }
    //3.提供当前枚举类的多个对象：public static final的
    public static final Season SPRING = new Season("春天","春暖花开");
    public static final Season SUMMER = new Season("夏天","夏日炎炎");
    public static final Season AUTUMN = new Season("秋天","秋高气爽");
    public static final Season WINTER = new Season("冬天","冰天雪地");
    //4.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }
    public String getSeasonDesc() {
        return seasonDesc;
    }
    //4.其他诉求1：提供toString()
    @Override
    public String toString() {
        return "Season{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}
  • jdk 5.0 新增使用enum定义枚举类。步骤：
//使用enum关键字枚举类
enum Season1 {
    //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
    SPRING("春天","春暖花开"),
    SUMMER("夏天","夏日炎炎"),
    AUTUMN("秋天","秋高气爽"),
    WINTER("冬天","冰天雪地");

    //2.声明Season对象的属性:private final修饰
    private final String seasonName;
    private final String seasonDesc;

    //2.私化类的构造器,并给对象属性赋值

    private Season1(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //4.其他诉求1：获取枚举类对象的属性
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

}

1.3. 使用enum定义枚举类之后，枚举类常用方法：（继承于java.lang.Enum类）

Season1 summer = Season1.SUMMER;
        //toString():返回枚举类对象的名称
        System.out.println(summer.toString());

//        System.out.println(Season1.class.getSuperclass());
        System.out.println("****************");
        //values():返回所的枚举类对象构成的数组
        Season1[] values = Season1.values();
        for(int i = 0;i < values.length;i++){
            System.out.println(values[i]);
        }
        System.out.println("****************");
        Thread.State[] values1 = Thread.State.values();
        for (int i = 0; i < values1.length; i++) {
            System.out.println(values1[i]);
        }

        //valueOf(String objName):返回枚举类中对象名是objName的对象。
        Season1 winter = Season1.valueOf("WINTER");
        //如果没objName的枚举类对象，则抛异常：IllegalArgumentException
//        Season1 winter = Season1.valueOf("WINTER1");
        System.out.println(winter);

1.4. 使用enum定义枚举类之后，如何让枚举类对象分别实现接口：

interface Info{
    void show();
}

//使用enum关键字枚举类
enum Season1 implements Info{
    //1.提供当前枚举类的对象，多个对象之间用","隔开，末尾对象";"结束
    SPRING("春天","春暖花开"){
        @Override
        public void show() {
            System.out.println("春天在哪里？");
        }
    },
    SUMMER("夏天","夏日炎炎"){
        @Override
        public void show() {
            System.out.println("宁夏");
        }
    },
    AUTUMN("秋天","秋高气爽"){
        @Override
        public void show() {
            System.out.println("秋天不回来");
        }
    },
    WINTER("冬天","冰天雪地"){
        @Override
        public void show() {
            System.out.println("大约在冬季");
        }
    };
}

2 注解

2.1. 注解的理解

  1. jdk 5.0 新增的功能

  2. Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。通过使用 Annotation程序员可以在不改变原逻辑的情况下, 在源文件中嵌入一些补充信息。

  3. 在JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaEE/Android中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版中所遗留的繁冗 代码和XML配置等。

框架 = 注解 + 反射机制 + 设计模式

2.2. 注解的使用示例

  • 示例一：生成文档相关的注解

  • 示例二：在编译时进行格式检查(JDK内置的个基本注解)

    • @Override: 限定重写父类方法, 该注解只能用于方法
    • @Deprecated: 用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的择
    • @SuppressWarnings: 抑制编译器警告

  • 示例三：跟踪代码依赖性，实现替代配置文件功能

2.3. 如何自定义注解：参照@SuppressWarnings定义

  • ① 注解声明为：@interface
  • ② 内部定义成员，通常使用value表示
  • ③ 可以指定成员的默认值，使用default定义
  • ④ 如果自定义注解没成员，表明是一个标识作用。

说明：
如果注解有成员，在使用注解时，需要指明成员的值。
自定义注解必须配上注解的信息处理流程(使用反射)才意义。
自定义注解通过都会指明两个元注解：Retention、Target

@Inherited
@Repeatable(MyAnnotations.class)
@Retention(RetentionPolicy.RUNTIME)
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE,TYPE_PARAMETER,TYPE_USE})
public @interface MyAnnotation {

    String value() default "hello";
}

2.4. 元注解 ：对现有的注解进行解释说明的注解。

jdk 提供的4种元注解：

  • Retention：指定所修饰的 Annotation 的生命周期：SOURCE\CLASS（默认行为\RUNTIME只声明为RUNTIME生命周期的注解，才能通过反射获取。
  • Target:用于指定被修饰的 Annotation 能用于修饰哪些程序元素
    出现的频率较低
  • Documented:表示所修饰的注解在被javadoc解析时，保留下来。
  • Inherited:被它修饰的 Annotation 将具继承性。

—>类比：元数据的概念：String name = “Tom”;

2.5. 如何获取注解信息:通过发射来进行获取、调用。

前提：要求此注解的元注解Retention中声明的生命周期状态为：RUNTIME.

2.6.JDK8中注解的新特性：可重复注解、类型注解

可重复注解：

  • ① 在MyAnnotation上声明@Repeatable，成员值为MyAnnotations.class
  • ② MyAnnotation的Target和Retention等元注解与MyAnnotations相同。

类型注解：

  • ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明。
  • ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。

3 泛型

3.1.泛型的概念

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返
回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、
创建对象时确定（即传入实际的类型参数，也称为类型实参）。

3.2.泛型的引入背景

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就是类型参数，即泛型

//在集合中使用泛型的情况：以HashMap为例
    @Test
    public void test3(){
//        Map<String,Integer> map = new HashMap<String,Integer>();
        //jdk7新特性：类型推断
        Map<String,Integer> map = new HashMap<>();

        map.put("Tom",87);
        map.put("Jerry",87);
        map.put("Jack",67);

//        map.put(123,"ABC");
        //泛型的嵌套
        Set<Map.Entry<String,Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

        while(iterator.hasNext()){
            Map.Entry<String, Integer> e = iterator.next();
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key + "----" + value);
        }

    }

3.3 集合中使用泛型总结：

  • ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
  • ② 在实例化集合类时，可以指明具体的泛型类型
  • ③ 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型。
  • 比如：add(E e) —>实例化以后：add(Integer e)
  • ④ 注意点：泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，拿包装类替换
  • ⑤ 如果实例化时，没指明泛型的类型。默认类型为java.lang.Object类型。

3.4 自定义泛型方法、泛型接口，泛型类

【Order.java】

public class Order<T> {

    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型

    T orderT;

    public Order(){
        //编译不通过
//        T[] arr = new T[10];
        //编译通过
        T[] arr = (T[]) new Object[10];
    }

    public Order(String orderName,int orderId,T orderT){
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    //如下的个方法都不是泛型方法
    public T getOrderT(){
        return orderT;
    }

    public void setOrderT(T orderT){
        this.orderT = orderT;
    }

    @Override
    public String toString() {
        return "Order{" +
                "orderName='" + orderName + '\'' +
                ", orderId=" + orderId +
                ", orderT=" + orderT +
                '}';
    }
    //静态方法中不能使用类的泛型。
//    public static void show(T orderT){
//        System.out.println(orderT);
//    }

    public void show(){
        //编译不通过
//        try{
//
//
//        }catch(T t){
//
//        }

    }

    //泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没任何关系。
    //换句话说，泛型方法所属的类是不是泛型类都没关系。
    //泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。
    public static <E>  List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;

    }
}

【SubOrder.java】

public class SubOrder extends Order<Integer> {//SubOrder:不是泛型类


    public static <E> List<E> copyFromArrayToList(E[] arr){

        ArrayList<E> list = new ArrayList<>();

        for(E e : arr){
            list.add(e);
        }
        return list;

    }


}


//实例化时，如下的代码是错误的
SubOrder<Integer> o = new SubOrder<>();

【SubOrder1.java】
public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是泛型类

}


【测试】
@Test
    public void test1(){
        //如果定义了泛型类，实例化没指明类的泛型，则认为此泛型类型为Object类型
        //要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型。
        Order order = new Order();
        order.setOrderT(123);
        order.setOrderT("ABC");

        //建议：实例化时指明类的泛型
        Order<String> order1 = new Order<String>("orderAA",1001,"order:AA");

        order1.setOrderT("AA:hello");

    }

    @Test
    public void test2(){
        SubOrder sub1 = new SubOrder();
        //由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。
        sub1.setOrderT(1122);

        SubOrder1<String> sub2 = new SubOrder1<>();
        sub2.setOrderT("order2...");
    }

    @Test
    public void test3(){

        ArrayList<String> list1 = null;
        ArrayList<Integer> list2 = new ArrayList<Integer>();
        //泛型不同的引用不能相互赋值。
//        list1 = list2;

        Person p1 = null;
        Person p2 = null;
        p1 = p2;


    }

    //测试泛型方法
    @Test
    public void test4(){
        Order<String> order = new Order<>();
        Integer[] arr = new Integer[]{1,2,3,4};
        //泛型方法在调用时，指明泛型参数的类型。
        List<Integer> list = order.copyFromArrayToList(arr);

        System.out.println(list);
    }

在这里插入图片描述
在这里插入图片描述

3.5 应用举例

【DAO.java】:定义了操作数据库中的表的通用操作。 ORM思想(数据库中的表和Java中的类对应)

public class DAO<T> {//表的共性操作的DAO

    //添加一条记录
    public void add(T t){

    }

    //删除一条记录
    public boolean remove(int index){

        return false;
    }

    //修改一条记录
    public void update(int index,T t){

    }

    //查询一条记录
    public T getIndex(int index){

        return null;
    }

    //查询多条记录
    public List<T> getForList(int index){

        return null;
    }

    //泛型方法
    //举例：获取表中一共有多少条记录？获取最大的员工入职时间？
    public <E> E getValue(){

        return null;
    }

}

【CustomerDAO.java】:

public class CustomerDAO extends DAO<Customer>{//只能操作某一个表的DAO
}

【StudentDAO.java】:
public class StudentDAO extends DAO<Student> {//只能操作某一个表的DAO
}
Java初学笔记（四）：注解和泛型
Qngcken的博客
04-13 489
文章目录注解泛型泛型技术: 擦拭法extends通配符super通配符`extends`与`super`对比:PECS原则无限定通配符泛型和反射关于使用泛型 注解 所有注解都继承自java.lang.annotation.Annotation 自定义注解 public @interface XXX { // 使用@interface声明注解，public指定作用域 int type(...
泛型、枚举、注解
yubin1285570923的博客
05-14 378
一、泛型 泛型的参数类型可以用在类，接口和方法创建中分别称为：泛型类，泛型接口和泛型方法。 ArrayList<E>:整个称为泛型类型，E表示泛型变量或泛型参数 ArralyList<Integer>：整个称为参数化类型，Integer称为类型参数的实例或者实际类型参数 1.泛型类的定义和使用 class Par<T> { private T value;...
Android之AsyncTask异步加载
木刻川川
09-06 423
今天总结的是android中的异步加载AsyncTask。android的UI线程（主线程）主要负责处理用户的按键事件、用户触屏事件及屏幕绘图事件等，因此开发者的其他操作不应该、也不能阻塞UI线程，否者UI界面将会出现停止响应的状况。 为了避免UI线程失去响应的问题，android将耗时操作放在了新线程中完成，但是新线程也可能需要动态更新UI组件：比如需要从网上获取网页，然后在TextView中将其
对java泛型、枚举、注解以及反射的基础学习
weixin_45273750的博客
11-29 213
泛型、枚举、注解和反射的初步了解 2 泛型 泛型是JDK1.5及以上才可以使用的特性/语法，它的本质是 类型参数化(Parameterized by types). 2.1 概述 在声明一个类、接口、方法的时候，需要涉及到到一个问题：要给属性确定一个类型，或者给方法的返 回值确定一个类型，或者给方法的参数确定一个类型 之前，定义类、接口、方法的时候，上面所描述的类型都是直接写死，不会变化的 public class Point{ int x; int y; } Point 类表示一个坐
深入理解Java：注解（Annotation）自定义注解入门
菠萝菠萝派的点滴积累
03-09 701
本文转自：http://www.cnblogs.com/peida/archive/2013/04/24/3036689.html要深入学习注解，我们就必须能定义自己的注解，并使用注解，在定义自己的注解之前，我们就必须要了解Java为我们提供的元注解和相关定义注解的语法。元注解元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 a
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
[Java学习笔记doc](必看经典)
最新发布
08-11
这份“Java学习笔记doc”必看经典文档，很可能是对Java编程的深入解析和实践经验的总结。通常，这样的笔记会涵盖以下关键知识点： 1. **基础语法**：包括变量、数据类型、运算符、流程控制语句（如if、for、while）...
java学习笔记(学习java的好书).rar_Java笔记_java 学习_w3school离线完全版_编程开发手册
09-24
对于Java的进阶部分，可能会讲解到反射、注解、泛型、枚举、Lambda表达式以及Java 8及更高版本引入的新特性。此外，还有Java EE（企业版）的相关知识，如Servlet、JSP、JDBC以及Spring框架等，这些都是进行服务器端...
Java基础尚硅谷宋红康学习笔记
05-29
3. **枚举**：枚举是Java中的一种特殊类，用于定义一组固定的常量，提高了代码的可读性和安全性。 4. **注解（Annotation）**：注解提供了一种元数据，用于向编译器或JVM提供关于代码的附加信息，例如用于代码生成...
java学习笔记基础和框架
11-13
这份“java学习笔记基础和框架”涵盖了从Java的基础概念到高级特性的全方位学习资料，非常适合初学者以及准备面试的开发者。 一、Java基础知识 1. **Java环境搭建**：首先，了解如何安装JDK（Java Development Kit...
Java学习笔记（八）之泛型，枚举，注解
伟子时代的博客
11-18 252
泛型 Java中的泛型，只在编译阶段有效 泛型类 对象实例化时不指定泛型，默认为：Object 泛型不同的引用不能相互赋值 public class Test { public static void main(String[] args) { A<String> a = new A<>(); //在new A的对象指定泛型的类型String a.setKey("xxxx"); //对象使用setKey(T key)方法，中的k
Java注释@interface的用法
07-31 930
java用  @interface Annotation{ } 定义一个注解 @Annotation，一个注解是一个类。 @Override，@Deprecated，@SuppressWarnings为常见的3个注解。 注解相当于一种标记，在程序中加上了注解就等于为程序加上了某种标记，以后， JAVAC编译器，开发工具和其他程序可以用反射来了解你的类以及各种元素上有无任何标记，看你有什么标记
java 自定义注解 & 泛型
limonero
11-19 1872
一、自定义注解 1、定义注解使用@inteface,基本注解的定义 package com.lemon.self.annotation.zhujie; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * 自定义注解
JavaEnhance——枚举、注解及泛型
0pr
05-16 800
枚举一、概述如果一个变量的取值要被限定在一定的范围内，例如星期的取值，限定在1~7的范围内，并且想要在编译期就能指出变量取值超出范围的错误，就可以使用枚举。枚举相当于一个类，其中也可以定义构造方法，成员变量，普通方法和抽象方法。二、枚举的应用1.使用普通类模拟枚举使用普通类模拟枚举的时候，首先将构造方法私有化，然后在类的内部创建常量，那么其他类在调用这个类的时候，只能得到模拟枚举类中的常量，不能ne
TypeScript篇.02-Interface接口,Class类,Function函数,Enum枚举,泛型
qq_54379580的博客
03-14 2345
关于ts中的接口, 类, 以及函数, 枚举, 泛型的简单介绍....
枚举&注解
mamingshifan的博客
06-01 267
枚举不是一个类，但可以将枚举看作一个类使用 2.注解 注解(Annotation) 关键字：@interface 自定义注解：使用关键字 @interface，注解一般由 注解本身+处理程序组成。 当属性名字是value时，赋值时可以不写value 注解中的属性不能使用基本数据类型的包装类，只能使用基本数据类型。 注解的注解 1.@Retention:表示注解的保留策略。 2.@Target：表示注解的实用程序元素的种类。 3.@Documented：表示注解信息是否可以生成到文档中 有该注解就可以
Java基础知识学习——枚举类、注解
weixin_37719485的博客
02-05 201
知识点汇总 枚举类的使用： 类的对象只有有限个，确定的时候称为枚举类。 定义枚举类： 方式一：jdk5.0之前自定义枚举类 方式二：使用enum关键字定义枚举类 Enum中常用的方法： values()方法，valueOf()方法，toString()方法。 代码示例： public class EnumTest{ public static void main(String[] args...
Java进阶知识体系_特殊类（抽象接口内部类枚举注解）
weixin_41300542的博客
05-06 500
Java进阶知识体系 （一）、类和对象 （二）、方法和封装 （三）、static关键字和继承 （四）、多态 （五）、特殊类 （五）、特殊类 1，抽象类 抽象类的概念 抽象类主要指不能具体实例化的类并且使用abstract关键字修饰，也就是不能创建对象 抽象方法的概念 抽象方法主要指不能具体实现的方法并且使用abstract关键字修饰，也就是没有方法体。 具体格式如下： 访问权限 abstract 返回值类型 方法名(形参列表); public abstract void cry(); 抽象类和抽象方法的关系
TypeScript 学习笔记--- interface 、enum
一撇一画的博客
02-20 3081
//interface 感觉接口主要就是用来约束传参属性的，就只能传{sex：xxxxx}的形式 interface Person { sex:String } function marry (x:Person,y:Person){ if(x.sex !== y.sex) { return '可以 marry' } else { th...
Java学习笔记：实用问题解决方案总结
Java的高级特性包括泛型（Generics）、注解（Annotations）、枚举（Enums）、反射（Reflection）和Lambda表达式等。掌握这些高级特性可以使Java代码更加健壮和灵活。 7. Java设计模式与框架： 学习笔记总结可能会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值