导航
我们为什么需要Java语法?
程序语言,就是一种用来与机器交流的语言,和中文、英语、日语一样,每种程序语言都有着自己的语法,掌握了这些基础语法,就能与机器进行正常的沟通交流。而进行写英语作文一样写出更复杂的代码,也是都基于基础语法的。Java基础语法,就是Java体系万丈高楼的基石,基石不牢,万丈高楼亦可平。基础语法虽不难但也得认真对待,于细微之处见真章。好在高级程序语言的基础语法基本类似,真正理解了其中一种语言的基础语法,其他语言便可以很快上手。
标识符
Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
关于 Java 标识符,有以下几点需要注意:
- 所有的标识符都应该以字母(A-Z 或者 a-z),美元符($)、或者下划线(_)开始
- 首字符之后可以是字母(A-Z 或者 a-z),美元符($)、下划线(_)或数字的任何字符组合
- 关键字不能用作标识符
- Java 是大小写敏感的,这就意味着标识符 Hello 与 hello 是不同的。
- 合法标识符举例:age、$salary、_value、__1_value
- 非法标识符举例:123abc、-salary
基本命名规则
起名字,确实是一个很让人头痛的问题。命名时,我们除了需要做到见词知意外,还需要遵守以下几个基本规则:
- 类名:类名的首字母应该大写。如果类名由若干单词组成,那么每个单词的首字母应该大写,例如 MyFirstJavaClass 。
- 方法名:所有的方法名都应该以小写字母开头。如果方法名含有若干单词,则后面的每个单词首字母大写,如eatFood()。
- 源文件名:源文件名必须和被public修饰的类名相同。(如果不相同则会导致编译错误)。
- 主方法入口:主程序入口写法为固定的: public static void main(String []args) ,Java程序从该方法开始执行。
关键字
关键字,也被叫为保留字。(此处又想吐槽IT业内对同一个东西有多个名词称呼的问题)就是这些名字,已经被系统设计时就占用了,我们再取名时,就不能和关键字重名。
Java关键字如下表:
类别 | 关键字 | 说明 |
---|---|---|
访问控制 | private | 私有的 |
protected | 受保护的 | |
public | 公共的 | |
default | 默认 | |
类、方法和变量修饰符 | abstract | 声明抽象 |
class | 类 | |
extends | 扩充,继承 | |
final | 最终值,不可改变的 | |
implements | 实现(接口) | |
interface | 接口 | |
native | 本地,原生方法(非 Java 实现) | |
new | 新,创建 | |
static | 静态 | |
strictfp | 严格,精准 | |
synchronized | 线程,同步 | |
transient | 短暂 | |
volatile | 易失 | |
程序控制语句 | break | 跳出循环 |
case | 定义一个值以供 switch 选择 | |
continue | 继续 | |
default | 默认 | |
do | 运行 | |
else | 否则 | |
for | 循环 | |
if | 如果 | |
instanceof | 实例 | |
return | 返回 | |
switch | 根据值选择执行 | |
while | 循环 | |
错误处理 | assert | 断言表达式是否为真 |
catch | 捕捉异常 | |
finally | 有没有异常都执行 | |
throw | 抛出一个异常对象 | |
throws | 声明一个异常可能被抛出 | |
try | 捕获异常 | |
包相关 | import | 引入 |
package | 包 | |
基本类型 | boolean | 布尔型 |
byte | 字节型 | |
char | 字符型 | |
double | 双精度浮点 | |
float | 单精度浮点 | |
int | 整型 | |
long | 长整型 | |
short | 短整型 | |
变量引用 | super | 父类,超类 |
this | 本类 | |
void | 无返回值 | |
保留关键字 | goto | 是关键字,但不能使用 |
const | 是关键字,但不能使用 | |
null 空 |
基本数据类型
Java中数据类型的分为基本数据类型与引用数据类型。其中引用数据类型属于面向对象范围,将在面向对象篇章中整理。基本数据类型,一共有八个。数据类型图示如下:
基本数据类型的
数据类型 | 占用空间 | 最小值 | 最大值 | 默认值 |
---|---|---|---|---|
byte | 8位,1字节 | -128(-2^7) | 127(2^7-1) | 0 |
short | 16位,2字节 | -32768(-2^15) | 32767(2^15 - 1) | 0 |
int | 32位,4字节 | -2^31 | 2^31 - 1 | 0 |
long | 64位,8字节 | -2^63 | 2^63 - 1 | 0L |
float | 32位,4字节 | -2^128 | 2^128 | 0.0f |
double | 64位,8字节 | -2^1024 | 2^1024 | 0.0d |
char | 16位,2字节 | \u0000(即为0) | \uffff(即为65,535) | ‘u0000’ |
boolean | 4字节,布尔数组1字节,取决于JVM | false |
转义字符
Java语言支持一些特殊的转义字符序列。
符号 | 含义 |
---|---|
\n | 换行 (0x0a) |
\r | 回车 (0x0d) |
\f | 换页符(0x0c) |
\b | 退格 (0x08) |
\0 | 空字符 (0x20) |
\s | 字符串 |
\t | 制表符 |
" | 双引号 |
’ | 单引号 |
\ | 反斜杠 |
\ddd | 八进制字符 (ddd) |
\uxxxx | 16进制Unicode字符 (xxxx) |
运算符
算术运算符
算术运算符用在数学表达式中,它们的作用和在数学中的作用一样。下表列出了所有的算术运算符,表中我们设整数变量A的值为10,变量B的值为20。
运算符 | 描述 | 示例 |
---|---|---|
+ | 加法 - 相加运算符两侧的值 | A + B 等于 30 |
- | 减法 - 左操作数减去右操作数 | A – B 等于 -10 |
* | 乘法 - 相乘操作符两侧的值 | A * B等于200 |
/ | 除法 - 左操作数除以右操作数 | B / A等于2 |
% | 取余 - 左操作数除以右操作数的余数 | B%A等于0 |
++ | 自增: 操作数的值增加1 | B++ 或 ++B 等于 21 |
– | 自减: 操作数的值减少1 | B-- 或 --B 等于 19 |
自增自减
自增(++)自减(–)是种特殊的算术运算符。在运算结果不继续参与其他运算时,运算符++/–放在前面或后面效果一样,都是等效于自身+1或-1。
我们设:a = 10; b = 20;
a++ 与 ++a 都等效于 a = a + 1;计算完成后,a的值为11。
a-- 与 --a 都等效于 a = a - 1;计算完成后,a的值为9。
如果自增自减后,还要参与运算,则运算符放在前与放在后是不一样的。
前缀自增自减法(++a,–a)时: 先进行自增或者自减运算,再进行表达式运算。
后缀自增自减法(a++,a–)时: 先进行表达式运算,再进行自增或者自减运算。
int a = 10;
int b = 20;
int x = 2*++a;
int y = 2*b++;
System.out.println("自增运算符前缀运算后a="+a+",x="+x);
System.out.println("自增运算符后缀运算后b="+b+",y="+y);
---------------------------------------------------------
输出结果:
自增运算符前缀运算后a=6,x=12
自增运算符后缀运算后b=6,y=10
关系运算符
我们设整数变量A的值为10,变量B的值为20。
运算符 | 描述 | 示例 |
---|---|---|
== | 检查如果两个操作数的值是否相等,如果相等则条件为真。 | ( A == B )为false |
!= | 检查如果两个操作数的值是否相等,如果值不相等则条件为真。 | ( A != B )为true |
> | 检查左操作数的值是否大于右操作数的值,如果是那么条件为真。 | ( A> B )为false |
< | 检查左操作数的值是否小于右操作数的值,如果是那么条件为真。 | ( A <B )为true |
>= | 检查左操作数的值是否大于或等于右操作数的值,如果是那么条件为真。 | ( A> = B )为false |
<= | 检查左操作数的值是否小于或等于右操作数的值,如果是那么条件为真。 | ( A <= B )为true |
位运算符
Java定义了位运算符,应用于整数类型(int),长整型(long),短整型(short),字符型(char),和字节型(byte)等类型。
我们设整数变量A的值为60,变量B的值为13。
运算符 | 描述 | 示例 |
---|---|---|
& | 如果相对应位都是1,则结果为1,否则为0 | (A&B),得到12,即0000 1100 |
| | 如果相对应位都是 0,则结果为 0,否则为 1 | (A | B)得到61,即 0011 1101 |
^ | 如果相对应位值相同,则结果为0,否则为1 | (A ^ B)得到49,即 0011 0001 |
〜 | 按位取反运算符翻转操作数的每一位,即0变成1,1变成0。 | (〜A)得到-61,即1100 0011 |
<< | 按位左移运算符。左操作数按位左移右操作数指定的位数。 | A << 2得到240,即 1111 0000 |
>> | 按位右移运算符。左操作数按位右移右操作数指定的位数。 | A >> 2得到15即 1111 |
>>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移,移动得到的空位以零填充。 | A>>>2得到15即0000 1111 |
A = 0011 1100
B = 0000 1101
-----------------
则:
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011
逻辑运算符
我们设变量A为true,变量B为false。
运算符 | 描述 | 示例 |
---|---|---|
& | 与- 当且仅当两个操作数都为true,结果才为true,否则为false。 | ( A & B )为false |
| | 或 - 当两个操作数中有一个为true,结果就为true。 | ( A | B )为true |
&& | 短路与 - 只要有一个操作数为false,直接返回结果为false。 | ( A && B )为false |
| | | 短路或 - 只要有一个操作数为true,直接返回结果为true。 | ( A | | B )为true |
! | 非 - 用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符的结果为false。 | ! B 为true |
^ | 异或 - 两个操作符相同为false,不同为true。 | ( A ^ B )为false |
短路与、短路或
在Java中,需要注意“短路与、短路或”虽然最终结果和“与、或”相同,但是计算过程是有差异的。短路的含义,就是当从判断第一个操作符就可以知道结果时,就不会再执行第二个操作符的语句。而使用与、或的情况下,是会执行的。举一个例子对比一下:
//短路与
int a = 5;
boolean b = (a<4) && (a++<10);
System.out.println("使用短路逻辑运算符的结果为:"+b);
System.out.println("a的结果为:"+a);
--------------
输出结果为:
使用短路逻辑运算符的结果为:false
a的结果为:5
//与
int a = 5;
boolean b = (a<4) & (a++<10);
System.out.println("使用短路逻辑运算符的结果为:"+b);
System.out.println("a的结果为:"+a);
--------------
输出结果为:
使用短路逻辑运算符的结果为:false
a的结果为:6
赋值运算符
下面是Java语言支持的赋值运算符:
运算符 | 描述 | 示例 |
---|---|---|
= | 简单的赋值运算符,将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
+ = | 加和赋值操作符,它把左操作数和右操作数相加赋值给左操作数 | C + = A等价于C = C + A |
- = | 减和赋值操作符,它把左操作数和右操作数相减赋值给左操作数 | C - = A等价于C = C - A |
* = | 乘和赋值操作符,它把左操作数和右操作数相乘赋值给左操作数 | C * = A等价于C = C * A |
/ = | 除和赋值操作符,它把左操作数和右操作数相除赋值给左操作数 | C / = A,C 与 A 同类型时等价于 C = C / A |
(%)= | 取模和赋值操作符,它把左操作数和右操作数取模后赋值给左操作数 | C%= A等价于C = C%A |
<< = | 左移位赋值运算符 | C << = 2等价于C = C << 2 |
>> = | 右移位赋值运算符 | C >> = 2等价于C = C >> 2 |
&= | 按位与赋值运算符 | C&= 2等价于C = C&2 |
^ = | 按位异或赋值操作符 | C ^ = 2等价于C = C ^ 2 |
| = | 按位或赋值操作符 | C | = 2等价于C = C | 2 |
字符串连接符
Java中有一个非常快捷的将两个字符串连接起来的运算符,就是:+ ,参与 + 运算的变量中有一个为字符串,那么+就不再代表相加的意思, 而是表示字符串连接,就算参与运算的另一个变量不是变量而是数值型,连接结果依旧会为字符串类型。
运算符 | 描述 | 示例 |
---|---|---|
+ | 字符串连接符,相加结果为字符串类型 | “2” + 2 = “22” |
多个+运算时,从左往右进行计算,如果同时有字符串和数值型进行计算时,要注意上什么时候计算结果变为了字符串类型。举一个例子,方便理解:
System.out.println(1+2+3);
System.out.println("1"+2+3);
System.out.println(1+"2"+3);
System.out.println(1+2+"3");
----------------------------------
输出结果为:
6 //数值类型
123 //字符串类型
123 //字符串类型
33 //字符串类型
条件运算符(?:)
条件运算符也被称为三元运算符,该运算符比较特殊,是Java中唯一的三元运算符,其他运算符都是二元,条件运算符的运算规则如下:
运算符 | 描述 | 示例 |
---|---|---|
? : | ?前的操作数为true时,则返回:前的操作数,否则返回:后的操作数 | ( 1 == 1 ) ?2:3,返回值为2 |
操作数可以是一个数值,也可以是表达式。需要注意的是,条件运算符判断第一个操作数后,根据判断结果去选择执行:前、后的操作数,不会都执行。举例:
int a = 10;
int b = ( a == 11 ) ? ( ++a ) : ( --a ) ;
System.out.println("运行后a的值为:"+a);
System.out.println("运行后b的值为:"+b);
----------------------------------
输出结果:
运行后a的值为:9 //如果++a也运行了,a的值应该会为10。证明不会运行。
运行后a的值为:9
instanceof 运算符
该操作符用于判断操作对象是否是某一个特定的类型(类类型或接口类型)。
运算符 | 描述 |
---|---|
instanceof | 判断操作对象是否是某一个特定的类型 |
示例:
String name = "HHM";
boolean result = name instanceof String;
System.out.println("result:"+result );
----------------------------------
输出结果:
result:true // 由于 name 是 String 类型,所以返回真
class Animal {}
public class Cat extends Animal {
public static void main(String[] args){
Animal a = new Cat();
boolean result = a instanceof Cat;
System.out.println("result:"+result );
}
}
输出结果:
result:true
运算符优先级
当写比较复杂的判断条件等情况的时候,一长串的运算符执行顺序是怎么样的呢?这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中,运算符优先级不同会导致最后得出的结果差别甚大。下表列出了运算符的优先级,数字小的,优先级高,先执行。
优先级 | 运算符 | 结合性 |
---|---|---|
1 | () [] . (点操作符) | 左到右 |
2 | + + - !〜 | 从右到左 |
3 | * /% | 左到右 |
4 | + - | 左到右 |
5 | >> >>> << | 左到右 |
6 | >> = << = | 左到右 |
7 | == != | 左到右 |
8 | & | 左到右 |
9 | ^ | 左到右 |
10 | | | 左到右 |
11 | && | 左到右 |
12 | | | | 左到右 |
13 | ?: | 从右到左 |
14 | = + = - = * = / =%= >> = << =&= ^ = |= | 从右到左 |
但建议在写复杂的运算逻辑时,多用 ( ) ,将想要先进行运算的表达式括起来先执行,这样不仅可以不用为优先级排序而头痛,还可以增强可读性。
类型转换
在日常开发过程中,常有需要将一些数据类型相互转换,然后再进行计算的问题。这时就需要涉及类型转换的问题。类型转换大致分为两类:自动类型转换 与 强制类型转换。
数据类型转换时有如下规则:
- 不能对boolean类型进行类型转换。
- 不能把对象类型转换成不相关类的对象。
- 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
- 转换过程中可能导致溢出或损失精度。
自动类型转换
进行自动类型转换,需满足转换前的数据类型的容量(取值范围)要低于转换后的数据类型,如long型就可以自动转换为float型。
float a = 11223344L; // √ , 11223344L 为long类型,可以转换
long b = 11.22f; // × , 11.22f 为float类型,不可以转为long类型
特例:我们输入的整数,实际就是int类型,可以直接赋值给byte类型,但不能超过byte的容量范围。这里其实也进行了数据类型的转换,可以看作是进行了自动类型转换,也可以看作进行了隐式的强制类型转换。Java这种设计并不是莫名其妙想搞特例,而是为了方便日常编程。
byte c = 127; // √ , 127 为 int类型,但可以赋值给byte
byte d = 128; // × , 128 为 int类型,但超出了byte范围
强制类型转换
当我们需要把容量大的数据类型转换为容量小的数据类型时,就需要使用强制类型转换。转换实现如下:
int a = 123;
byte b = (byte)a;//强制类型转换为byte
System.out.println("int强制类型转换为byte后的值等于="+b);
--------------------------------------------
输出结果为:
int强制类型转换为byte后的值等于=123
精度丢失问题
在浮点数到整数的强制转换过程中,是通过舍弃小数得到,而不是四舍五入,举例:
double a = 3.14f;
int b = (int)a;
System.out.println("b = " + b);
--------------------------------------------
输出结果为:
b = 3 // 精度损失,舍弃小数,而不是四舍五入
溢出问题
进行强制类型转换时,我们需要格外注意一些溢出问题:
1.超出容量范围造成溢出。这种需要避免,不能进行这样的类型转换。
int a = 128;
byte b = (byte)a;
System.out.println("b = " + b);
--------------------------------------------
输出结果为:
b = -128 // 因为128超出了byte范围,造成溢出
2.计算过程中造成溢出,需要在计算前进行数据类型转换。
int a = 100000000;
int b = a*20; // 范围内,未溢出情况
int c = a*30; // 超出范围,溢出
long d = a*30; // 计算时已超出范围,再赋值给容量大的类型也为时已晚
long e = (long)a*30; // 先进行强制数据类型转换,保证计算结果为容量更大的类型
long f = a*30L; // 先声明其中一个参与计算的数字为容量更大的类型
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println("d = " + d);
System.out.println("e = " + e);
System.out.println("f = " + f);
--------------------------------------------
输出结果为:
b = 2000000000
c = -1294967296
d = -1294967296
e = 3000000000
f = 3000000000
流程控制语句
流程控制语句是用来控制程序中各语句执行顺序的语句, 可以把语句组合成能完成一定
功能的小逻辑模块。
其流程控制方式采用结构化程序设计中规定的三种基本流程结构, 即: 顺序结构、 选择
结构和循环结构, 如下图所示:
顺序结构
Java代码,都是从上至下,一行一行按顺序运行的,这就时顺序结构。
选择结构
有些时候,我们需要有选择地执行或不执行某些特定的语句,这时候我们就需要选择结构。
if else 语句
最基本的 if 语句包含一个布尔表达式和一条或多条语句。如果布尔表达式为true则紧跟的语句将被执行,否则跳过。在此基础上可以使用else,else后紧跟的语句将在布尔表达式为false时执行,否则跳过。并且可以使用else if,在第一个布尔表达式为false时,进一步进行另一个布尔表达式的判断。当然,if else后面紧跟的语句可以为任何语句,包括if else语句。
if语句语法格式如下:
if(布尔表达式)
{
//如果布尔表达式为true将执行的语句,否则将跳过
}
if else语句语法格式如下:
if(布尔表达式){
//如果布尔表达式的值为true将执行的语句,否则将跳过
}else{
//如果布尔表达式的值为false将执行的语句,否则将跳过
}
if else if else语句语法格式如下:( 需要注意Java中else if中间是有空格的,有些编程语言里是连着的:elseif )
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码,否则将跳过
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码,否则将跳过
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码,否则将跳过
}else {
//如果以上布尔表达式都不为true执行代码,否则将跳过
}
嵌套的 if…else 语句语法格式如下:
if(布尔表达式 1){
如果布尔表达式 1的值为true执行代码
if(布尔表达式 2){
如果布尔表达式 2的值为true执行代码
}
}
switch case 语句
使用if else if else语句,特别时当选择条件过多时,会显得代码十分复杂且累赘。这时我们可以使用Java提供的另一种选择语句来达成相同的目的:switch case语句。
switch case 语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。switch case 语法格式如下:
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
switch case 语句有如下规则:
-
switch 语句中的变量类型可以是: byte、short、int 或者 char。从 Java SE 7 开始,switch 支持字符串 String 类型了,同时 case 标签必须为字符串常量或字面量。
-
switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
-
case 语句中的值的数据类型必须与变量的数据类型相同,而且只能是常量或者字面常量。
-
当变量的值与 case 语句的值相等时,那么 case 语句之后的语句开始执行,直到 break 语句出现才会跳出 switch 语句。
-
当遇到 break 语句时,switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现,程序会继续执行下一条 case 语句,直到出现 break 语句。
-
switch 语句可以包含一个 default 分支,该分支一般是 switch 语句的最后一个分支(可以在任何位置,但建议在最后一个)。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
循环结构
顺序结构的程序语句只能被执行一次。如果想要同样的操作执行多次,,就需要使用循环结构。
while 循环语句
while是最基本的循环,它的语法格式为:
while( 布尔表达式 ) {
//循环中被执行的语句 只要布尔表达式为 true,循环就会一直执行下去。
}
do…while 循环语句
do…while 循环和 while 循环相似,不同的是,do…while 循环至少会执行一次,在第一次循环完成后再判断尔表达式是否为true,以决定是否进入下一次循环。do…while 的语法格式如下:
do {
//循环中被执行的语句 如果布尔表达式为 true,循环就会一直执行下去。
}while(布尔表达式);
for 循环语句
虽然所有循环结构都可以用 while 或者 do…while表示,但 Java 提供了另一种语句 —— for 循环,使一些循环结构变得更加简单。
for循环执行的次数是在执行前就确定的。语法格式如下:
for(初始化; 布尔表达式; 更新) {
//循环中被执行的语句 如果布尔表达式为 true,循环就会一直执行下去。
}
实例:
for(int x = 1; x < 10; x++) {
System.out.print( x );
System.out.print( "," );
}
-------------------------------------------
输出结果为:
1,2,3,4,5,6,7,8,9,
关于 for 循环有以下几点说明:
- 最先执行初始化步骤。可以声明一种类型,但可初始化一个或多个循环控制变量,也可以是空语句。
- 然后,检测布尔表达式的值。如果为 true,循环体被执行。如果为false,循环终止,开始执行循环体后面的语句。
- 执行一次循环后,更新循环控制变量。
- 再次检测布尔表达式。循环执行上面的过程。
Java 增强 for 循环,foreach
Java5 引入了一种主要用于数组的增强型 for 循环。Java 增强 for 循环语法格式如下:
for(type element: array)
{
//代码句子
}
在声明语句中,声明的变量是来循环取用数组中的元素,声明的变量并不是数组元素本身,所有对声明的变量的修改等操作,并不会影响数组本身。实例:
public class Test {
public static void main(String[] args){
int [] numbers = {10, 20, 30, 40, 50};
//尝试修改
System.out.print("尝试修改:");
for(int x : numbers ){
x = x*10;
System.out.print(x); //只是修改了该代码块中的x,数组实际未改变
System.out.print(",");
}
System.out.print("\n");
//数组实际
System.out.print("数组实际的值:");
for(int x : numbers ){
System.out.print( x );
System.out.print(",");
}
}
}
-------------------------------------------
输出结果为:
尝试修改:100,200,300,400,500,
数组实际的值:10,20,30,40,50,
break与continue
break 主要用在循环语句或者 switch 语句中,用来跳出整个语句块,并且继续执行该循环下面的语句。
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。在 for 循环中,continue 语句使程序立即跳转到更新语句。在 while 或者 do…while 循环中,程序立即跳转到布尔表达式的判断语句。
枚举
Java 5.0引入了枚举,枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的 bug。
例如,我们为果汁店设计一个程序,它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。实例:
class FreshJuice {
enum FreshJuiceSize{ SMALL, MEDIUM , LARGE }
FreshJuiceSize size;
}
public class FreshJuiceTest {
public static void main(String []args){
FreshJuice juice = new FreshJuice();
juice.size = FreshJuice.FreshJuiceSize.MEDIUM; //只能为enum中设定的SMALL, MEDIUM , LARGE
}
}
注释
类似于 C/C++,Java 也支持单行以及多行注释。注释中的字符将被 Java 编译器忽略,不会编译为字节码。单行注释使用 // ,多行使用 /* /。除此之外,还有文档注释,以 /* 开始,以 */结束,主要用于对编写的类、变量和方法进行说明,再使用这些类、变量和方法时,就可以看见这些注释。示例:
// System.out.println("Hello World"); 单行注释,被注释的代码不会编译,也不会执行
/* 多
* 行
* 注
* 释
*/
/** 文档注释
* @author HHM
* @version 1.0
*/
写代码一定多写一点注释,用文字描述一下程序设计的关键点等,方便自己及他人阅读。
在结尾,欢快一点,我正好想起了一个程序员点菜段子,点了鱼香肉丝但不想要了。
程序员://鱼香肉丝
正常人:鱼香肉丝
我自知我文章写的不行,但如果这个有被这个段子笑到,给我点个赞吧,哈哈~