精华内容
下载资源
问答
  • 2021-02-27 14:57:02

    内部类:

    内部类的定义 :

    在一个类的内部又定义了一个类,里面的这个类就是内部类。

    内部类可以定义在外部类的成员位置(与成员变量的位置相同)或局部位置(意思是,把类写在外部类的方法里面)。

    什么时候使用内部类 :

    一个具体的事物里面还有一个具体的事物。比如汽车中有发动机。

    1、成员内部类

    1.将内部类,定义在了外部类的成员位置。

    2.成员内部类,可以使用成员修饰符:public、static等。但是一般也不写,因为开发也不怎么用。

    3.成员内部类,毕竟是一个类,可以继承,也可以实现接口...

    4.调用规则:

    内部类可以使用外部类的成员,包括私有(因为内部类没有出去外部类的范围)。[例1]

    外部类要使用内部类的成员,必须要创建内部类的对象。

    packagecom;public classOuter {private int a = 1;class Inner{ //在外部类成员的位置定义内部类

    public voidfun(){

    System.out.println(a);//内部类可以使用外部类的成员。

    }

    }

    }classtest1{public static voidmain(String[] args) {

    Outer.Inner oi= new Outer().new Inner(); //创建内部类的对象的格式。

    oi.fun();

    }

    }

    结果:1

    内部类中同名变量的调用:

    packagecom;public cl

    更多相关内容
  • 一、枚举类的使用: 1.枚举类的理解:类的对象只有有限个,确定的。我们称此为枚举类 2.当需要定义一组常量时,强烈建议使用枚举类。 3.如果枚举类中只有一个对象,则可以作为单例模式的实现方式。 二、如何定义枚举...
  • 比如110000是北京
  • 主要介绍了Java实现接口的枚举类,结合实例形式分析了java接口的枚举类相关原理与使用技巧,需要的朋友可以参考下
  • 主要介绍了java枚举类的构造函数实例详解的相关资料,需要的朋友可以参考下
  • java 通过反射获取枚举类,及枚举类的值,枚举类枚举实例名。本项目为普通java项目
  • 主要介绍了Java枚举类使用场景及实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了Java手动方式创建枚举类,结合实例形式分析了java创建枚举类的方法及相关操作技巧,需要的朋友可以参考下
  • 主要给大家介绍了关于ASP.Net Core中使用枚举类而不是枚举的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用ASP.Net Core具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • 主要给大家介绍了关于mybatis处理枚举类的简单方法,文中通过示例代码介绍的非常详细,对大家学习或者使用mybatis具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • Genum是从YAML数组生成Java枚举类文件的代码生成器。 您可以在服务器端和客户端应用程序之间共享定义! 例如,这是一个以YAML格式编写的数组。 - Tokyo - NewYork - London - Beijing - Paris - Roma Genum将其...
  • 主要介绍了java枚举类的属性、方法和构造方法应用,结合实例形式分析了java枚举类的定义、构造及相关应用操作技巧,需要的朋友可以参考下
  • 本源码由 springboot 开发,只有2个简单的文件(1是 枚举类单例,2是 controller请求测试类)。 主要测试了枚举类的饿汉式加载机制 / 单例机制。 代码中包含枚举类的基本使用,和完整的请求示例。 主要实现了枚举类...
  • 主要介绍了Jackson优雅序列化Java枚举类过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了java 中枚举类enum的values()方法的详解的相关资料,希望通过本文大家能够掌握这部分内容,需要的朋友可以参考下
  • 56个民族枚举类

    2019-08-12 01:26:23
    NULL 博文链接:https://mvplee.iteye.com/blog/2265413
  • Java枚举类enum介绍

    2020-09-03 19:44:42
    主要介绍了Java枚举类enum介绍,和其它普通类一样,enum同样可以有成员变量、方法、构造器,也可以实现一个或多个接口,需要的朋友可以参考下
  • 主要介绍了Java包含抽象方法的枚举类,结合实例形式分析了Java包含抽象方法的枚举类实现方法与相关操作技巧,需要的朋友可以参考下
  • 解析字符串转化为对象+code转desc+通过值实例枚举类+EnumUtil+PackageUtils工具类 ZipInputStream实现压缩文件的读取与数据转化的过程,利用反射实现根据枚举值获取枚举对象。
  • 枚举类与注解.xmind

    2020-08-11 16:00:41
    自己总结的java枚举类和注解的笔记,绘制了详细的思维导图,每个思维导图中均有详细的博文解释,方便大家学习和理解,免费分享给大家。适合java的爱好者和学习者
  • JAVA枚举类

    千次阅读 2022-01-30 13:13:25
    自定义枚举类(jdk5.0之前) package com.atguigu.java; /** * 一、枚举类的使用 * 1.枚举类的理解:类的对象只有有限个,确定的。我们称此类为枚举类 * 2.当需要定义一组常量时,强烈建议使用枚举类 * 3.如果...

    自定义枚举类(jdk5.0之前)

    在这里插入图片描述

    package com.atguigu.java;
    
    /**
     * 一、枚举类的使用
     * 1.枚举类的理解:类的对象只有有限个,确定的。我们称此类为枚举类
     * 2.当需要定义一组常量时,强烈建议使用枚举类
     * 3.如果枚举类中只有一个对象,则可以作为一种单例模式的实现方式。
     *
     * 二、如何定义枚举类
     * 方式一:jdk5.0之前,自定义枚举类
     * 方式二:jdk5.0,可以使用enum关键字定义枚举类
     *
     */
    
    //自定义枚举类
    class Season{
        //1.声明Season对象的属性:private final修饰
        private final String seasonName;//final修饰的,要么直接赋值,要么构造器赋值
        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 + '\'' +
                    '}';
        }
    }
    //测试使用自定义枚举类
    public class SeasonTest {
    
        public static void main(String[] args) {
            Season spring = Season.SPRING;
            System.out.println(spring);//Season{seasonName='春天', seasonDesc='春暖花开'}
            
        }
    
    }
    

    使用enum关键字定义枚举类

    package com.atguigu.java;
    
    public class SeasonTest2 {
        public static void main(String[] args) {
            Season1 summer = Season1.SUMMER;
            //toString():返回枚举类对象的名称
            System.out.println(summer.toString());//SUMMER
    
            System.out.println(Season1.class.getSuperclass());//父类是 class java.lang.Enum
            //即定义的枚举类默认继承于java.lang.Enum类
    }
    
    //使用enum关键字枚举类(class在这改为enum)
    enum Season1 {
            //public static final Season1 SPRING = new Season1("春天","春暖花开");
           // 把自定义枚举类中的public static final Season1 ,new Season1都去掉。
         //此处要求对象SPRING,SUMMER,AUTUMN, WINTER要写着最上边 不然报错
        //1.提供当前枚举类的对象,多个对象之间用","隔开,末尾对象";"结束
        SPRING("春天","春暖花开"),//多个对象之间用逗号,
        SUMMER("夏天","夏日炎炎"),
        AUTUMN("秋天","秋高气爽"),
        WINTER("冬天","冰天雪地");
    
        //2.声明Season对象的属性:private final修饰
        private final String seasonName;
        private final String seasonDesc;
    
        //3.私有化类的构造器,并给对象属性赋值
    
        private Season1(String seasonName,String seasonDesc){
            this.seasonName = seasonName;
            this.seasonDesc = seasonDesc;
        }
    
        //4.其他诉求1:获取枚举类对象的属性
        public String getSeasonName() {
            return seasonName;
        }
    
        public String getSeasonDesc() {
            return seasonDesc;
        }
    
    }
    }
    
    
    

    Enum类中的常用方法和使用enum关键字定义的枚举类实现接口

    在这里插入图片描述

    package com.atguigu.java;
    
    /**
     * 使用enum关键字定义枚举类
     * 说明:定义的枚举类默认继承于java.lang.Enum类
     *
     * * 三、Enum类中的常用方法:
     *  *    values()方法:返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
     *  *    valueOf(String str):可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是,会有运行时异常:IllegalArgumentException。
     *  *    toString():返回当前枚举类对象常量的名称
     *  *
     *  * 四、使用enum关键字定义的枚举类实现接口的情况
     *  *   情况一:实现接口,在enum类中实现抽象方法
     *  *   情况二:让枚举类的对象分别实现接口中的抽象方法
     *  *
     */
    public class SeasonTest1 {
        public static void main(String[] args) {
            Season1 summer = Season1.SUMMER;
            //toString():返回枚举类对象的名称
            System.out.println(summer.toString());//SUMMER
    
            System.out.println(Season1.class.getSuperclass());//父类是 class java.lang.Enum
            //即定义的枚举类默认继承于java.lang.Enum类
    
            System.out.println("****************");
            //values():返回所有的枚举类对象构成的数组
            Season1[] values = Season1.values();
            for(int i = 0;i < values.length;i++){
                System.out.println(values[i]);//
                values[i].show();
            }
            //SPRING
            //春天在哪里?
            //SUMMER
            //宁夏
            //AUTUMN
            //秋天不回来
            //WINTER
            //大约在冬季
            System.out.println("****************");
    
            //valueOf(String objName):返回枚举类中对象名是objName的对象。
            Season1 winter = Season1.valueOf("WINTER");
            //如果没有objName的枚举类对象,则抛异常:IllegalArgumentException
    //        Season1 winter = Season1.valueOf("WINTER1");
            System.out.println(winter);//WINTER
            winter.show();//大约在冬季
        }
    }
    
    interface Info{//一个接口
        void show();
    }
    
    //使用enum关键字枚举类
    enum Season1 implements Info{//实现接口和class类实现接口一样
        //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.声明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;
        }
    //    //4.其他诉求1:提供toString()
    //    这里不必重写toString(),如果有诉求,可以重写。
    //    @Override
    //    public String toString() {
    //        return "Season1{" +
    //                "seasonName='" + seasonName + '\'' +
    //                ", seasonDesc='" + seasonDesc + '\'' +
    //                '}';
    //    }
    
    
        @Override
        //情况一:实现接口,在enum类中实现抽象方法
        public void show() {
            System.out.println("这是一个季节");
        }
    }
    
    展开全文
  • Java 枚举类使用实践

    千次阅读 2022-04-05 09:46:26
    枚举类使用实践

    涉及知识点

    • 前台Thymeleaf下拉列表使用枚举类
    • 后台实体类使用枚举类接收前台传值
    • 自定义Mybatis枚举类转换器,插入枚举类数据和查询数据封装为枚举类
    • EnumMap,使用枚举类作为Key的Map

    前台

    <!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    <div>
        <select id="test">
            <!-- 前台将后台枚举类中的数据遍历显示 -->
            <option th:each="enmu:${enums}" th:value="${enmu.code}" th:text="${enmu.name}"></option>
        </select>
        <button onclick="submitData()">提交请求</button>
    </div>
    </body>
    <script th:src="@{/js/jquery.min.js}"></script>
    <script th:inline="javascript" type="text/javascript">
    	// 获取项目根路径
        const ctxPath = [[${#httpServletRequest.getContextPath()}]];
    
        async function submitData() {
    		
    		// 属性名需要和后台用来接收的实体类的属性名保持一致
            const data = {
                name: '贾飞天',
                sexTypes: $("#test").val()
            };
    		
    		// 使用fetch发送请求,提交前台json数据
            const result = await fetch(ctxPath + '/enum/getValue', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json;charset=utf-8'
                },
                body: JSON.stringify(data)
            })
            
            // 获取后台返回的json数据
            const json = await result.json();
            console.log(json);
        }
    </script>
    </html>
    

    枚举类

    import com.fasterxml.jackson.annotation.JsonCreator;
    import com.fasterxml.jackson.annotation.JsonFormat;
    
    import java.util.Arrays;
    
    /*
    	SexTypes被组合到Teacher实体类中,当SpingBoot接收到前台的数据进行封装的时候
    	需要使用jackson中的注解指定封装到枚举类中
    */ 
    @JsonFormat(shape = JsonFormat.Shape.OBJECT)
    public enum SexTypes {
    
        男性("1"),
        女性("2"),
        保密("3");
        
        private String code;
    
        SexTypes(String code) {
            this.code = code;
        }
    
        public String getCode() {
            return code;
        }
    
        /*
        	根据code获取枚举类对象
        	SpringBoot在将前台数据封装的时候,通过@JsonCreator注解对应的方法
        	指定前台的性别code转换为对应的枚举类
    	*/ 
        @JsonCreator
        public static SexTypes fromCode(String code) {
            return Arrays.stream(SexTypes.values())
                    .filter(item -> item.code.equals(code)).findAny().orElse(null);
    
        }
    
        public static SexTypes fromName(String name) {
    
            return Arrays.stream(SexTypes.values())
                    .filter(item -> item.name().equals(name)).findAny().orElse(null);
        }
    }
    

    实体类

    public class Teacher {
    
        private String name;
        private SexTypes sexTypes;
    
        public Teacher(String name, SexTypes sexTypes) {
            this.name = name;
            this.sexTypes = sexTypes;
        }
    
        // 省略get,set,toString...
    }
    

    数据库

    在这里插入图片描述

    Mybatis自定义枚举类转换器

    import java.sql.CallableStatement;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    import org.apache.ibatis.type.BaseTypeHandler;
    import org.apache.ibatis.type.JdbcType;
    import org.apache.ibatis.type.MappedJdbcTypes;
    import org.apache.ibatis.type.MappedTypes;
    
    // 数据库字段所对应的类型
    @MappedJdbcTypes({JdbcType.VARCHAR})
    // 需要转换为JAVA侧的类型
    @MappedTypes(value = SexTypes.class)
    // 进行类型转换需要继承Mybatis的BaseTypeHandler类
    public class CustomEnumTypeHandler extends BaseTypeHandler<SexTypes> {
        
        // 重写BaseTypeHandler中的方法
        @Override
        public void setNonNullParameter(PreparedStatement preparedStatement, int i, SexTypes parameter, JdbcType jdbcType) throws SQLException {
        	/*
        		当插入数据的时候(#{参数名}),会调用此方法,将枚举类中的code当做参数插入
        		因为数据库中的sex为varchar类型,因此设置参数类型为string
    		*/ 
            preparedStatement.setString(i, parameter.getCode());
        }
    	
    	// 当进行查询的时候,会通过code获取到对应的枚举类
        @Override
        public SexTypes getNullableResult(ResultSet resultSet, String s) throws SQLException {
            String code = resultSet.getString(s);
            return SexTypes.fromCode(code);
        }
    
        @Override
        public SexTypes getNullableResult(ResultSet resultSet, int i) throws SQLException {
            String code = resultSet.getString(i);
            return SexTypes.fromCode(code);
        }
    
        @Override
        public SexTypes getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
            String code = callableStatement.getString(i);
            return SexTypes.fromCode(code);
        }
    }
    

    将自定义枚举类转换器添加到全局配置文件application.properties

    # 指定转换器包所在的路径
    mybatis.type-handlers-package=com.example.demo.EnumPack
    

    Mapper

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.example.demo.mapper.TestEnumInsert">
        <select id="insertEnumData" parameterType="com.example.demo.form.EnumTestFrom">
          INSERT
            INTO myblog.enumuser(name, sex)
            <!--
            	由于我们配置了枚举类转换器,因此直接插入枚举类属性即可
            	转换器会将枚举类中的code获取出来当做参数插入
    		-->
            VALUES (#{name}, #{sexTypes})
        </select>
    
        <select id="selectAllData" resultType="com.example.demo.mybatisTest.Teacher">
        	<!--枚举类转换器会将sex的code转换为对应的枚举类-->
            SELECT * from myblog.enumuser
        </select>
    </mapper>
    
    public interface TestEnumInsert {
    	
    	// 插入枚举类数据
        void insertEnumData(EnumTestFrom form);
    	
    	// 查询所有的数据
        List<Teacher> selectAllData();
    }
    

    插入后查询

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.*;
    import org.springframework.web.servlet.ModelAndView;
    
    import java.util.EnumMap;
    import java.util.List;
    import java.util.Set;
    import java.util.stream.Collectors;
    
    @Controller
    @RequestMapping("/enum")
    public class EnumTestController {
    
        @Autowired
        private TestEnumInsert mapper;
    
        @GetMapping("/init")
        public ModelAndView init() {
        
            ModelAndView modelAndView = new ModelAndView();
            modelAndView.setViewName("enum");
            // 将枚举类数组传给前台下拉列表使用
            modelAndView.addObject("enums", SexTypes.values());
            return modelAndView;
        }
    
        @PostMapping("/getValue")
        @ResponseBody
        public ResultInfo getValueFromView(@RequestBody EnumTestFrom form) {
    		
    		// 先将前台的数据插入数据库
            mapper.insertEnumData(form);
    		
    		// 插入完成之后查询所有的Teacher数据
            List<Teacher> teachers = mapper.selectAllData();
    
            // 教师按照性别枚举类进行分组
            EnumMap<SexTypes, Set<Teacher>> collect = teachers.stream().collect(
                    Collectors.groupingBy(
                            // 参数一: 分组按照什么进行分类,此处按照教师性别进行分类
                            Teacher::getSexTypes,
                            // 参数二: 分组最后用什么容器保存返回,默认是HashMap::new.此处我们指定使用EnumMap
                            () -> new EnumMap<>(SexTypes.class),
                            // 参数三: 按照第一个参数分类之后,对应的分类的结果如何收集,默认是Collectors.toList
                            Collectors.toSet()
                    )
            );
            System.out.println(collect);
    		
    		// 将封装好的EnumMap数据封装到自定义实体类中返回前台
            return new ResultInfo("成功", collect);
        }
    }
    

    效果

    枚举类数据通过自定义转换器处理,插入数据库成功

    在这里插入图片描述

    在这里插入图片描述

    对数据查询,通过自定义转换器封装为枚举类

    在这里插入图片描述

    将数据封装为EnumMap这种枚举类为key的数据格式

    在这里插入图片描述

    前台接收到后台返回值

    在这里插入图片描述

    展开全文
  • Java学习记录——枚举类之自定义枚举类 一、什么是枚举类? 所谓的枚举类,就是有限个类的对象。比如说定义了一个星期类,而星期是有限的,只有一至七;再比如说,定义了一个季节类,春夏秋冬是有限的季节类的对象。...

    Java学习记录——枚举类之自定义枚举类

    一、什么是枚举类?

    1.所谓的枚举类,就是有限个类的对象。比如说定义了一个星期类,而星期是有限的,只有一至七;
    再比如说,定义了一个季节类,春夏秋冬是有限的季节类的对象。这就是枚举类。说白了,就是一个一个数出来,有点类似于遍历,但与遍历的概念不等同。
    2.当需要定义一组产量时,强烈建议使用枚举类。
    3.当枚举类当中只有一个对象,则可以作为单例模式的实现方式。
    	(1)啥是单例模式?简言之:确保某个类只有一个对象实例。单例类	必须自己创建自己的唯一实例。单例类必须给所有其他对象提供这一实例。
    

    二、如何定义枚举类?

    (以下的定义枚举类的方法采用的是JDK5.0之前的方式定义)

    以定义一个季节类为示例,供大家学习。

    public class SeasonTest {
        public static void main(String[] args) {
            Season spring = Season.SPRING;
            System.out.println(spring);//输出
        }
    }
    //自定义枚举类
    class Season{
        //1.声明Season对象的属性:private final 修饰 作为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 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:获取属性,只有get方法可以调。因为对象是一个常量,不可以修改的,所以拿到的只有get方法。
    
        public String getSeasonName() {
            return seasonName;
        }
    
        public String getSeasonDesc() {
            return seasonDesc;
        }
    
        //4.诉求2:输出
        @Override
        public String toString() {
            return "Season{" +
                    "seasonName='" + seasonName + '\'' +
                    ", seasonDesc='" + seasonDesc + '\'' +
                    '}';
        }
    }
    
    
    
    
    
    

    在这里插入图片描述

    展开全文
  • 一、枚举类的概述 1.枚举类的理解:类的对象只有有限个,确定的。我们称此类为枚举类 2.当需要定义一组常量时,强烈建议使用枚举类 3.如果枚举类中只一个对象,则可以作为单例模式的实现方式。 二、枚举类中的常用...
  • 深入理解枚举类

    千次阅读 2021-03-14 03:33:40
    深入理解枚举最近刚学习完JVM相关知识,想到枚举既然这么异类,那就从字节码角度来分析一下它。... 枚举类和普通类的区别:(1)枚举类可以实现一个或多个接口,使用enum定义的枚举类默认继承了jav...
  • Java枚举类

    千次阅读 2021-01-15 21:47:46
    Java枚举类轻松入门
  • 首先大家要明白的是:枚举类不是Python的原生类!不是原生类!不是!Python中的枚举类是依靠 enum模块 来实现的。 枚举是在 Python3.4 添加的新功能(安装Python解释器后自带的官方模块),3.4以前的版本需要使用pip...
  • 1.枚举类注:JDK1.5之前需要自定义枚举类JDK 1.5 新增的 enum 关键字用于定义枚举类若枚举只有一个成员, 则可以作为一种单例模式的实现方式1.枚举类的属性1、枚举类对象的属性不应允许被改动, 所以应该使用 private ...
  • Java学习——枚举类

    2021-03-15 03:20:42
    Java学习——枚举类摘要:本文主要介绍了Java的枚举类。部分内容来自以下博客:https://www.cnblogs.com/sister/p/4700702.htmlhttps://blog.csdn.net/zhou520yue520/article/details/80952404为什么使用枚举类枚举...
  • Java 枚举类 详解

    千次阅读 2021-02-27 21:46:36
    1、枚举是什么?Java中的枚举其实是一种...2、枚举类和普通类的区别①、使用 enum 定义的枚举类默认继承 java.lang.Enum 类,即枚举类是不能再继承别的类了。而普通类的一般父类默认是 Object②、枚举类的构造器只能...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 460,845
精华内容 184,338
关键字:

枚举类