Java 枚举类型与泛型-第13章

已于 2023-11-02 18:13:53 修改
阅读量151 收藏
点赞数
文章标签： java 开发语言
于 2023-10-28 11:07:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sion_one/article/details/134088848
版权

Java 枚举类型与泛型-第13章

1.枚举类型

枚举类型是一种特殊的数据类型，用于表示一组有限的命名常量。枚举类型可以帮助您更清晰地定义和管理相关常量，并提供类型安全性。

1.1使用枚举类型设置常量

枚举类型是一种非常方便的方式来设置常量。我们可以创建一个枚举类型，其中包含需要的常量，然后在代码中使用这些常量。以下是如何使用枚举类型来设置常量的示例：

public class ConstantsExample {
    // 定义一个枚举类型来表示颜色常量
    enum Color {
        RED, GREEN, BLUE
    }

    public static void main(String[] args) {
        // 使用枚举常量
        Color myColor = Color.BLUE;
        System.out.println("我的颜色是：" + myColor);

        // 使用switch语句根据不同的颜色执行不同的操作
        switch (myColor) {
            case RED:
                System.out.println("我喜欢红色！");
                break;
            case GREEN:
                System.out.println("绿色也不错！");
                break;
            case BLUE:
                System.out.println("蓝色是我的最爱！");
                break;
            default:
                System.out.println("我不确定我的颜色是什么。");
        }
    }
}

在上述示例中，我们首先定义了一个名为Color的枚举类型，其中包含了三个颜色常量：RED、GREEN和BLUE。然后，我们在main方法中使用枚举常量Color.BLUE来表示颜色，以及使用switch语句根据不同的颜色执行不同的操作。

枚举类型使得代码更具可读性和可维护性，因为它将相关的常量组织在一起，并提供了一种类型安全的方式来处理它们。这在需要使用常量的情况下非常有用，因为它可以减少错误和提高代码的清晰度。

1.2深入了解枚举类型

1.枚举类型的常用方法

枚举类型在Java中有一些常用的方法，这些方法使得操作和管理枚举常量更加方便。以下是一些常用的枚举类型方法：

  1. values(): 这个方法返回枚举类型的常量数组，允许您遍历所有的枚举常量。例如：Season.values()将返回包含所有季节的Season[]数组。
  2. valueOf(String name): 这个方法返回与给定名称匹配的枚举常量。通常用于将字符串转换为枚举常量。例如：Season.valueOf("SUMMER")将返回Season.SUMMER。
  3. name(): 这个方法返回枚举常量的名称作为字符串。例如：Season.SUMMER.name()将返回字符串 “SUMMER”。
  4. ordinal(): 这个方法返回枚举常量在枚举类型中的位置（从0开始）。例如：Season.SUMMER.ordinal()将返回2，因为它是Season枚举中的第三个常量。

这些方法可以帮助我们在处理枚举类型时执行各种操作，如遍历常量、根据名称查找常量或获取常量的位置。以下是一个示例：

public class EnumMethodsExample {
    enum Day {
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
    }

    public static void main(String[] args) {
        // 使用values方法遍历所有常量
        Day[] days = Day.values();
        for (Day day : days) {
            System.out.println("Day: " + day.name() + ", Ordinal: " + day.ordinal());
        }

        // 使用valueOf方法根据名称查找常量
        Day tuesday = Day.valueOf("TUESDAY");
        System.out.println("Tuesday is " + tuesday);

        // 使用name方法获取常量的名称
        String fridayName = Day.FRIDAY.name();
        System.out.println("Friday's name is " + fridayName);
    }
}

上示例演示了如何使用这些常用的枚举方法来操作枚举常量。这些方法使得在处理枚举类型时更加便捷和有用。

2.枚举类型中的构造方法

枚举类型可以具有自定义构造方法，但这些构造方法在使用时有一些限制和特殊的用法。通常情况下，枚举类型的构造方法应该是私有的，以确保只有枚举常量内部可以调用它们。

以下是一个示例，演示如何在枚举类型中定义和使用构造方法：

enum Color {
    RED(255, 0, 0), // 枚举常量，每个常量都可以传入参数
    GREEN(0, 255, 0),
    BLUE(0, 0, 255);

    // 枚举类型的构造方法
    private int red;
    private int green;
    private int blue;

