精华内容
下载资源
问答
  • 枚举 enum关键字

    2017-12-29 19:57:44
    在 C 语言中对这样取值比较特殊的变量可以定义枚举类型。所谓枚举是指将变量的值一一列举出来,变量只限于列举出来的值的范围内取值。enum DAY { MON=1, TUE, WED, THU, FRI, SAT, SUN, };枚举一般的...

    在实际应用中,有的变量只有几种可能取值。如人的性别只有两种可能取值,星期只有七种可能取值。在 C 语言中对这样取值比较特殊的变量可以定义为枚举类型。所谓枚举是指将变量的值一一列举出来,变量只限于列举出来的值的范围内取值。

    enum DAY
    {
      MON=1, 
      TUE,  
      WED,  
      THU, 
      FRI, 
      SAT, 
      SUN,
    };

    枚举一般的定义方式如下:

    enum enum_type_name //标识符 数据类型名
    { 
        ENUM_CONST_1,//枚举常量 (常量一般大写)
        ENUM_CONST_1,//注意此处是 , 而不是 ;
        ENUM_CONST_1,
    }enum_variable_name;//是enum_type_name类型的一个变量名

    enum变量类型可以给其中的常量符号赋值,如果不赋值的话将会从被赋初值的那个常量开始依次加1,如果都没有赋值,他们的值从0开始依次递增加1。

    (1)全员没有被赋值 从0开始依次加1

    这里写图片描述

    (2)部分成员被赋值 从被赋值的成员开始加1

    这里写图片描述

    枚举的具体应用(密码锁)

    #include<stdio.h>
    //定义枚举数据类型及类型别名
    typedef enum STATE
    {
            STATE1,
            STATE2,
            STATE3,
            STATE4,
    }S;
    int main(void)
    {
            int num = 0;
            S current_state = STATE1;//current_state是一个枚举类型的数据,其取值只能是S类型里面的数据。
            printf("请输入密码");
            while (1)
            {
                    scanf("%d", &num);
                    printf("num = %d.\n", num);
                    //判断当时的状态 
                    switch (current_state)
                    {
                            case STATE1:
                            if (num == 2)
                                    {
                                            current_state = STATE2; // 如果第一个密码输入正确,就进入下一个状态 
                                    }
                            else
                                    {
                                            current_state = STATE1;
                                    }
                            break;
    
                            case STATE2:
                            if (num == 5)
                                    {
                                            current_state = STATE3;  
                                    }
                            else
                                    {
                                            current_state = STATE1;
                                    }
                            break;
    
                            case STATE3:
                            if (num == 8)
                                    {
                                            current_state = STATE4; 
                                    }
                            else
                                    {
                                            current_state = STATE1;
                                    }
                            break;
    
    
                            default:
                            current_state = STATE1;
                            break;      
                    }
                    if (current_state == STATE4)
                    {
                            printf("密码正确.\n");
                            //break
                            return 0;
                    }
                    if (current_state == STATE1)
                    {
                            printf("请重新输入\n");
                    }
            }
    } 

    程序运行结果:

    这里写图片描述

    展开全文
  • Java枚举enum关键字

    2019-07-18 17:20:00
    枚举的理解 枚举其实就是一个类,枚举类的实例是一组限定的对象 传统的方式创建枚举 【了解】 对比:单例类 1、构造器私有化 2、本类内部创建对象 3、通过public static方法,对外暴露该对象 枚举类 1、构造器...

    枚举的理解

    枚举其实就是一个类,枚举类的实例是一组限定的对象

    传统的方式创建枚举 【了解】

    对比:单例类

    1、构造器私有化
    2、本类内部创建对象
    3、通过public static方法,对外暴露该对象

    枚举类

    1、构造器私有化
    2、本类内部创建一组对象,添加public static修饰符,直接暴露对象

    /**
     * 此类用于演示使用传统的方式创建枚举
     * 步骤
     *    1、构造器私有化    
        2、本类内部创建一组对象,添加public static final修饰符,直接暴露对象
     */
    public class TestEnum1 {
        public static void main(String[] args) {
            //引用枚举类的对象        
            System.out.println(Season.SPRING);
            System.out.println(Season.SUMMER);
    }//简单示例2:提供有参构造
    class Season{
        private String name;//季节名称
        private String description;//季节描述
        //2.本类内部创建一组对象,添加public static修饰符,直接暴露对象
        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("冬天","千树万树梨花开");
        
        //1、构造器私有化    
        private Season(String name, String description) {
            super();
            this.name = name;
            this.description = description;
        }
        public String getName() {
            return name;
        }
        
        public String getDescription() {
            return description;
        }
    
        @Override
        public String toString() {
            return "Season [name=" + name + ", description=" + description + "]";
        }
    }

    使用enum关键字定义枚举掌握

    引入:jdk5.0出现的新特性

    【特点】

    1、使用enum关键字代替class关键字
    2、对象(常量)的创建必须放在枚举类中的第一句

    【语法】

    对象名(实参列表), 对象名(实参列表);

    3、如果是无参构造,则无参构造的定义和实参列表都可以省略

    /**
     * 此类用于演示使用enum关键字定义枚举类【掌握】
     * 引入:jdk5.0出现的新特性
     * 特点:
     *         1、使用enum关键字代替class关键字
     *         2、对象(常量)的创建必须放在枚举类中的第一句
     *         语法:
     *         对象名(实参列表),对象名(实参列表);
     *         3、如果是无参构造,则无参构造的定义和实参列表都可以省略
     *
     */
    public class TestEnum2 {
        
        public static void main(String[] args) {
            //引用枚举类的对象
            //示例1:
            System.out.println(Gender2.GIRL);
            
            //示例2:
            System.out.println(Season2.SUMMER);
        }
    }
    enum Season2{
        //2.本类内部创建一组对象,添加public static修饰符,直接暴露对象
        SPRING("春天","春风又绿江大南"),
        SUMMER ("夏天","接天莲叶无穷碧"),
        AUTUMN ("秋天","霜叶红于二月花"),
        WINTER("冬天","千树万树梨花开");
    
        private String name;
        private String description;
        
        //1、构造器私有化    
        private Season2(String name, String description) {
            this.name = name;
            this.description = description;
        }
        public String getName() {
            return name;
        }
        public String getDescription() {
            return description;
        }
    }
    
    //简单示例1:使用无参构造器:枚举常量
    enum Gender2{
        BOY,GIRL;
    }

    介绍枚举类的常见方法【了解】

    toString:Enum类已经重写过了,返回的是当前对象的常量名。自定义的枚举类可以继续重写该方法

    name:Enum类中的name方法返回的是当前对象的常量名(同toString),但自定义的枚举类不可以继续重写该方法

    values:一个静态方法,用于返回指定的枚举类中的所有枚举常量

    valueOf:一个静态方法,将一个有效的字符串转换成枚举对象

    枚举类如何实现接口掌握

    特点:

    1. 和普通类实现接口一样,只是允许枚举常量也有自己对抽象方法的特有实现!

    2. enum类不能再继承其他类,因为已经隐式的直接继承了Enum类

    语法:

    enum A implements 接口1,接口2{
        常量1(参数){
            //抽象方法的实现
     
        },常量2(参数){
            //抽象方法的实现
        }
        //类对抽象方法的实现
     }

    示例:

    /**
     * 此类用于演示枚举类实现接口
     * 
     * 特点:
     *     1.和普通类实现接口一样,只是允许枚举常量也有自己对抽象方法的特有实现!
     *     2.enum类不能再继承其他类,因为已经隐式的直接继承了Enum类
     * 语法:
     * enum A implements 接口1,接口2{
     *         常量1(参数){
     *             //抽象方法的实现
     * 
     *         },常量2(参数){
     * 
     *             //抽象方法的实现
     *         }
     *         //类对抽象方法的实现
     * }
     *
     */
    public class TestEnum4 {
        
        public static void main(String[] args) {
            Show s = Color4.RED;
            s.display();
            
            Color4.BLACK.display();
        }
    }
    interface Show{
        void display();
    }
    enum Color4 implements Show{
        RED(255,0,0){
            public void display(){
                System.out.println("我是红色");
            }
        },
        BLUE(0,0,255){
            public void display(){
                System.out.println("我是蓝色");
            }
        },
        BLACK(0,0,0){
            public void display(){
                System.out.println("我是蓝色");
            }
        },
        YELLOW(255,255,0){
            public void display(){
                System.out.println("我是黄色");
            }
        },
        GREEN(0,255,0){
            public void display(){
                System.out.println("我是蓝色");
            }
        };
        private int redValue;
        public int getRedValue() {
            return redValue;
        }
        public int getGreenValue() {
            return greenValue;
        }
        public int getBlueValue() {
            return blueValue;
        }
        private int greenValue;
        private int blueValue;
        private Color4(int redValue, int greenValue, int blueValue) { // 构造器
            this.redValue = redValue;
            this.greenValue = greenValue;
            this.blueValue = blueValue;
        }
    }

     

    展开全文
  • Java枚举关键字

    2018-04-12 14:11:02
    Java枚举Java 5.0引入了枚举枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。...方法、变量、构造函数也可以在枚举定义。实例class FreshJuice { enum FreshJuiceSize{ SMALL,...

    Java枚举

    Java 5.0引入了枚举,枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。

    例如,我们为果汁店设计一个程序,它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。

    注意枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。


    实例

    class FreshJuice {
       enum FreshJuiceSize{ SMALL, MEDUIM, LARGE }
       FreshJuiceSize size;
    }
    
    public class FreshJuiceTest {
       public static void main(String args[]){
          FreshJuice juice = new FreshJuice();
          juice.size = FreshJuice. FreshJuiceSize.MEDUIM ;
       }
    }
    

    Java关键字

    这些保留字不能用于常量、变量、和任何标识符的名称

    关键字描述
    abstract抽象方法,抽象类的修饰符
    assert断言条件是否满足
    boolean布尔数据类型
    break跳出循环或者label代码段
    byte8-bit 有符号数据类型
    caseswitch语句的一个条件
    catch和try搭配捕捉异常信息
    char16-bit Unicode字符数据类型
    class定义类
    const未使用
    continue不执行循环体剩余部分
    defaultswitch语句中的默认分支
    do循环语句,循环体至少会执行一次
    double64-bit双精度浮点数
    elseif条件不成立时执行的分支
    enum枚举类型
    extends表示一个类是另一个类的子类
    final表示一个值在初始化之后就不能再改变了
    表示方法不能被重写,或者一个类不能有子类
    finally为了完成执行的代码而设计的,主要是为了程序的健壮性和完整性,无论有没有异常发生都执行代码。
    float32-bit单精度浮点数
    forfor循环语句
    goto未使用
    if条件语句
    implements表示一个类实现了接口
    import导入类
    instanceof测试一个对象是否是某个类的实例
    int32位整型数
    interface接口,一种抽象的类型,仅有方法和常量的定义
    long64位整型数
    native表示方法用非java代码实现
    new分配新的类实例
    package一系列相关类组成一个包
    private表示私有字段,或者方法等,只能从类内部访问
    protected表示字段只能通过类或者其子类访问
    子类或者在同一个包内的其他类
    public表示共有属性或者方法
    return方法返回值
    short16位数字
    static表示在类级别定义,所有实例共享的
    strictfp浮点数比较使用严格的规则
    super表示基类
    switch选择语句
    synchronized表示同一时间只能由一个线程访问的代码块
    this表示调用当前实例
    或者调用另一个构造函数
    throw抛出异常
    throws定义方法可能抛出的异常
    transient修饰不要序列化的字段
    try表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码
    void标记方法不返回任何值
    volatile标记字段可能会被多个线程同时访问,而不做同步
    whilewhile循环

    展开全文
  • 自定义枚举类 public class TestEnum1 { public static void main(String[] args) { Person man = Person.MAN; System.out.println(man.toString()); Person woman = Person.WOMAN; System.out....
    1. 自定义枚举类
      public class TestEnum1 {
      	public static void main(String[] args) {
      		
      		Person man = Person.MAN;
      		System.out.println(man.toString());
      		Person woman = Person.WOMAN;
      		System.out.println(woman);
      	}
      }
      //自定义枚举类型
      class Person{
      	//1 属性私有化
      	private final String name;
      	private final int age;
      	//2 构造器私有 化
      	private Person(String name,int age) {
      		this.name = name;
      		this.age = age;
      	}
      	//3 创建对象 
      	public final static Person MAN = new Person("小明",20);
      	public final static Person WOMAN = new Person("小花",23);
      	@Override
      	public String toString() {
      		return "Person [name=" + name + ", age=" + age + "]";
      	}
      }
      

       

    2. 通过enum关键字定义枚举
      public class TestEnum2 {
      	public static void main(String[] args) {
      		Person1 man = Person1.MAN;
      		System.out.println(man.info());
      		Person1 woman = Person1.WOMAN;
      		System.out.println(woman.info());
      	}
      }
      enum Person1{
      	MAN("小明",20),
      	WOMAN("小花",24);
      	//1 属性私有化
      	private final String name;
      	private final int age;
      	//2 构造器私有 化
      	
      	private Person1(String name,int age) {
      		this.name = name;
      		this.age = age;
      	}
      	public String info() {
      		return "Person1 [name=" + name + ", age=" + age + "]";
      	}
      }
      

      注意:创建对象必须放在最枚举类的最前面

    3. 如何实现接口
      interface Interface1{
      	void show();
      }
      enum Person1 implements Interface1{
      	MAN("小明",20){
      		public void show() {
      			System.out.println("男人");
      		}
      	},
      	WOMAN("小花",24){
      		public void show() {
      			System.out.println("女人");
      		}
      	};
      	//1 属性私有化
      	private final String name;
      	private final int age;
      	//2 构造器私有 化
      	
      	private Person1(String name,int age) {
      		this.name = name;
      		this.age = age;
      	}
      	public String info() {
      		return "Person1 [name=" + name + ", age=" + age + "]";
      	}
      	@Override
      	public void show() {
      		System.out.println("这是人类");
      		
      	}
      }
      

       

    4. 枚举中方法使用
      //两个常用的方法 values()  valueOf(String)
      		//values()获取枚举类中的所有对象 
      		Person1[] ps = Person1.values();
      		for(Person1 p : ps) {
      			System.out.println(p.info());
      		}
      		System.out.println("=============");
      		//valueOf(对象字符串)获取其中一个
      		Person1 p1 = Person1.valueOf("MAN");
      		System.out.println(p1.info());
      		Person1 p2 = Person1.valueOf("WOMAN");
      		System.out.println(p2.info());
      

       

    展开全文
  • 枚举类型

    2017-03-12 17:43:21
    目录枚举类型 语法 常用方法枚举类型枚举类型取代了...[enum][1]是定义枚举类型关键字。public enum Size { SMALL, MEDIUM, LARGE;// 定义枚举类型成员时必须为第一条语句 Size(){System.out.println(构造方法);};
  • 目录 宏定义(#define) 概念 无参宏定义 举个例子 #define 用法的几点说明 带参数的宏定义 带参宏定义的说明 枚举类型(enum 关键字) 概念 过度 类型创建 类型定义,初始化 赋值 作为函数即返回值 typedef 存在的...
  • 使用enum关键字定义枚举类 定义的枚举类默认继承于java.lang.enum类 package com.ran; import java.util.concurrent.*; import java.util.concurrent.locks.ReentrantLock; public class ran { public static ...
  • 一、枚举类型 1.使用枚举类型设置常量语法  public enun Constants{ ... enum是定义枚举类型关键字,constant(常量),当需要在程序中使用该常量时,可以使用Constants.Constants_A表示。 2.操作枚举类型的成
  • Java 枚举类型

    2018-06-24 20:48:09
    }其中,enum是定义枚举类型关键字。当需要在程序中使用该常量时,可以使用Constants.Constants_A来表示。 枚举类型较传统定义常量的方式,除了具有参数类型检测的优势之外,还具有其他方面的优势。 ...
  • 枚举、typedef关键字

    千次阅读 2015-06-29 01:11:36
    1)枚举类型介绍及定义 目前为止接触到的数据类型: 基本数据类型 指针类型 空类型 void 构造类型 数组、结构体 枚举类型 a、枚举类型枚举类型定义的一般形式: enum 枚举类型名{ 值1, 值2, ... 值n }; 在枚举值...
  • :Extern ―C‖是由C++提供的一个连接交换指定符号,用于告诉C++这段代码是C函数。这是因为C++编译后库中函数名会变得很长,与C生成的不一致,造成C++...使用时在前面加上extern ―c‖ 关键字即可。可以用一
  • (Java)定义一个枚举类型

    千次阅读 2020-02-18 23:16:50
    Java 有两种方式定义新类型:类和接口。对于大部分面向对象编程来说,这两种方法够了,但是对于一些特殊情况比如:想定义一个 Color 类,它只能有 ...可以使用关键字 enum 定义枚举类型: [public] enum 枚举类型{ ...
  • 相关文章链接 : 1.【嵌入式开发】C语言 指针数组 多维数组 2.【嵌入式开发】C语言 命令行参数 函数指针 ... 3.... 4.... 5.【C语言】 C 语言 关键字分析 ( 属性关键字 | 常量关键字 | 结构体关键字 | 联合体关键字 ...
  • c enum 枚举关键字

    千次阅读 2014-12-11 10:43:02
    一、枚举类型的使用方法 一般的定义方式如下: enum enum_type_name { ENUM_CONST_1, ENUM_CONST_2, ... ENUM_CONST_n } enum_variable_name; 注意:enum_type_name 是自定义的一种数据数据类型名,而...
  • java关键字之enum枚举类型浅析

    千次阅读 2016-11-29 15:58:49
    在很长的一段时间里面,在java的使用中,我都没有使用到枚举类型,一是因为之前压根就没有了解过,二就是在一般的开发中很...在没有使用枚举类型的时候,我是这样定义一个常量的: priavte static final String TIME;
  • 一、枚举类型介绍及定义 在实际问题中有许多可能出现的属性有固定的值,例如一年的12个月,十二生肖,一年四季等等。   因此C语言中提供了一种称为“枚举”的类型,在“枚举”的定义中列举出所有可能的值,...
  • 常量可以是任何的基本数据类型,比如整数常量、浮点常量、字符常量,或字符串字面值,也有枚举常量。 常量就像是常规的变量,只不过常量的值在定义后不能进行修改。 常用的一些常量表示,如: 名称 值 含义 ...
  • 深入理解Java枚举类型(enum)

    万次阅读 多人点赞 2017-05-13 18:27:14
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ... 出自【zejian的博客】 关联文章: 深入理解Java类型信息...深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解
  • 一、关于定义和声明声明: 例: extern int i; extern int arr[ ];告诉编译器,已经定义了一个变量名,但是不分配空间,声明可以出现多次。定义: 例: int i const int i = 0(定义的同时初始化...二、重要关键字:1.a
  • 枚举类型是Java 5中新增特性的一部分,它是一种特殊的数据类型,之所以特殊是因为它既是一种类(class)类型却又比类类型多了些特殊的约束,但是这些约束的存在也造就了枚举类型的简洁性、安全性以及便捷性。...
  • 主要介绍了Java编程中枚举类型定义与使用,简单讲解了enum关键字与枚举类的用法,需要的朋友可以参考下
  • 复杂类型关键字

    2021-03-14 12:27:13
    struct:结构体声明。 union:联合体声明。...enum:枚举声明。 typedef:声明类型别名。 sizeof:得到特定类型或特定类型变量的大小。 inline:内联函数用于取代宏定义,会在任何调用它的地方展开。
  • 1、 C#中的常量用constant标定,不能改变或赋值; 2、枚举类型 ...将枚举类型的声明到命名空间的下面,类的上面,所有命名空间下面的类都可以使用此枚举类型枚举类型就是一个简单的变量类型。 例如: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 103,079
精华内容 41,231
关键字:

定义枚举类型关键字