精华内容
下载资源
问答
  • Java中如何创建一个枚举Enum

    千次阅读 2019-12-10 15:22:21
    从jdk5出现了枚举类后,定义一些字典值可以使用枚举类型。 枚举常用的方法是 ...获取枚举类中的常量的名称使用枚举对象.name() 枚举类中重写了toString()方法,返回的是枚举常量的名称; 其实toString()和va...

    从jdk5出现了枚举类后,定义一些字典值可以使用枚举类型。

    枚举常用的方法是

    values():对枚举中的常量值进行遍历;

    valueof(String name) :根据名称获取枚举类中定义的常量值;要求字符串跟枚举的常量名必须一致;

    获取枚举类中的常量的名称使用枚举对象.name()

    枚举类中重写了toString()方法,返回的是枚举常量的名称;

    其实toString()和value是相反的一对操作。valueOf是通过名称获取枚举常量对象。而toString()是通过枚举常量获取枚举常量的名称;

    下面是枚举类的创建,和使用:

    package enumTest;
    
    public enum Color {
    
        RED(0,"红色"),
        BLUE(1,"蓝色"),
        GREEN(2,"绿色");
    
    //    可以看出这在枚举类型里定义变量和方法和在普通类里面定义方法和变量没有什么区别。唯一要注意的只是变量和方法定义必须放在所有枚举值定义的后面,否则编译器会给出一个错误。
        private int code;
        private String desc;
    
        Color(int code, String desc) {
            this.code = code;
            this.desc = desc;
        }
    
        /**
         * 自己定义一个静态方法,通过code返回枚举常量对象
         * @param code
         * @return
         */
        public static Color getValue(int code){
    
            for (Color  color: values()) {
                if(color.getCode() == code){
                    return  color;
                }
            }
            return null;
    
        }
    
    
        public int getCode() {
            return code;
        }
    
        public void setCode(int code) {
            this.code = code;
        }
    
        public String getDesc() {
            return desc;
        }
    
        public void setDesc(String desc) {
            this.desc = desc;
        }
    }

     

    使用(测试类):

    package enumTest;
    
    
    public class EnumTest {
        public static void main(String[] args){
            /**
             * 测试枚举的values()
             *
             */
            String s = Color.getValue(0).getDesc();
            System.out.println("获取的值为:"+ s);
    
    
            /**
             * 测试枚举的valueof,里面的值可以是自己定义的枚举常量的名称
             * 其中valueOf方法会把一个String类型的名称转变成枚举项,也就是在枚举项中查找字面值和该参数相等的枚举项。
             */
    
            Color color =Color.valueOf("GREEN");
            System.out.println(color.getDesc());
    
            /**
             * 测试枚举的toString()方法
             */
    
            Color s2 = Color.getValue(0) ;
            System.out.println("获取的值为:"+ s2.toString());
    
        }

     参考:https://www.cnblogs.com/codething/p/9321174.html

    展开全文
  • 如何手动创建枚举类 package com.joy.bean; /* * 如何手动创建枚举类 * * ①声明Season对象的属性(用private final修饰) * ②私有化类的构造器,并且给对象的属性赋值 * ③提供当前枚举类的多个对象(用public ...

    自定义枚举类

    package com.joy.bean;
    
    /*
    * 如何手动创建枚举类
    *
    * ①声明Season对象的属性(用private final修饰)
    * ②私有化类的构造器,并且给对象的属性赋值
    * ③提供当前枚举类的多个对象(用public static final修饰)
    * ------以下是可选步骤--------
    * ④获取枚举类对象的属性
    * ⑤重写Object类中的toString方法
    * */
    public class EnumOne {
        public static void main(String[] args) {
            Season spring = Season.SPRING;
            Season summer = Season.SUMMER;
            Season autumn = Season.AUTUMN;
            Season winter = Season.WINTER;
            //若未重写toString方法,又因为其继承的时Object类,则打印出的是地址值
            System.out.println(spring);
            System.out.println(summer);
            System.out.println(autumn);
            System.out.println(winter);
        }
    }
    class Season{
    //  ①声明Season对象的属性(用private final修饰)
        private final String seasonName;
        private final String seasonDesc;
    //  ②私有化类的构造器,并且给对象的属性赋值
        private Season(String seasonName,String seasonDesc){
            this.seasonName = seasonName;
            this.seasonDesc = seasonDesc;
        }
    //  ③提供当前枚举类的多个对象(用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("冬","白雪皑皑");
    //  ④获取枚举类对象的属性
        public String getSeasonName(){
            return seasonName;
        }
        public String getSeasonDesc(){
            return seasonDesc;
        }
    //  重写Object类中的toString方法,否则打印出的是地址值
        @Override
        public String toString() {
            return "季节:"+seasonName+"  "+"描述:"+seasonDesc;
        }
    }
    

    使用enum关键字定义枚举类

    package com.joy.bean;
    
    /*
     * 使用enum关键字定义枚举类
     *
     * ①提供当前枚举类的对象,多个对象之间用 ”,“ 隔开,最后用 ”;“ 结束
     * ②声明Season对象的属性(用private final修饰)
     * ③私有化类的构造器,并且给对象的属性赋值
     * ④获取枚举类对象的属性
     * ⑤重写Object类中的toString方法,否则打印出的是对象名
     *
     * 注意:第一步必须在最前面
     * */
    public class EnumTwo {
        public static void main(String[] args) {
            Season2 spring = Season2.SPRING;
            Season2 summer = Season2.SUMMER;
            Season2 autumn = Season2.AUTUMN;
            Season2 winter = Season2.WINTER;
    //      若未重写toString方法,又因为其继承的是Enum类,则打印出的是对象名
    //      可由 System.out.println(Season2.class.getSuperclass());获取
            System.out.println(spring);
            System.out.println(summer);
            System.out.println(autumn);
            System.out.println(winter);
        }
    }
    
    enum Season2 {
    //  ①提供当前枚举类的对象,多个对象之间用 ”,“ 隔开,最后用 ”;“ 结束
    
        SPRING("春", "鸟语花香"),
        SUMMER("夏", "夏日炎炎"),
        AUTUMN("秋", "秋高气爽"),
        WINTER("冬", "白雪皑皑");
    
    //  ②声明Season对象的属性(用private final修饰)
        private final String seasonName;
        private final String seasonDesc;
    
    //  ③私有化类的构造器,并且给对象的属性赋值
        private Season2(String seasonName, String seasonDesc) {
            this.seasonName = seasonName;
            this.seasonDesc = seasonDesc;
        }
    
    //  ④获取枚举类对象的属性
        public String getSeasonName() {
            return seasonName;
        }
    
        public String getSeasonDesc() {
            return seasonDesc;
        }
    
    //  ⑤重写Object类中的toString方法,否则打印出的是对象名
        @Override
        public String toString() {
            return "季节:" + seasonName + "  " + "描述:" + seasonDesc;
        }
    }
    
    
    
    展开全文
  • java枚举类

    2018-09-19 11:23:15
    1.如何自定义枚举类枚举类:类的对象是有限个的,确定的。  私有化类的构造器,保证不能在类的外部创建对象   在类的内部创建枚举类的实例。声明为:public static final   若类有属性,那么属性声明为...

    枚举类


    1.如何自定义枚举类。 枚举类:类的对象是有限个的,确定的。

    •    私有化类的构造器,保证不能在类的外部创建其对象 
    •    在类的内部创建枚举类的实例。声明为:public static final 
    •    若类有属性,那么属性声明为:private final 。此属性在构造器中赋值。

    2.使用enum关键字定义枚举类

    1.     其中常用的方法:values()  valueOf(String name);
    2.     枚举类如何实现接口  
    •  让类实现此接口,类的对象共享同一套接口的抽象方法的实现。
    •  让类的每一个对象都去实现接口的抽象方法,进而通过类的对象调用被重写的抽象方法时,执行的效果不同

    自定义枚举类代码:

    class Season{
    
        private final String name;
        private final String desc;
    
        public String getName() {
            return name;
        }
    
        public String getDesc() {
            return desc;
        }
    
        private Season(String name, String desc) {
            this.name = name;
            this.desc = desc;
        }
        public static final Season SPRING = new Season("spring","春暖花开");
        public static final Season SUMMER = new Season("summer","夏日炎炎");
        public static final Season AUTUMN = new Season("autumn","秋高气爽");
        public static final Season WINTER = new Season("winter","白雪皑皑");
    
    
        @Override
        public String toString() {
            return "Season{" +
                    "name='" + name + '\'' +
                    ", desc='" + desc + '\'' +
                    '}';
        }
    
        public void show(){
            System.out.println("这是一个季节");
        }
    }
    

    用enum关键字创建枚举类代码:

    public class TestSeason1 {
        public static void main(String[] args) {
            Season1 spring = Season1.SPRING;
            System.out.println(spring);
            spring.show();
            System.out.println(spring.getSeasonName());
            
            System.out.println();
            //1.values()
            Season1[] seasons = Season1.values();
            for(int i = 0;i < seasons.length;i++){
                System.out.println(seasons[i]);
            }
            //2.valueOf(String name):要求传入的形参name是枚举类对象的名字。
            //否则,报java.lang.IllegalArgumentException异常
            String str = "WINTER";
            Season1 sea = Season1.valueOf(str);
            System.out.println(sea);
            System.out.println();
            
            Thread.State[] states = Thread.State.values();
            for(int i = 0;i < states.length;i++){
                System.out.println(states[i]);
            }
            sea.show();
            
        }
    }
    interface Info{
        void show();
    }
    //枚举类
    enum Season1 implements Info{
        SPRING("spring", "春暖花开"){
            public void show(){
                System.out.println("春天在哪里?");
            }
        },
        SUMMER("summer", "夏日炎炎"){
            public void show(){
                System.out.println("生如夏花");
            }
        },
        AUTUMN("autumn", "秋高气爽"){
            public void show(){
                System.out.println("秋天是用来分手的季节");
            }
        },
        WINTER("winter", "白雪皑皑"){
            public void show(){
                System.out.println("冬天里的一把火");
            }
        };
        
        private final String seasonName;
        private final String seasonDesc;
        
        private Season1(String seasonName,String seasonDesc){
            this.seasonName = seasonName;
            this.seasonDesc = seasonDesc;
        }
        public String getSeasonName() {
            return seasonName;
        }
        public String getSeasonDesc() {
            return seasonDesc;
        }
        
        @Override
        public String toString() {
            return "Season [seasonName=" + seasonName + ", seasonDesc="
                    + seasonDesc + "]";
        }
    //    public void show(){
    //        System.out.println("这是一个季节");
    //    }
    }
    展开全文
  • 枚举类和注解

    2021-01-26 00:53:11
    枚举类 ...如何定义枚举类 方式一:JDK 5.0之前,自定义枚举类 方拾二:JDK 5.0之后可以用enum关键字定义枚举类 方法一 、自定义枚举类 public class SeasonTest { public static void main(Str

    枚举类

    枚举用于类的对象个数有限且确定,例如:

    ​ 性别:男,女

    ​ 星期:星期一,星期二,、、、

    ​ 季节:春、夏、秋、冬

    ​ 、、、、、

    当需要定义一组常量时,强烈建议使用枚举类

    如果枚举类只有一个对象,则可以作为单利模式的实现方式

    创建方法

    如何定义枚举类
    方式一:JDK 5.0之前,自定义枚举类
    方拾二:JDK 5.0之后可以用enum关键字定义枚举类
    

    方法一 、自定义枚举类

    public class SeasonTest {
        public static void main(String[] args) {
            Season spring = Season.SPRING;
            System.out.println(spring);
        }
    }
    //自定义枚举类
    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.其他诉求,获取枚举类对象的属性
        public String getSeasonName() {
            return seasonName;
        }
    
        public String getSeasonDesc() {
            return seasonDesc;
        }
        //4, 其他诉求,提供toString()
        //该类继承于object类,toString()方法返回的是地址,故可以按需重写tostring()方法
    
        @Override
        public String toString() {//重写toString()方法
            return "Season{" +
                    "seasonName='" + seasonName + '\'' +
                    ", seasonDesc='" + seasonDesc + '\'' +
                    '}';
        }
    }
    

    方法二、enum关键字实现枚举类

    package javaSE.Enum;
    
    /**
     * 使用enum关键字定义枚举类
     * 说明:定义的枚举类默认继承于java.lang.Enumle。其toString()方法返回的
     * 是枚举类中的对象变量名可虫子额toString()方法打印需要的内容
     */
    public class SeasonTest1 {
        public static void main(String[] args) {
            Season1 spring = Season1.SPRING;
            System.out.println(spring);
    
        }
    }
    
    //自定义枚举类
    enum  Season1{
    
        //1, 提供枚举类的对象
        SPRING ("春天","春暖花开"),
        SUMMER ("夏天","夏日炎炎"),
        AUTUMN ("秋天","秋高气爽"),
        WINTER ("冬天","冰天雪地");
        //enum实现枚举,对象放在最开始,且不同对象之间用逗号隔开且最后用分号
    
        //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.其他诉求,获取枚举类对象的属性
        public String getSeasonName() {
            return seasonName;
        }
    
        public String getSeasonDesc() {
            return seasonDesc;
        }
        //4, 其他诉求,提供toString()
    
         @Override
        public String toString() {//重写toString()方法
            return "Season1{" +
                    "seasonName='" + seasonName + '\'' +
                    ", seasonDesc='" + seasonDesc + '\'' +
                    '}';
        }
    }
    
    

    enum类的主要方法

    values()方法:返回枚举类型的对象数组,该方法可以很方便的遍历枚举值

    valueof(String str):可以把一个字符串转为对应的枚举对象,要求字符串必须是枚举类对象的“名字”,如果不是会有运行时异常

    toString():返回当前枚举类对象常量的名字

    package javaSE.Enum;
    
    /**
     * 使用enum关键字定义枚举类
     * 说明:定义的枚举类默认继承于java.lang.Enumle。其toString()方法返回的
     * 是枚举类中的对象变量名可虫子额toString()方法打印需要的内容
     */
    public class SeasonTest1 {
        public static void main(String[] args) {
            Season1 spring = Season1.SPRING;
            //tostring()
            System.out.println(spring);
            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]);
            }
    
            System.out.println("************************");
            //valueof(string str);返回一个枚举对象名是str的对象
            //如果没有str的枚举类对象会抛出IllegalArgumentException异常
    
            Season1 winter = Season1.valueOf("WINTER");
            System.out.println(winter);
    
        }
    }
    
    //自定义枚举类
    enum  Season1{
    
        //1, 提供枚举类的对象
        SPRING ("春天","春暖花开"),
        SUMMER ("夏天","夏日炎炎"),
        AUTUMN ("秋天","秋高气爽"),
        WINTER ("冬天","冰天雪地");
        //enum实现枚举,对象放在最开始,且不同对象之间用逗号隔开且最后用分号
    
        //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.其他诉求,获取枚举类对象的属性
        public String getSeasonName() {
            return seasonName;
        }
    
        public String getSeasonDesc() {
            return seasonDesc;
        }
        //4, 其他诉求,提供toString()
    
    //     @Override
    //    public String toString() {//重写toString()方法
    //        return "Season1{" +
    //                "seasonName='" + seasonName + '\'' +
    //                ", seasonDesc='" + seasonDesc + '\'' +
    //                '}';
    //    }
    }
    
    

    使用enum关键字实现的枚举类实现接口的情况

    情况一

    ​ 和普通类实现接口一样,在enum类中实现抽象方法

    interface Info{
        void show ();
    }
    
    //自定义枚举类
    enum  Season1 implements Info{
        
        SPRING ("春天","春暖花开"),
        SUMMER ("夏天","夏日炎炎"),
        AUTUMN ("秋天","秋高气爽"),
        WINTER ("冬天","冰天雪地");
        
        private final String seasonName;
        private final String seasonDesc;
        
        private Season1(String seasonName,String seasonDesc){
            this.seasonName = seasonName;
            this.seasonDesc = seasonDesc;
        }
        
        public String getSeasonName() {
            return seasonName;
        }
    
        public String getSeasonDesc() {
            return seasonDesc;
        }
       
    
        @Override
        public void show() {
            System.out.println("这是一个季节");
        }
    }
    

    情况二

    情况一中每一个枚举类对象调用接口实现方法所执行的步骤都相同,如果想让每一个枚举类对象调用接口实现对象时执行不同的操作,则可以让每一个对象都实现一下该接口方法,如下

    interface Info{
        void show ();
    }
    
    //自定义枚举类
    enum  Season1 implements Info{
    
        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("大约在冬季");
            }
        };
    
        private final String seasonName;
        private final String seasonDesc;
    
        private Season1(String seasonName,String seasonDesc){
            this.seasonName = seasonName;
            this.seasonDesc = seasonDesc;
        }
    
        public String getSeasonName() {
            return seasonName;
        }
    
        public String getSeasonDesc() {
            return seasonDesc;
        }
    }
    

    注解

    概述

    	从JDK 5.0开始,java增加了对元数据(MetaData)的支持,也就是Annotation(注解)
    

    ​ Annotation其实就是代码里的特殊标记,程序员可以通过Annotation在不改变原有逻辑的情况下,在源文件中嵌入一些补充信息。

    ​ Annotation可以像修饰符一样使用,可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明,这些信息被保存在Annotation的“name = value”对中。

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

    @author

    @version

    @see;参考主题,也是相关主题

    @since;从那个版本开始增加

    @param;对方法中的参数的说明,如果没有参数就不能写

    @return对方法返回值的说明,如果返回值是void就不能写

    @exception;对方法抛出的异常进行说明,如果方法没有用throw显示抛出异常就不能写

    ​ 其中

    ​ @param、@return、@exception只能用在方法中

    ​ @param格式要求: @param形参名 形参类型 形参说明

    ​ @return格式要求: @return 返回值类型 返回值说明

    ​ @exception的格式要求:@exception 异常类型 异常说明

    ​ @param和@exception可以并列多个

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

    ​ @Override;限定重写父类方法,该注解只用于方法

    ​ @Deprecated;用于表示所修饰元素(类、方法等)已过时,通常是因为所修饰的结构危险或存在更好的选择

    ​ @SupressWarnings;抑制编译器警告

    示例三,跟踪代码的依赖性,实现替代配置文件功能

    自定义注解

    自定义注解必须配上注解的信息处理流程(使用反射)才有意义
    

    在这里插入图片描述

    package javaSE.Annotation;
    
    /**
     * 自定义注解
     *  注解生命为 @interface
     *  内部定义成员,通常使用value使用
     *  可以指定成员的默认值,使用default定义
     *  如果自定义注解没有成员,表明是一个标识作用
     *
     * @Author: Thewind
     * @Date: 2021/1/25 22:22
     */
    public @interface MyAnnotation {
    
        // String value();
        // 此方法设置默认值,其调用方法为 @MyAnnotation(value = " hello")
    
    
        String value() default "hello";
        //此方法设置了默认值,其调用方法为@MyAnnotation()
        //但是也可以使用@MyAnnotation(value = " 其他值")
    
    }
    
    

    JDK中的元注解

    JDK的元Annotation是用于修饰其他的Annotation定义

    JDK 5.0提供了4个标准的meta-annotation类型,分别是

    Retention

    Target

    Documented

    Inherited

    自定义注解时通常会指明两个元注解,@Retention和@Target

    Retention

    指定所修饰的Annotationd的生命周期,

    在这里插入图片描述

    Target

    用于指示被修饰的Annotation 能用于修饰那些程序元素

    //使用方法 @Target(ElementType.常量)
    //或者@Target({常量,常量,常量,.....})
    
    
    //ElementType类的定义
    public enum ElementType {
        /** Class, interface (including annotation type), or enum declaration */
        TYPE,
    
        /** Field declaration (includes enum constants) */
        FIELD,
    
        /** Method declaration */
        METHOD,
    
        /** Formal parameter declaration */
        PARAMETER,
    
        /** Constructor declaration */
        CONSTRUCTOR,
    
        /** Local variable declaration */
        LOCAL_VARIABLE,
    
        /** Annotation type declaration */
        ANNOTATION_TYPE,
    
        /** Package declaration */
        PACKAGE,
    
        /**
         * Type parameter declaration
         *
         * @since 1.8
         */
        TYPE_PARAMETER,
    
        /**
         * Use of a type
         *
         * @since 1.8
         */
        TYPE_USE
    }
    

    Documented

    用于指定所修饰的Annotation注解将被javaDoc解析时会被保留下来

    注意:定义为Documented 的注解必须设置Retention为RUNTIME

    Inherited

    它所修饰的注解将具有继承性,即如果某个类使用了被@Inherited修饰的注解,其子类将自动具有该注解

    通过反射获取注解信息

    反射章节再具体介绍

    JDK 8 中注解的新特性

    可重复注解

    注解可重复注解多次

    ​ 说明:MyAnnotations,和MyAnnotation是自定义注解类

    ​ 1,在MyAnnotation 上声明 @Repeatable,成员值为MyAnnotation.class

    2,MyAnnotation的 Target和Retention和MyAnnotations相同

    类型注解

    在这里插入图片描述

    展开全文
  • 枚举(枚举类)一、枚举和枚举类二、如何自定义枚举类1、私有化构造器2、私有化属性并在构造器中初始化属性3、设置可以调用属性的公共方法4、提供方法与重写toString5、创建枚举类对象三、如何使用enum关键字创建...
  • 目录java枚举类和enum关键字一、枚举的理解二、传统的方式创建枚举 【了解】二、使用enum关键字定义枚举【掌握】三、介绍枚举类的常见方法【了解】四、枚举类如何实现接口【掌握】 一、枚举的理解 枚举其实就是一...
  • 它讨论了高级主题,包括对象创建,并发,序列化,反射等。 它将指导您完成Java掌握的旅程! 在这里查看 ! 目录 1.简介 2.枚举作为特殊 3.枚举和实例字段 4.枚举和接口 5.枚举和泛型 6.便捷的...
  • 枚举类与注解

    2021-03-09 15:03:41
    如何定义 1.对象有限个 2.需要定义一种常量的时候,枚举列...第一步:先创建对象 public static final s =new Season1(..............); //以上修改成 s(); //因为其他是多余的,一定是public static final XXX =ne
  • 目录   枚举Enum 创建枚举 通过构造函数创建枚举对象 ...访问枚举对象中元素的... 学过java都知道如何创建枚举类 Enum, 给定构造函数,然后在内部写枚举对象以及枚举对象的属性  那么python也是一样的。而且...
  • 如何根据字符串动态创建类对象

    千次阅读 2013-04-13 11:12:43
    如何根据字符串动态创建对象  今天跟同事聊天的时候,同事有一个需求,就是如何根据的名字和值,动态返回该...当然,我们也可以返回Integer对象、Long对象等,该函数可以实现动态的创建对象。 一、 枚举
  • 全方位解析枚举类

    2016-05-24 17:05:57
    如何自定义枚举类 1.私有化类的构造器,保证不能在类的外部创建对象 2.在类的内部创建枚举类的实例。...1.把内的内部创建枚举类对象首行, 2.变形:去掉重复的东西(见博客) 3.可以单独定义抽象方法
  • 枚举类enum和注解Annotation

    千次阅读 2018-08-16 20:31:07
    1.如何自定义枚举类枚举类:类的对象是有限个的,确定的。  1.1 私有化类的构造器,保证不能在类的外部创建对象   1.2 在类的内部创建枚举类的实例。声明为:public static final   1.3 若类有属性,那么...
  • java枚举类关键字enum,是jdk1.5之后 才有的新...1、如何创建一个枚举类?创建一个枚举类就和创建类的原理一样,只是class关键字换成enum关键字,比如: public enum Light { RED , GREEN , YELLOW ; } 2、ja...
  • 一、请问如何创建对象的方式都有哪些? 答:①用new语句创建对象; ②调用对象的clone()方法; ③运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor的newInstance()实例方法。 ④运用反...
  •  1.1 私有化类的构造器,保证不能在类的外部创建对象 1.2 在类的内部创建枚举类的实例。声明为:public static final 1.3 若类有属性,那么属性声明为:private final 。此属性在构造器中赋值。2.使用enum...
  • 1、如何自定义枚举类枚举类:类的对象时有限个的、确定的(不可被修改)。 1.1 私有化类的构造器,保证不能在类的外部创建对象 1.2 在类的内部创建枚举类的实例。声明为:public static final 1.3 若类有属性...
  • Java学习笔记之枚举类

    2015-04-17 10:27:05
    枚举类: 一:如何自定义枚举类: 1、提供类的属性,声明为private final。...4、创建枚举类对象:将类的对象声明为public static final public class TestSeason { public static void main(String[] ar
  • 枚举类:类的对象是有限个的,确定的 1.1私有化类的构造器,保证不能在类的外部创建对象 1.2在类的内部创建枚举类的实例,声明为:publicstatic final 1.3若类有属性,那么属性声明为:privatefinal .此属性在构造器中...
  • 第九章:Java_枚举类和注解

    千次阅读 2017-02-13 22:48:31
    如何自定义枚举类枚举类:类的对象是有限个的,确定的。 1.1 私有化类的构造器,保证不能在类的外部创建对象 1.2 在类的内部创建枚举类的实例。声明为:public static final 1.3 若类有属性,那么属性声明为...
  • 枚举非常适合将具有相似行为的对象组合在一起。 它们也是有效的,因为将仅创建其中一个实例。 但是,很难为行为稍有不同的实现枚举。 让我举例说明。 示例:统计计算器 假设我们要编写一个统计计算器,以计算...
  • 1.如何自定义枚举类枚举类:类的对象是有限个的,确定的。  1.1 私有化类的构造器,保证不能在类的外部创建对象   1.2 在类的内部创建枚举类的实例。声明为:public static final   1.3 若类有属性,...
  • 枚举

    2021-02-22 14:54:47
    1. 概念: 类的对象只有有限个,确定的。此类可以看做是枚举类。...3. 创建枚举类中的对象:public static final 6. 如何使用enum关键字自定义枚举类(jdk5.0) enum Seanson{ // 声明对象-必须省略public
  • 一、枚举类的使用 当类的对象只有有限个,确定的(此类称为枚举类),如 星期:周一,… , 周日 ...1. 如何自定义枚举类(JDK5.0之前) 枚举类的属性 枚举类对象的属性不应允许被改动,所以应
  • 但这样子时行不通的,因为声明只是描述了对象的形式,并没有创建对象。因此,在创建对象前,将没有用于存储值得空间。 然而,有两个方式可以实现这个目标,并且效果相同。 第一种方式是在中声明一个枚举。在...
  • 该项目包含一个C ++,该允许在Windows中使用DirectShow枚举设备,以便选择和获取在创建(例如)VideoCapture对象以从摄像机抓取帧时需要与OpenCV一起使用的ID。 我决定将其设置为“如何获取在OpenCV中使用的设备...
  • java枚举如何使用与注意事项

    千次阅读 2021-04-23 17:05:40
    在本内部创建一组对象 对外暴漏对象 (即:通过为对象添加public final static修饰符) 可以提供get方法,但是不能提供set方法 演示代码如下: public class TestSeason { public static void main(String[]...
  • Java中的String 在java中,String是不可不可变长的字符序列,java程序中所有的字符串字面值(如"abc")都作为此类的实例实现 简单介绍一下这些常用...如何创建对象?—>构造器 通过java为我们提供的API文档来使用...
  • 当在类体内定义好各种属性后,外部是可以随便添加属性的,Python中类如何限制实例的属性? Python自带了很多定制类,诸如__slots__,__str__ __slots__ __slots__方法是在类创建时,为实例限定属性的 class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 390
精华内容 156
关键字:

枚举类如何创建对象