    private Color(int red, int green, int blue) {
        this.red = red;
        this.green = green;
        this.blue = blue;
    }

    public int getRed() {
        return red;
    }

    public int getGreen() {
        return green;
    }

    public int getBlue() {
        return blue;
    }
}

public class EnumConstructorExample {
    public static void main(String[] args) {
        Color myColor = Color.RED;
        System.out.println("My color is " + myColor);
        System.out.println("Red: " + myColor.getRed() + ", Green: " + myColor.getGreen() + ", Blue: " + myColor.getBlue());
    }
}

在上述示例中，我们定义了一个名为Color的枚举类型，其中包含了三个颜色常量：RED、GREEN和BLUE。每个常量都有一个构造方法，用于初始化red、green和blue成员变量。这些构造方法是私有的，只能在枚举内部访问。我们还定义了getter方法来获取颜色的RGB值。

当我们使用枚举常量时，可以看到它们的构造方法被调用，并且可以使用getter方法来获取颜色的RGB值。这样，枚举类型允许您将自定义数据与每个枚举常量相关联。

需要注意，枚举类型的构造方法在定义时是私有的，并且只能在枚举内部使用。这是因为枚举常量通常在定义时就被实例化，所以不允许外部代码创建新的枚举常量。

2.泛型

回顾向上转型与向下转型
在这里插入图片描述

泛型是一种Java编程语言的特性，它允许您编写通用的、类型安全的代码，以便在不同的数据类型上工作。泛型允许您在编写类、接口和方法时使用类型参数，这样您可以编写一次代码，然后在多种数据类型上重复使用，而不必为每种数据类型都编写新的代码。

2.1定义泛型类

要定义一个泛型类，我们需要在类名后面添加类型参数，并在类的内部使用这个类型参数来代表泛型类型。以下是一个简单的泛型类的示例：

public class MyGenericClass<T> {
    private T data;

    public MyGenericClass(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }
}

在上述示例中，MyGenericClass 是一个泛型类，它具有一个类型参数 <T>，该参数代表一个泛型类型。构造方法 MyGenericClass(T data) 接受一个泛型类型的参数，并将其存储在私有成员变量 data 中。getData 方法返回存储在 data 中的泛型数据。

还可以在创建泛型类的实例时指定具体的数据类型。例如：

MyGenericClass<Integer> integerGeneric = new MyGenericClass<>(42);
int intValue = integerGeneric.getData();
System.out.println("Integer Value: " + intValue);

MyGenericClass<String> stringGeneric = new MyGenericClass<>("Hello, Generics!");
String stringValue = stringGeneric.getData();
System.out.println("String Value: " + stringValue);

在上述示例中，我们创建了两个 MyGenericClass 的实例，一个使用整数类型 (Integer)，另一个使用字符串类型 (String) 作为泛型类型。这允许我们在不同的数据类型上使用相同的泛型类，提高了代码的重用性和类型安全性。

2.2泛型的常规用法

泛型在Java中有许多常规用法，它们有助于提高代码的可读性、类型安全性和重用性。以下是一些常见的泛型用法：

  1. 集合类使用泛型：Java标准库中的集合类如ArrayList、HashMap等都使用泛型来存储元素，以确保集合中的元素是一种特定类型。这提供了类型安全性，避免了在编译时和运行时出现不合适的数据类型。

    List<String> stringList = new ArrayList<>();
Map<Integer, String> intToStringMap = new HashMap<>();

  2. 自定义数据结构：您可以创建自定义的泛型数据结构，以便处理不同类型的数据。

    public class Pair<T, U> {
    private T first;
    private U second;
    
    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }
    
    public T getFirst() {
        return first;
    }
    
    public U getSecond() {
        return second;
    }
}

  3. 泛型方法：您可以创建泛型方法，以便在方法内部使用类型参数。

    public <T> T findMax(T[] array) {
    T max = array[0];
    for (T element : array) {
        if (element.compareTo(max) > 0) {
            max = element;
        }
    }
    return max;
}

  4. 通配符和限定通配符：通配符允许您编写灵活的代码，接受不确定的泛型类型，而限定通配符允许您指定通配符类型的范围。

    public void printList(List<?> list) {
    for (Object element : list) {
        System.out.print(element + " ");
    }
}

