Enum类
Enum枚举类就是class,而且是一个不可以被继承的final类。(后面均用Color举例)。
其枚举值(RED,BLUE...)都是Color类型的类静态常量,我们可以通过下面的方式来得到Color枚举类的一个实例:
Color c=Color.RED;
注意:这些枚举值都是public static final的,也就是我们经常所定义的常量方式,因此枚举类中的枚举值最好全部大写。
1、即然枚举类是class,当然在枚举类型中有构造器,方法和数据域。但是,枚举类的构造器有很大的不同,不能使用public的构造函数,只能使用private的构造函数,这样可以保证外部代码无法新构造枚举类的实例。
2.所有枚举值都是public , static , final的。注意这一点只是针对于枚举值,我们可以和在普通类里面定义变量一样定义其它任何类型的非枚举变量,这些变量可以用任何你想用的修饰符。
3.Enum默认实现了https://www.wendangku.net/doc/0a10092910.html,parable接口。
4.Enum覆载了了toString方法,因此我们如果调用
Color.Blue.toString()默认返回字符串”Blue”.
5.Enum提供了一个valueOf方法,这个方法和toString方法是相对应的。调用valueOf(“Blue”)将返回Color.Blue.因此我们在自己重写toString方法的时候就要注意到这一点,一把来说应该相对应地重写valueOf方法。
6.Enum还提供了values方法,这个方法使你能够方便的遍历所有的枚举值。
7.Enum还有一个oridinal的方法,这个方法返回枚举值在枚举类种的顺序,这个顺序根据枚举值声明的顺序而定,这里Color.RED.ordinal(); //返回结果:0
Color.BLUE.ordinal(); //返回结果:1
8.equals()方法:比较两个枚举类对象的引用。
public final boolean equals(Object other) {
return this==other;
}
https://www.wendangku.net/doc/0a10092910.html,pareTo()方法: Enum实现了https://www.wendangku.net/doc/0a10092910.html,parable接口,因此可以比较象与指定对象的顺序。Enum中的compareTo返回的是两个枚举值的顺序之差。当然,前提是两个枚举值必须属于同一个枚举类,否则会抛出ClassCastException()异常。
https://www.wendangku.net/doc/0a10092910.html,pareTo(Color.BLUE); //返回结果-1
10.枚举类可以在switch语句中使用。
Color color=Color.RED;
switch(color){
case RED: System.out.println("it's red");break;
case BLUE: System.out.println("it's blue");break;
case BLACK: System.out.println("it's blue");break;
}
枚举类的定义:
例1:
public class TestEnum {
//只能是三种颜色之一
public enum Mycolor{red,blue,green};
//开我们家门只能是我和我的家人
public enum Mydor{me,myfamily};
public static void main(String[] agrs){
Mycolor m = Mycolor.blue;
Mydor d = Mydor.me;
switch (m){
case red:
System.out.println("red") ;
break;
case green:
System.out.println("green") ;;
break;
case blue:
System.out.println("blue");
break;
default:
System.out.println("default");
}
switch(d){
case me:
System.out.println("me");
break;
case myfamily:
System.out.println("myfamily");
break;
}
}
}
打印结果为:
blue
me
例2:
import java.util.EnumMap;
import java.util.EnumSet;
/*
* enum的应用,包括定义,遍历,switch,enumset,enummap
* Java枚举类型enum使用详解
* MyEnum可以存放多个枚举类型
*/
public class MyEnum {
// 定义一个enum枚举类型,包括实例ON,OFF
public enum State {
ON, OFF
}
public enum Country {
China, Japan
}
// 测试方法
public static void main(String[] args) {
System.out.println("******遍历枚举的值********");
// 遍历State枚举的值
for (State i : State.values()) {
System.out.print(https://www.wendangku.net/doc/0a10092910.html,()+" ");
}
System.out.println();
// 遍历Country枚举的值
for (Country j : Country.values()) {
System.out.print(https://www.wendangku.net/doc/0a10092910.html,()+" ");
}
System.out.println();
System.out.println("******switch与enum的结合使用********");
// switch与enum的结合使用
State s= State.OFF;
switch (s) {
case OFF:
System.out.println("OFF");
break;
case ON:
System.out.println("ON");
break;
}
System.out.println("******EnumSet的用法********");
/*
* 创建一个EnumSet ,并把State转换成EnumSet类型
*/
EnumSet
//遍历Enumset
for (State s1 : stateSet) {
System.out.println(s1);
}
System.out.println("******EnumMap的用法********");
/*
* 创建一个EnumMap ,并把State转换成EnumMap类型
* 并为EnumMap添加内容。
*/
EnumMap stateMap = new EnumMap(State.class);
stateMap.put(State.ON, "is on");
stateMap.put(State.OFF, "is off");
//遍历EnumMap
for (State s2 : State.values()) {
System.out.println(https://www.wendangku.net/doc/0a10092910.html,() + ":" + stateMap.get(s2));
}
System.out.println("==枚举可以这样被调用==");
// 枚举可以这样被调用
State state1 = MyEnum.State.OFF;
System.out.println(https://www.wendangku.net/doc/0a10092910.html,());
System.out.println("***把枚举State放进一个数组 ****");
//把枚举State放进一个数组
State[] state2 = MyEnum.State.values();
for (State state : state2) {
System.out.print(https://www.wendangku.net/doc/0a10092910.html,()+" ");
}
}
}
打印结果为:
******遍历枚举的值 ********
ON OFF
China Japan
******switch与enum的结合使用 ********
OFF
******EnumSet的用法********
ON
OFF
******EnumMap的用法********
ON:is on
OFF:is off
==枚举可以这样被调用==
OFF
***把枚举State放进一个数组 ****
ON OFF
枚举类型也可以直接以类的形式声明,可以跟类、接口同级别
例1:在enum中定义方法和变量,比如我们可以为Color增加一个方法随机返回一个颜色。
public enum EnumColor1 {
Red,
Green,
Blue;
//定义一个变量表示枚举值的数目。
private static int number = EnumColor1.values().length ;
/*
* 随机返回一个枚举值
* @return a random enum value.
*/
public static EnumColor1 getRandomColor(){
//获取当前时间以毫秒为单位,再出number取余。
long random = System.currentTimeMillis() % number;
switch ((int) random){
case 0:
return EnumColor1.Red;
case 1:
return EnumColor1.Green;
case 2:
return EnumColor1.Blue;
default : return EnumColor1.Red;
}
}
public static void main(String args[]){
EnumColor1 e =EnumColor1.getRandomColor();
System.out.println(e);
}
}
打印结果为:Green
该值是随机分配的。
可以看出这在枚举类型里定义变量和方法和在普通类里面定义方法和变量没有什么区别。唯一要注意的只是变量和方法定义必须放在所有枚举值定义的后面,否则编译器会给出一个错误。
例2:
public enum EnumToString {
Red,
Green,
Blue;
public static void main(String[] agrs){
EnumToString e = EnumToString.Blue;
System.out.println(e);
}
public String toString(){
switch (this){
case Red:
return"Color.Red";
case Green:
return"Color.Green";
case Blue:
return"Color.Blue";
default:
return"Unknow Color";
}
}
}
调用Color.Blue.toString()默认返回字符串”Blue”。
此时打印出来的是
Color.Blue
而不是
Blue.
可以看到toString确实是被重写了。一般来说在覆载toString的时候我们同时也应该覆载valueOf方法,以保持它们相互的一致性
每一个枚举值都可以定义方法。这样,我们前面重写toString的例子可以被改写成这样。
public enum EnumColor {
//每个枚举值都重写了toString方法。
Red {
public String toString(){
return"Color.Red";
}
},
Green {
public String toString(){
return"Color.Green";
}
},
Blue{
public String toString(){
return"Color.Blue";
}
};
public static void main(String[] agrs){
EnumColor e = EnumColor.Blue;
System.out.println(e);
}
}
例3:
public enum EnumTest {
//定义枚举值
FRANK("The given name of me"),
LIU("The family name of me");
private String context;
private String getContext(){
return this.context;
}
private EnumTest(String context){
this.context = context;
}
public static void main(String[] args){
//遍历整个枚举值。
for(EnumTest i:EnumTest.values()){
System.out.println(i+":"+i.getContext());
}
//来获取这个FRANK这个枚举值中定义了的类,
System.out.println(EnumTest.LIU.getDeclaringClass());
}
}
打印出的结果为:
FRANK:The given name of me
LIU:The family name of me
class https://www.wendangku.net/doc/0a10092910.html,.test.EnumTest
枚举类构造函数是使用。
(1)构造器只是在构造枚举值(方法和数据域)的时候被调用。(2)构造器只能私有private,绝对不允许有public构造器。这样可以保证外部代码无法新构造枚举类的实例。这也是完全符合情理的,因为我们知道枚举值是public static final的常量而已。但枚举类的方法和数据域可以允许外部访问。
例1:
public enum ColorEnum {
RED(255,0,0),BLUE(0,0,255),BLACK(0,0,0),
YELLOW(255,255,0),GREEN(0,255,0);
//构造枚举值,比如RED(255,0,0)
private ColorEnum(int rv,int gv,int bv){
this.redValue=rv;
this.greenValue=gv;
this.blueValue=bv;
}
public String toString(){
//覆盖了父类Enum的toString()
Return super.toString()+"("+redValue+","
+greenValue+","+blueValue+")";
}
//自定义数据域,private为了封装。
private int redValue;
private int greenValue;
private int blueValue;
public static void main(String args[]){
// Color colors=new Color(100,200,300); //wrong
ColorEnum color=ColorEnum.RED;
System.out.println(color); // 调用了toString()方法
}
}
打印的值为:RED(255,0,0)
例2:
public enum Enum {
Red("This is Red"),
Green("This is Green"),
Blue("This is Blue");
private String desc;
Enum(String desc){
this.desc = desc;
}
public String getDesc(){
return this.desc;
}
public static void main(String args[]){
Enum e =Enum.Red;
System.out.println(e.getDesc());
}
}
打印的值为:This is Red
实现接口
所有的枚举都继承自https://www.wendangku.net/doc/0a10092910.html,ng.Enum类。由于Java 不支持多继承,所以枚举对象不能再继承其他类。
interface Behaviour {
void print();
String getInfo();
}
public enum Color implements Behaviour{
RED("红色", 1), GREEN("绿色", 2),
BLANK("白色", 3), YELLO("黄色", 4);
// 成员变量
private String name;
private int index;
// 构造方法
private Color(String name, int index) {
https://www.wendangku.net/doc/0a10092910.html, = name;
this.index = index;
}
public static void main(String args[]){
Color c = Color.RED;
c.print();
}
//重写接口方法
public String getInfo() {
return https://www.wendangku.net/doc/0a10092910.html,;
}
//重写接口方法
public void print() {
System.out.println(this.index+":"+https://www.wendangku.net/doc/0a10092910.html,);
}
}
打印的值为:1:红色
使用接口组织枚举
public interface Food {
enum Coffee implements Food{
BLACK_COFFEE,DECAF_COFFEE,
LATTE,CAPPUCCINO
}
enum Dessert implements Food{
FRUIT, CAKE, GELATO
}
}
关于枚举集合的使用
private static String[] showCollectType = {"服务采集", "性能采集"};
/**
* 将采集类型编码
* @param collectType
* @return
*/
public static CollectType encodeCollectType(String collectType) { CollectType collType = CollectType.COLLSERVICE;
if(collectType.equals("服务采集")){
collType = CollectType.COLLSERVICE;
枚举类型的定义 在程序设计中,有时会用到由若干个有限数据元素组成的集合,如一周内的星期一到星期日七个数据元素组成的集合,由三种颜色红、黄、绿组成的集合,一个工作班组内十个职工组成的集合等等,程序中某个变量取值仅限于集合中的元素。此时,可将这些数据集合定义为枚举类型。因此,枚举类型是某类数据可能取值的集合,如一周内星期可能取值的集合为: { Sun,Mon,Tue,Wed,Thu,Fri,Sat} 该集合可定义为描述星期的枚举类型,该枚举类型共有七个元素,因而用枚举类型定义的枚举变量只能取集合中的某一元素值。由于枚举类型是导出数据类型,因此,必须先定义枚举类型,然后再用枚举类型定义枚举型变量。 enum <枚举类型名> { <枚举元素表> }; 其中:关键词enum表示定义的是枚举类型,枚举类型名由标识符组成,而枚举元素表由枚举元素或枚举常量组成。例如:enum weekdays { Sun,Mon,Tue,Wed,Thu,Fri,Sat }; 定义了一个名为 weekdays的枚举类型,它包含七个元素:Sun、Mon、Tue、Wed、Thu、Fri、Sat。在编译器编译程序时,
给枚举类型中的每一个元素指定一个整型常量值(也称为序号值)。若枚举类型定义中没有指定元素的整型常量值,则整型常量值从0开始依次递增,因此,weekdays枚举类型的七个元素Sun、Mon、Tue、Wed、Thu、Fri、Sat对应的整型常量值分别为0、1、2、3、4、5、6。 注意:在定义枚举类型时,也可指定元素对应的整型常量值。例如,描述逻辑值集合{TRUE、FALSE}的枚举类型boolean可定义如下: enum boolean { TRUE=1 ,FALSE=0 }; 该定义规定:TRUE的值为1,而FALSE的值为0。 而描述颜色集合{red,blue,green,black,white,yellow}的枚举类型colors可定义如下: enum colors {red=5,blue=1,green,black,white,yellow}; 该定义规定red为5 ,blue为1,其后元素值从2 开始递增加1。green、black、white、yellow的值依次为2、3、4、5。此时,整数5将用于表示二种颜色red与yellow。通常两个不同元素取相同的整数值是没有意义的。 枚举类型的定义只是定义了一个新的数据类型,只有用枚举类型定义枚举变量才能使用这种数据类型。 8.1.2枚举类型变量的定义
枚举类型是JDK5.0的新特征。Sun引进了一个全新的关键字enum来定义一个枚举类。下面就是一个典型枚举类型的定义: Java代码 1.public enum Color{ 2. RED,BLUE,BLACK,YELLOW,GREEN 3.} 显然,enum很像特殊的class,实际上enum声明定义的类型就是一个类。而这些类都是类库中Enum类的子类(https://www.wendangku.net/doc/0a10092910.html,ng.Enum
如果一个变量你需要几种可能存在的值,那么就可以被定义成为枚举类型。之所以叫枚举就是说将变量或者叫对象可能存在的情况也可以说是可能的值一一例举出来。 举个例子来说明一吧,为了让大家更明白一点,比如一个铅笔盒中有一支笔,但在没有打开之前你并不知道它是什么笔,可能是铅笔也可能是钢笔,这里有两种可能,那么你就可以定义一个枚举类型来表示它! enum box{pencil,pen};//这里你就定义了一个枚举类型的变量叫box,这个枚举变量内含有两个元素也称枚举元素在这里是pencil和pen,分别表示铅笔和钢笔。 这里要说一下,如果你想定义两个具有同样特性枚举类型的变量那么你可以用如下的两种方式进行定义! enum box{pencil,pen}; enum box box2;//或者简写成box box2; 再有一种就是在声明的时候同时定义。 enum {pencil,pen}box,box2; //在声明的同时进行定义! 枚举变量中的枚举元素系统是按照常量来处理的,故叫枚举常量,他们是不能进行普通的算术赋值的,(pencil=1;)这样的写发是错误的,但是你可以在声明的时候进行赋值操作! enum box{pencil=1,pen=2}; 但是这里要特别注意的一点是,如果你不进行元素赋值操作那么元素将会被系统自动从0开始自动递增的进行赋值操作,说到自动赋值,如果你只定义了第一个那么系统将对下一个元素进行前一个元素的值加1操作,例如 enum box{pencil=3,pen};//这里pen就是4系统将自动进行pen=4的定义赋值操作! 前面说了那么多,下面给出一个完整的例子大家可以通过以下的代码的学习进行更完整的学习! #include
Enum类 Enum枚举类就是class,而且是一个不可以被继承的final类。(后面均用Color举例)。 其枚举值(RED,BLUE...)都是Color类型的类静态常量,我们可以通过下面的方式来得到Color枚举类的一个实例: Color c=Color.RED; 注意:这些枚举值都是public static final的,也就是我们经常所定义的常量方式,因此枚举类中的枚举值最好全部大写。 1、即然枚举类是class,当然在枚举类型中有构造器,方法和数据域。但是,枚举类的构造器有很大的不同,不能使用public的构造函数,只能使用private的构造函数,这样可以保证外部代码无法新构造枚举类的实例。 2.所有枚举值都是public , static , final的。注意这一点只是针对于枚举值,我们可以和在普通类里面定义变量一样定义其它任何类型的非枚举变量,这些变量可以用任何你想用的修饰符。 3.Enum默认实现了https://www.wendangku.net/doc/0a10092910.html,parable接口。 4.Enum覆载了了toString方法,因此我们如果调用 Color.Blue.toString()默认返回字符串”Blue”. 5.Enum提供了一个valueOf方法,这个方法和toString方法是相对应的。调用valueOf(“Blue”)将返回Color.Blue.因此我们在自己重写toString方法的时候就要注意到这一点,一把来说应该相对应地重写valueOf方法。
6.Enum还提供了values方法,这个方法使你能够方便的遍历所有的枚举值。 7.Enum还有一个oridinal的方法,这个方法返回枚举值在枚举类种的顺序,这个顺序根据枚举值声明的顺序而定,这里Color.RED.ordinal(); //返回结果:0 Color.BLUE.ordinal(); //返回结果:1 8.equals()方法:比较两个枚举类对象的引用。 public final boolean equals(Object other) { return this==other; } https://www.wendangku.net/doc/0a10092910.html,pareTo()方法: Enum实现了https://www.wendangku.net/doc/0a10092910.html,parable接口,因此可以比较象与指定对象的顺序。Enum中的compareTo返回的是两个枚举值的顺序之差。当然,前提是两个枚举值必须属于同一个枚举类,否则会抛出ClassCastException()异常。 https://www.wendangku.net/doc/0a10092910.html,pareTo(Color.BLUE); //返回结果-1 10.枚举类可以在switch语句中使用。 Color color=Color.RED; switch(color){ case RED: System.out.println("it's red");break; case BLUE: System.out.println("it's blue");break; case BLACK: System.out.println("it's blue");break; } 枚举类的定义: 例1: public class TestEnum { //只能是三种颜色之一
枚举类可以实现接口,但要求枚举中的每个对象都必须覆写接口中的抽象方法。interface Print{ public String getColor() ; } enum Color implements Print{ RED{ public String getColor(){ return "红色" ; } },GREEN{ public String getColor(){ return "绿色" ; } },BLUE{ public String getColor(){ return "蓝色" ; } } ; } public class InterfaceEnumDemo{ public static void main(String args[]){ for(Color c:Color.values()){ System.out.print(c.getColor() + "、") ; } } }; 枚举类中可以定义抽象方法,但要求枚举中每个对象都必须覆写抽象方法enum Color { RED{ public String getColor(){ return "红色" ; } },GREEN{ public String getColor(){ return "绿色" ; } },BLUE{ public String getColor(){ return "蓝色" ; } } ; public abstract String getColor() ; } public class AbstractMethodEnum{
public static void main(String args[]){ for(Color c:Color.values()){ System.out.print(c.getColor() + "、") ; } } };
一、typedef声明新的类型名 结构体类型名较长、有些类型名不直观或不习惯、不喜欢?可不可以重命名呢? 用typedef声明新的类型名来代替已有的类型名 例如: 1)typedef float single; 2) typedef struct STU SD; 则“float x,y;”与“single x,y;”等价;
“p=(struct STU*)malloc(sizeof(struct STU));”与 “p=( SD *)malloc(sizeof(SD));”等价。 二、共用体 1、共用体类型的定义 当若干变量每次只使用其中之一时,可以采用“共用体”数据结构。共用体数据中各成员存放到同一段内存单元,设置这种数据类型的主要目的就是节省内存。 共用体类型需要用户自己定义,然后才能用之来定义相应类
型的变量、数组、指针等。 定义共用体类型的格式为: union 共用体类型名 { 数据类型1 成员名1; 数据类型2 成员名2; …… 数据类型n 成员名n; }; 【注意】在右花括号}的后面有一个语句结束符“分号”。
2、共用体变量、数组的定义 有三种方法可以定义共用体变量、数组:先定义共用体类型,然后定义变量、数组;同时定义共用体类型和变量、数组;定义无名称的共用体类型的同时定义变量、数组。 例如:①union GYT {char a[2]; int b; }; GYT x ,y[5]; ②union GYT
{ char a[2]; int b; }x ,y[5]; ③union { char a[2]; int b; }x ,y[5]; 上述三种方法完全等价。 【注意】(1)共用体变量所占内存单元数目等于占用单元数目最多的那个成员的单元数目。 (2)共用体变量各成员占据相同的起始地址,每一瞬时
java枚举类型 public class TestEnum { /*最普通的枚举*/ public enum ColorSelect { red, green, yellow, blue; } /* 枚举也可以象一般的类一样添加方法和属性,你可以为它添加静态和非静态的属性或方法,这一切都象你在一般的类中做的那样. */ public enum Season { // 枚举列表必须写在最前面,否则编译出错 winter, spring, summer, fall; private final static String location = "Phoenix"; public static Season getBest() { if (location.equals("Phoenix")) return winter; else return summer; } } /*还可以有构造方法*/ public enum Temp { /*通过括号赋值,而且必须有带参构造器和一属性跟方法,否则编译出错 * 赋值必须是都赋值或都不赋值,不能一部分赋值一部分不赋值 * 如果不赋值则不能写构造器,赋值编译也出错*/ absoluteZero(-459), freezing(32),boiling(212), paperBurns(451); private final int value; public int getValue() { return value; } //构造器默认也只能是private, 从而保证构造函数只能在内部使用 Temp(int value) { this.value = value; } } public static void main(String[] args) { /* * 枚举类型是一种类型,用于定义变量,以限制变量的赋值赋值时通过"枚举名.值"来取得相
#include
switch(loop) { case 1: pri=(enum color)i;//此处需要进行强制类型转换,否则报错 break; case 2: pri=(enum color)j;//此处需要进行强制类型转换,否则报错 break; case 3: pri=(enum color)k;//此处需要进行强制类型转换,否则报错 break; default: break; } switch(pri) { case red: printf("%-10s","red"); break; case yellow: printf("%-10s","yellow"); break; case blue: printf("%-10s","blue"); break; case white: printf("%-10s","white");
static 关键字修饰的成员就是类成员,前面已经介绍的类成员有类属性、类方法、静态初始化块等三个成分,static关键字不能修饰构造器。static修饰的类成员属于整个类,不是属于单个实例的。 在JA V A类里只能包含属性,方法,构造器,初始化块,内部类和枚举类等六种成员,也包含了接口,目前已经介绍了前面四种,其中static可以修饰属性,方法,初始化块,内部类和枚举类,以static修饰的成员就是类成员,类成员属于整个类,而不是属于单个对象。 我们要知道,当系统第一次准备使用该类时,系统会为该类属性分配内存空间,类属性开始生效,直到该类被卸载,该类的类属性怕占有的内存才被系统的垃圾回收机制回收。类属性生存范围几乎等同于该类的生存范围,当类初始化完成后,类属性也被初始化完成。 类属性既可通过类来访问,也可通过类的对象来访问。但通过类的对象来访问类属性时,实际上并不是访问该对象所具有的属性。当通过对象来访问类属性时,系统会在底层转换让为通过该类来访问类属性。 由于所有对象实际上并不保持类属性,类属性是由该类来保持的,同一个类的所有对象访问类属性时,实际上访问的是该类所持有的属性。因此从程序运行表面上来看,即可看到同一类的所有实例的类属性共享同一块内存区。 类方法也是类成员的一种,类方法也是属于类的,通常直接使用类作为调用类方法,但也可以使用对象来调用类方法。与类属性类似的,即使使用对象来调用类方法,其效果与采用类来调用类方法完全一样。 当使用实例来访问类成员时,实际依然委托给该类来访问类成员,因此即使某个实例为Null它也可以访问它所属类的类成员。
本来是不想写太多的概念性的东西的,但为了大家能更好的理解写出来的代码,所以还是麻烦下自已写出来。 看代码: public class NullAccessStatic { private static void test() { System.out.println("static修饰的类方法"); } //主方法入口 public static void main(String[] args) { //定义一个NullAccessStatic变量,其值为:null NullAccessStatic nas = null; //null对象调用所属类的静态方法 nas.test(); } }
C-枚举 在实际应用中,有的变量只有几种可能取值。如人的性别只有两种可能取值,星期只 有七种可能取值。在 C 语言中对这样取值比较特殊的变量可以定义为枚举类型。所谓枚举是指将变量的值一一列举出来,变量只限于列举出来的值的范围内取值。 定义一个变量是枚举类型,可以先定义一个枚举类型名,然后再说明这个变量是该枚 举类型。例如: enum weekday{sun,mon,tue,wed,thu,fri,sat}; 定义了一个枚举类型名 enum weekday,然后定义变量为该枚举类型。例如: enum weekday day; 当然,也可以直接定义枚举类型变量。例如: enum weekday{sun,mon,tue,wed,thu,fri,sat} day; 其中,sum,mon,…,sat 等称为枚举元素或枚举常量,它们是用户定义的标识符。 需要说明的有以下几点。 ① 枚举元素不是变量,而是常数,因此枚举元素又称为枚举常量。因为是常量,所 以不能对枚举元素进行赋值。 ② 枚举元素作为常量,它们是有值的,C 语言在编译时按定义的顺序使它们的值为 0,1,2,…。 在上面的说明中,sun 的值为 0,mon 的值为 1,…sat 的值为 6,如果有赋值语句 day=mon; 则 day 变量的值为 1。当然,这个变量值是可以输出的。例如: printf ("%d",day); 将输出整数 1。 如果在定义枚举类型时指定元素的值,也可以改变枚举元素的值。例如: enum weekday{sun=7,mon=1,tue,wed,thu,fri,sat}day; 这时,sun 为 7,mon 为 1,以后元素顺次加 1,所以 sat 就是 6 了。 ③ 枚举值可以用来作判断。例如: if (day==mon) {…} if (day>mon) {…} 枚举值的比较规则是:按其在说明时的顺序号比较,如果说明时没有人为指定,则第 一个枚举元素的值认作 0。例如,mon>sun,sat>fri。 C 语言教程 ?216? ④ 一个整数不能直接赋给一个枚举变量,必须强制进行类型转换才能赋值。例如: day=(enum weekday)2; 这个赋值的意思是,将顺序号为 2 的枚举元素赋给 day,相当于 workday=tue; 【例 11.6】从键盘输入一个整数,显示与该整数对应的枚举常量的英文名称。 # include void main( ) {
基本语法 编写Java程序时,应注意以下几点: ?大小写敏感:Java是大小写敏感的,这就意味着标识符Hello与hello是不同的。 ?类名:对于所有的类来说,类名的首字母应该大写。如果类名由若干单词组成,那么每个单词的首字母应该大写,例如 MyFirstJavaClass 。 ?方法名:所有的方法名都应该以小写字母开头。如果方法名含有若干单词,则后面的每个单词首字母大写。 ?源文件名:源文件名必须和类名相同。当保存文件的时候,你应该使用类名作为文件名保存(切记Java是大小写敏感的),文件名的后缀为.java。(如果文件名和类名不相同则会导致编译错误)。 ?主方法入口:所有的Java 程序由public static void main(String []args)方法开始执行。 Java标识符 Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。 关于Java标识符,有以下几点需要注意: ?所有的标识符都应该以字母(A-Z或者a-z),美元符($)、或者下划线(_)开始 ?首字符之后可以是字母(A-Z或者a-z),美元符($)、下划线(_)或数字的任何字符组合 ?关键字不能用作标识符 ?标识符是大小写敏感的 ?合法标识符举例:age、$salary、_value、__1_value ?非法标识符举例:123abc、-salary
Java修饰符 像其他语言一样,Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符: ?访问控制修饰符: default, public , protected, private ?非访问控制修饰符: final, abstract, strictfp 在后面的章节中我们会深入讨论Java修饰符。 Java变量 Java中主要有如下几种类型的变量 ?局部变量 ?类变量(静态变量) ?成员变量(非静态变量) Java数组 数组是储存在堆上的对象,可以保存多个同类型变量。在后面的章节中,我们将会学到如何声明、构造以及初始化一个数组。 Java枚举 Java 5.0引入了枚举,枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。 例如,我们为果汁店设计一个程序,它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。 实例
1.中断号定义 typedefenumIRQn { /****** Cortex-M4 Processor Exceptions Numbers ****************************************************************/ NonMaskableInt_IRQn = -14, /*!< 2 Non Maskable Interrupt */ MemoryManagement_IRQn = -12, /*!< 4 Cortex-M4 Memory Management Interrupt */ BusFault_IRQn = -11, /*!< 5 Cortex-M4 Bus Fault Interrupt */ UsageFault_IRQn = -10, /*!< 6 Cortex-M4 Usage Fault Interrupt */ SVCall_IRQn = -5, /*!< 11 Cortex-M4 SV Call Interrupt */ DebugMonitor_IRQn = -4, /*!< 12 Cortex-M4 Debug Monitor Interrupt */ PendSV_IRQn = -2, /*!< 14 Cortex-M4 Pend SV Interrupt */ SysTick_IRQn = -1, /*!< 15 Cortex-M4 System Tick Interrupt */ /****** STM32 specific Interrupt Numbers **********************************************************************/ WWDG_IRQn = 0, /*!< Window WatchDog Interrupt */ PVD_IRQn = 1, /*!< PVD through EXTI Line detection Interrupt */ TAMP_STAMP_IRQn = 2, /*!< Tamper and TimeStamp interrupts through the EXTI line */ RTC_WKUP_IRQn = 3, /*!< RTC Wakeup interrupt through the EXTI line */ FLASH_IRQn = 4, /*!< FLASH global Interrupt */ RCC_IRQn = 5, /*!< RCC global Interrupt */ EXTI0_IRQn = 6, /*!< EXTI Line0 Interrupt */ EXTI1_IRQn = 7, /*!< EXTI Line1 Interrupt */ EXTI2_IRQn = 8, /*!< EXTI Line2 Interrupt */ EXTI3_IRQn = 9, /*!< EXTI Line3 Interrupt */ EXTI4_IRQn = 10, /*!< EXTI Line4 Interrupt
自定义数据类型 结构体 结构体是程序员在程序中自定义的一种数据类型,在说明和使用之前必须先定义它,也就是构造它。定义一个结构体的语法格式如下: Struct 结构体类型名 { 成员1的数据类型名成员1名称; 成员2的数据类型名成员2名称; . . 成员n的数据类型名成员n名称; }结构体变量表={成员初始化}; 注意成员可以由若干个不同的数据类型组成,每个成员也可以是结构体,即可以嵌套定义。 例如: Struct student { Long num; Char name; Char sex; Float score; }; 已经定义的某种结构体类型可以视为一种标准的数据类型,它的使用方法与标准数据类型使用方法相同,可以用来定义变量、数组、指针。 结构体变量说明 结构体变量的说明在程序的变量说明部分给出,一般在结构定义之后,它的语法格式如下: Struct 结构类型名结构变量名表; 例如: Struct student stu; 指出了结构变量stu是student类型的变量,它由四个成员组成,每个成员的数据类型和名字都与student结构定义中给出的相同。系统完全按照结构定义时制定的内存模式为结构变量分配内存空间。 可以在定义结构体类型的同时给出结构体变量。 Struct student { Long num; Cha name[20]; Cha sex; Float score; }stu1,stu2; 这种形式与前面给出的结构定义和结构说明分开处理效果相同。
结构体成员访问 结构体成员是通过结构体变量名和成员名进行访问的,不能把他作为一个整体进行访问。其访问格式如下: 结构体变量名.成员名 其中运算符.是成员访问运算符,其运算级别是最高的,和圆括号运算符()、下标运算符[]是同一级别的。如果结构体成员是指针变量,则访问格式为: *https://www.wendangku.net/doc/0a10092910.html, 如果某个结构体变量的成员数据类型又是一个结构体,则访问方式为: 外层结构体变量名.外层成员名.内层成员名 可以在定义结构体变量的同时对结构体变量初始化。 {结构体成员}结构体变量={初始数据}; struct student { long num; char name[20]; char sex; float score; } stu1={200401L,"ZhangHong",'f',92.5f}; 对于嵌套的结构体类型数据,访问格式为: 结构体变量名1.结构体变量名2.成员名 结构体变量初始化的格式如下: struct 结构体名 {结构体成员}结构体变量={初始数据}; 初始数据类型必须与结构成员的数据类型相匹配,并且先后顺序一一对应赋值。 要对结构体变量的成员地址进行访问,其语法格式为: &结构体变量.成员名 当一个指针变量用来指向一个结构变量时,称为结构体指针变量。结构体指针变量中的值是所指向的结构体变量的首地址。 结构体指针变量: Struct 结构名*结构体指针变量名 Struct student *pstu; 必须先赋值后使用,把结构体变量的首地址赋给指针变量,不能把结构名或结构体变量名赋给指针变量。 pstu=&stu1; 结构体名和结构体变量是两个不同的概念,结构体名只能表示一个结构形式,编译系统并不对它分配内存空间,只有当某变量被说明为这种类型的结构时,才对该变量分配存储空间。这是因为结构体变量被定义后相当于标准数据类型被使用。 利用结构体指针变量访问成员如下: (*结构体指针变量).成员名 或者: 结构体指针变量->成员名 后一种形式较为方便,容易区分。
1. 枚举类的说明: * 1.枚举类的理解:类的对象只有有限个,确定的。我们称此类为枚举类* 2.当需要定义一组常量时,强烈建议使用枚举类 * 3.如果枚举类中只一个对象,则可以作为单例模式的实现方式。 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 + '\'' + '}'; } }
c#枚举(Enum)的用法及遍历方法 foreach (string s in Enum.GetNames(typeof(WallKind))) { WinFormTools.MsgBox(s); } 有人问怎样遍历Revit API中的枚举,遍历枚举是C#的语法功能。 来自MSDN 枚举可用来存储字符串与数字的值对,相当于一个对照表 常用方法:GetName(),GetValue(),Parse() using System; public class EnumTest { enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursda y, Friday }; enum BoilingPoints { Celcius = 100, Fahrenheit = 212 }; [FlagsAttribute] enum Colors { Red = 1, Green = 2, Blue = 4, Yellow = 8 }; public static void Main() { Type weekdays = typeof(Days); Type boiling = typeof(BoilingPoints); Console.WriteLine("The days of the week, and their corresponding valu es in the Days Enum are:"); foreach ( string s in Enum.GetNames(weekdays) ) Console.WriteLine( "{0,-11}= {1}", s, Enum.Format( weekdays, Enu m.Parse(weekdays, s), "d")); Console.WriteLine(); Console.WriteLine("Enums can also be created which have values that r epresent some meaningful amount."); Console.WriteLine("The BoilingPoints Enum defines the following item s, and corresponding values:"); foreach ( string s in Enum.GetNames(boiling) ) Console.WriteLine( "{0,-11}= {1}", s, Enum.Format(boiling, Enum.P arse(boiling, s), "d")); Colors myColors = Colors.Red | Colors.Blue | Colors.Yellow; Console.WriteLine();
第2章基本数据类型 本章介绍常量与变量的概念,以及C语言基本数据类型中的整型、字符型、实型数据的基本知识,各种不同数据类型之间的转换及混合运算。 2.1 数据概述 一个完整的计算机程序,至少应包含两方面的内容,一方面对数据进行描述,另一方面对操作进行描述。数据是程序加工的对象,数据描述是通过数据类型来完成的,操作描述则通过语句来完成。 C语言不仅提供了多种数据类型,还提供了构造更加复杂的用户自定义数据结构的机制。C语言提供的主要数据类型有: 1.基本类型:包括整型、字符型、实型(浮点型)和枚举类型 2.构造类型:包括数组、结构体和共用体类型 3.指针类型 4.空类型 其中整型、字符型、实型(浮点型)和空类型由系统预先定义,又称标准类型。 基本类型的数据又可分为常量和变量,它们可与数据类型结合起来分类,即为整型常量、整型变量、实型(浮点型)常量、实型(浮点型)变量、字符常量、字符变量、枚举常量、枚举变量。在本章中主要介绍基本数据类型(除枚举类型外),其它数据类型在后续章节中再详细介绍。 2.1.1 常量与符号常量 在程序执行过程中,其值不发生改变的量称为常量。常量区分为不同的类型,如68、0、-12为整型常量,3.14,9.8为实型常量,‘a’,‘b’,‘c’则为字符常量。常量即为常数,一般从其字面即可判别。有时为了使程序更加清晰和便于修改,用一个标识符来代表常量,即给某个常量取个有意义的名字,这种常量称为符号常量。如: 【例2-1】 #define PI 3.14 main( ) { float aera; aera=10*10*PI; printf(“aera=%f\n”,aera); }
/*通过getValue()取得相关枚举的值*/ System.out.println(t+"的值是"+t.getValue()); } } } 要求: (1)分析该程序,写出运行结果 【实验结果与分析】 图1 运行结果 分析:该程序主要应用了泛型和枚举的知识点。 2、编辑、编译、运行下面java程序 class Gen
public void setOb(T ob) { this.ob = ob; } public void showTyep() { System.out.println("T的实际类型是: " + ob.getClass().getName()); } } public class GenDemo { public static void main(String[] args){ //定义泛型类Gen的一个Integer版本 Gen
(一)枚举类型的定义 枚举类型是一种自定义类型,要使用枚举类型当然也要先说明枚举类型。 枚举类型的一般格式: (标识符1,标识符2,…,标识符n) 说明:①括号中的每一个标识符都称为枚举元素或枚举常量。 ②定义枚举类型时列出的所有枚举元素构成了这种枚举类型的值域(取值范围),也就是说,该类型的变量所有可能的取值都列出了。 例如,下列类型定义是合法的: type days=(sun,mon,tue,wed,thu,fri,sat); colors=(red,yellow,blue,white,black,green); 而下列类型定义是错误的(因为枚举元素非标识符): type colortype=('red','yellow','blue','white'); numbers=(1,3,5,7,9); ty=(for,do,while); (二)枚举类型变量 定义了枚举类型,就可以把某些变量说明成该类型。如: var holiday,workday:day; incolor:colors; 也可以把变量的说明与类型的定义合并在一起,如: var holiday,workday:(sun,mon,tue,wed,thu,fri,sat); incolor:(red,yellow,blue,white,black,green); (三)枚举类型的性质 ⒈枚举类型属于顺序类型 根据定义类型时各枚举元素的排列顺序确定它们的序号,第一个枚举元素的序号为0。例如:设有定义: type days=(sun,mon,tue,wed,thu,fri,sat); 则: ord(sun)=0,ord(mon)=1,ord(sat)=6;succ(sun)=mon,succ(mon)=tue, succ(fri)=sat;pred(mon)=sun,pred(tue)=mon,pred(sat)=fri。 应注意的是:枚举类型中的第一个元素无前趋,最后一个元素无后继。 ⒉对枚举类型只能进行赋值运算和关系运算