public double sumOfNumbers(List<? extends Number> numbers) {
    double sum = 0;
    for (Number number : numbers) {
        sum += number.doubleValue();
    }
    return sum;
}

  5. 泛型接口：您可以创建泛型接口，定义接口中的方法，这些方法可以在不同的实现中使用不同的泛型类型。

    interface ListConverter<T> {
    List<T> convertToList(T[] array);
}

2.3泛型的高级用法

泛型在Java中有许多高级用法，允许更高度的抽象和灵活性。以下是一些常见的高级泛型用法：

  1. 泛型通配符的上下界：通过使用通配符 ? 可以创建更灵活的泛型方法和类。通配符可以指定上限和下限，以便更精确地控制参数的类型。

    • 上限通配符 <? extends T>：表示通配符的类型必须是 T 类型或其子类型。
    • 下限通配符 <? super T>：表示通配符的类型必须是 T 类型或其父类型。
    public double sumOfNumbers(List<? extends Number> numbers) {
    double sum = 0;
    for (Number number : numbers) {
        sum += number.doubleValue();
    }
    return sum;
}

public void addIntegers(List<? super Integer> list, int[] integers) {
    for (int num : integers) {
        list.add(num);
    }
}

  2. 泛型通配符捕获：有时需要捕获通配符的类型以在方法内部使用。这可以通过将通配符类型存储在一个变量中来实现。

    public static <T> void copy(List<? extends T> source, List<T> destination) {
    for (T item : source) {
        destination.add(item);
    }
}

  3. 泛型擦除和反射：在Java中，泛型信息在运行时被擦除，这会导致一些限制。但是，您可以使用反射来获取泛型类型信息。

    Class<?> clazz = myGenericInstance.getClass();
Type type = clazz.getGenericSuperclass();
if (type instanceof ParameterizedType) {
    ParameterizedType paramType = (ParameterizedType) type;
    Type[] typeArgs = paramType.getActualTypeArguments();
    Class<?> genericType = (Class<?>) typeArgs[0];
    System.out.println("Generic type: " + genericType.getName());
}

  4. 泛型方法的类型推断：从Java 7开始，编译器可以推断泛型方法的类型参数，无需显式指定。

    public static <T> T getFirst(List<T> list) {
    return list.get(0);
}

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
Integer first = getFirst(integers); // 编译器可以推断类型参数

  5. 泛型枚举：从Java 5开始，可以将泛型用于枚举，使得每个枚举常量可以有不同的类型参数。

    enum Result<T> {
    SUCCESS, FAILURE;
    
    private T value;
    
    public T getValue() {
        return value;
    }
    
    public void setValue(T value) {
        this.value = value;
    }
}
Shion_online
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java第十一章 枚举与泛型
m0_61790579的博客
05-26 1630
11.1 枚举 枚举是一种数据类型，它是一系列具有名称的常量的集合。 11.1.1 使用枚举类型设置常量 定义常量的常用形式： public interface Contants { public static final int Constants_A=1; public static final int Constants_B=12; } ...
java-the-complete-reference:“ Java的源代码-java source code
03-25
Java：完整参考，第十一版 此仓库包含本书的代码示例。 章节 章节 标题 完全的 01 Java的历史与演进 02 Java概述 :check_mark_button: 03 数据类型，变量和数组 :check_mark_button: 04 运营商 :check_mark...
Java第十三章枚举类型与泛型
好好活就是做有意义的事，做有意义的事就是好好活
10-15 183
本篇文章，主要讲述了枚举类型、泛型
第十三章总结：枚举类型与泛型
m0_73576495的博客
09-04 238
13.1.1：使用枚举类型设置常量1:使用枚举类型设置常量设置常量时，我们通常将常量放置在接口中，这样在程序中就可以直接使用该常量不能被修改因为在接口中定义常量时，该常量的修饰符为final与static常规定义常量的代码如下。//常规定义变量代码变量代码，public static final int constants_B=2;}枚举类型出现后逐渐取代了。其中， enum 是定义枚举类型的关键字，当需要程序中使用该常量时，可以使用Constants和Constants_A来表示。
第十三章总结——枚举类型与泛型
m0_74981829的博客
09-28 154
1.object类为最上层的父类，很多程序员为了使程序更为通用，设计程序时通常使传入的值与返回objct类型为主。当需要使用这些实例时，必须正确地将该实例转换为原来的类型，否则在时将会发生 ClassCastException 异常。2.Java提供了泛型机制。其语法如下类名[例13.6]创建带泛型的图书类public class Book {//定义带泛型的book类//参考类型：书籍信息public Book(T bookInfo) {//参数为类型形参的构造方法。
Java的第十三章：枚举类型与泛型
nmy15570188135的博客
10-24 93
Object类最上层的父类，很多程序员为了使用更为通用，设计程序时通常使传入的值与返回的值都以Object类型为主。当需要使用这些实例时，必须正确地将该实例转换为原来的类型，否则在运行时将会发生ClassCastException异常。为了提前预防这种问题，Java提供了泛型机制。语法如下：类名.public class Book {//定义带泛型的Book类//类型形参：书籍信息public Book(T bookInfo) {//参数为类型形参的构造方法//为书籍信息赋值。
Java第十六章-枚举类型与泛型一
wangzilong_2019的博客
02-01 214
绪论 枚举类型可以取代以往的常量定义方式，即将常量封装在类或接口中。 枚举类型实质上还是以类的形式出现，泛型的出现可以让程序员少写代码，主要作用时解决类型安全问题。 枚举类型 枚举类型取代长量的定义方法，同时还赋予程序在编译时进行检查的功能 案例：使用枚举体定义常量 package 枚举类型与泛型; interface Constants { //将常量放在接口中 public static ...
Java十三章：枚举类型与泛型
2301_76549115的博客
10-27 51
Object类最上层的父类，很多程序员为了使用更为通用，设计程序时通常使传入的值与返回的值都以Object类型为主。当需要使用这些实例时，必须正确地将该实例转换为原来的类型，否则在运行时将会发生ClassCastException异常。为了提前预防这种问题，Java提供了泛型机制。语法如下：类名.<T>public class Book<T> { //定义带泛型的Book<T>类//类型形参：书籍信息public Book(T booklnfo) { //参数为类型形参的构造方法。
第十三章枚举类型与泛型
weixin_74215259的博客
10-02 58
语法：类名例子：在定义泛型类时，可以声明多个类型。语法如下:其中，T1和T2为可能被定义的类型。这样，在实例化指定类型的对象时就可以指定多个类型。例如:定义泛型类时也可以声明数组类型，下面的实例中定义泛型时便声明了数维类型例子:1.泛型的类型参数只能是类类型，不可以是简单类型，如 A这种泛型定义就是错误的2.泛型的类型个数可以是多个。3.可以使用 extends 关键字限制泛型的类型4.可以使用通配符限制泛型的类型。
第十三章---枚举类型与泛型
2302_76551984的博客
12-26 15
1
Thinking in java4（中文高清版）-java的'圣经'
11-20
非静态实例初始化 5.8 数组初始化 5.8.1 可变参数列表 5.9 枚举类型 5.10 总结 第6章 访问权限控制 第7章 复用类 第8章 多态 第9章 接口 第10章 内部类 第11章 持有对象 第12章 通过异常处理错误 第13章 字符串 第...
thinkinjava源码-Thinking-in-Java:ThinkingInJava源代码和练习题
05-20
第13章 字符串 第14章 类型信息 第15章 泛型 第16章 数组 第17章 容器深入研究 第18章 Java I/O系统 第19章 枚举类型 第20章 注解 第21章 并发 第22章 图形化用户界面 水平有限，发现错误不适者，出门左拐找童主任。
Java编程思想笔记(全)
最新发布
06-14
第 1 章 对象导论 第 2 章 一切都是对象 第 3 章 操作符 第 4 章 控制执行流程 第 5 章 初始化和清理 第 6 章 访问权限控制 ...第 19 章 枚举类型 第 20 章 注解 第 21 章 并发 第 22 章 图形化用户界面
简单的项目部署脚本（转载）
u010230019的博客
06-09 630
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1319
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 433
修改菜品——后端Java
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 424
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
java 泛型 父类_java泛型基础、子类泛型不能转换成父类泛型--未完待续
05-12
在Java中，泛型是一种强类型机制，它可以让你在编译时检查类型错误，从而提高代码的安全性和可读性。在使用泛型时，我们经常会遇到父类和子类的泛型转换问题。 首先，我们需要明确一点：子类泛型不能转换成父类泛型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值