Java 修饰符

Java语言提供了很多修饰符，主要分为以下两类：

访问修饰符非访问修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。我们通过下面的例子来说明：

public class ClassName {// ...}private boolean myFlag;static final double weeks = 9.5;protected static final int BOXWIDTH = 42;public static void main(String[] arguments) {// 方法体}

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default(即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private: 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）

public: 对所有类可见。使用对象：类、接口、变量、方法

protected: 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。

我们可以通过以下表来说明访问权限：

默认访问修饰符-不使用任何关键字

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都是隐视声明为 public static final,而接口里的方法默认情况下访问权限为public。

如下例所示，变量和方法的声明可以不使用任何修饰符。

实例

String version = "1.5.1";boolean processOrder() {return true;}

私有访问修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为private的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为private。

声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

下面的类使用了私有访问修饰符：

public class Logger {private String format;public String getFormat() {return this.format;}public void setFormat(String format) {this.format = format;}}

实例中，Logger类中的format变量为私有变量，所以其他类不能直接得到和设置该变量值。为了是其它类能够操作该变量，定义了两个public方法：getFormat() (返回format值) 和 setFormat(String) (设置format值)。

公有访问修饰符-public

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

以下函数使用了公有访问控制：

public static void main(String[] arguments) {// ...}

Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。

受保护的访问修饰符-protected

protected 需要从以下两个点来分析说明：

子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；

子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。

接口及接口的成员变量和成员方法不能声明为 protected。 可以看看下图演示：

子类能访问protected修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

下面的父类使用了protected访问修饰符，子类重写了父类的openSpeaker()方法。

class AudioPlayer {protected boolean openSpeaker(Speaker sp) {// 实现细节}}class StreamingAudioPlayer extends AudioPlayer {protected boolean openSpeaker(Speaker sp) {// 实现细节}}

如果把 openSpeaker() 方法声明为 private，那么除了 AudioPlayer 之外的类将不能访问该方法。

如果把 openSpeaker() 声明为 public，那么所有的类都能够访问该方法。

如果我们只想让该方法对其所在类的子类可见，则将该方法声明为 protected。

访问控制和继承

请注意以下方法继承的规则：

父类中声明为 public 的方法在子类中也必须为 public。

父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。

父类中声明为 private 的方法，不能够被继承。

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

static 修饰符，用来修饰类方法和类变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

abstract 修饰符，用来创建抽象类和抽象方法。

synchronized 和 volatile 修饰符，主要用于线程的编程。

static 修饰符

静态变量：

static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

静态方法：

static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

对类变量和方法的访问可以直接使用classname.variablename和classname.methodname的方式访问。

如下例所示，static修饰符用来创建类方法和类变量。

public class InstanceCounter {private static int numInstances = 0;protected static int getCount() {return numInstances;}private static void addInstance() {numInstances++;}InstanceCounter() {InstanceCounter.addInstance();}public static void main(String[] arguments) {System.out.println("Starting with " +InstanceCounter.getCount() + " instances");for (int i = 0; i < 500; ++i){new InstanceCounter();}System.out.println("Created " +InstanceCounter.getCount() + " instances");}}

以上实例运行编辑结果如下:

Starting with 0 instancesCreated 500 instances

final 修饰符

final 变量：

final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。

final 修饰符通常和 static 修饰符一起使用来创建类常量。

public class Test{final int value = 10;// 下面是声明常量的实例public static final int BOXWIDTH = 6;static final String TITLE = "Manager";public void changeValue(){value = 12; //将输出一个错误}}

final 方法

父类中的final方法可以被子类继承，但是不能被子类重写。

声明final方法的主要目的是防止该方法的内容被修改。

如下所示，使用 final 修饰符声明方法。

public class Test{public final void changeName(){// 方法体}}

final 类

final 类不能被继承，没有类能够继承 final 类的任何特性。

public final class Test {// 类体}

abstract 修饰符

抽象类：

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

抽象类可以包含抽象方法和非抽象方法。

实例：

abstract class Caravan{private double price;private String model;private String year;public abstract void goFast(); //抽象方法public abstract void changeColor();}

抽象方法

抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

抽象方法的声明以分号结尾，例如：public abstract sample();。

实例：

public abstract class SuperClass{abstract void m(); //抽象方法}class SubClass extends SuperClass{//实现抽象方法void m(){.........}}

synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。

实例：

public synchronized void showDetails(){.......}

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

实例：

public transient int limit = 55; // 不会持久化public int b; // 持久化

volatile 修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

一个 volatile 对象引用可能是 null。

实例：

public class MyRunnable implements Runnable{private volatile boolean active;public void run(){active = true;while (active) // 第一行{// 代码}}public void stop(){active = false; // 第二行}}

通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。 如果第一行中缓冲区的 active 值被使用，那么在第二行的 active 值为 false 时循环不会停止。

但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止。

Java 运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

算术运算符关系运算符位运算符逻辑运算符赋值运算符其他运算符

算术运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。下表列出了所有的算术运算符。

表格中的实例假设整数变量A的值为10，变量B的值为20：

实例

下面的简单示例程序演示了算术运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：

public class Test {public static void main(String[] args) {int a = 10;int b = 20;int c = 25;int d = 25;System.out.println("a + b = " + (a + b) );System.out.println("a - b = " + (a - b) );System.out.println("a * b = " + (a * b) );System.out.println("b / a = " + (b / a) );System.out.println("b % a = " + (b % a) );System.out.println("c % a = " + (c % a) );System.out.println("a++ = " + (a++) );System.out.println("a-- = " + (a--) );// 查看 d++ 与 ++d 的不同System.out.println("d++ = " + (d++) );System.out.println("++d = " + (++d) );}}

以上实例编译运行结果如下：

a + b = 30a - b = -10a * b = 200b / a = 2b % a = 0c % a = 5a++ = 10a-- = 11d++ = 25++d = 27

自增自减运算符

1、自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。

实例：

public class selfAddMinus{public static void main(String[] args){int a = 3;//定义一个变量；int b = ++a;//自增运算int c = 3;int d = --c;//自减运算System.out.println("进行自增运算后的值等于"+b);System.out.println("进行自减运算后的值等于"+d);}}

运行结果为：

进行自增运算后的值等于4进行自减运算后的值等于2

解析：

int b = ++a; 拆分运算过程为: a=a+1=4; b=a=4, 最后结果为b=4,a=4

int d = --c; 拆分运算过程为: c=c-1=2; d=c=2, 最后结果为d=2,c=2

2、前缀自增自减法(++a,--a):先进行自增或者自减运算，再进行表达式运算。

3、后缀自增自减法(a++,a--):先进行表达式运算，再进行自增或者自减运算 实例：

实例：

public class selfAddMinus{public static void main(String[] args){int a = 5;//定义一个变量；int b = 5;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

关系运算符

下表为Java支持的关系运算符

表格中的实例整数变量A的值为10，变量B的值为20：

实例

下面的简单示例程序演示了关系运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

public class Test {public static void main(String[] args) {int a = 10;int b = 20;System.out.println("a == b = " + (a == b) );System.out.println("a != b = " + (a != b) );System.out.println("a > b = " + (a > b) );System.out.println("a < b = " + (a < b) );System.out.println("b >= a = " + (b >= a) );System.out.println("b <= a = " + (b <= a) );}}

以上实例编译运行结果如下：

a == b = falsea != b = truea > b = falsea < b = trueb >= a = trueb <= a = false

位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下：

A = 0011 1100B = 0000 1101-----------------A&B = 0000 1100A | B = 0011 1101A ^ B = 0011 0001~A= 1100 0011

下表列出了位运算符的基本运算，假设整数变量 A 的值为 60 和变量 B 的值为 13：

实例

下面的简单示例程序演示了位运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

public class Test {public static void main(String[] args) {int a = 60; /* 60 = 0011 1100 */ int b = 13; /* 13 = 0000 1101 */int c = 0;c = a & b; /* 12 = 0000 1100 */System.out.println("a & b = " + c );c = a | b; /* 61 = 0011 1101 */System.out.println("a | b = " + c );c = a ^ b; /* 49 = 0011 0001 */System.out.println("a ^ b = " + c );c = ~a;/*-61 = 1100 0011 */System.out.println("~a = " + c );c = a << 2;/* 240 = 1111 0000 */System.out.println("a << 2 = " + c );c = a >> 2;/* 15 = 1111 */System.out.println("a >> 2 = " + c );c = a >>> 2;/* 15 = 0000 1111 */System.out.println("a >>> 2 = " + c );}}

以上实例编译运行结果如下：

a & b = 12a | b = 61a ^ b = 49~a = -61a << 2 = 240a >> 2 = 15a >>> 2 = 15

逻辑运算符

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假

实例

下面的简单示例程序演示了逻辑运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

public class Test {public static void main(String[] args) {boolean a = true;boolean b = false;System.out.println("a && b = " + (a&&b));System.out.println("a || b = " + (a||b) );System.out.println("!(a && b) = " + !(a && b));}}

以上实例编译运行结果如下：

a && b = falsea || b = true!(a && b) = true

短路逻辑运算符

当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

实例：

public class LuoJi{public static void main(String[] args){int a = 5;//定义一个变量；boolean b = (a<4)&&(a++<10);System.out.println("使用短路逻辑运算符的结果为"+b);System.out.println("a的结果为"+a);}}

运行结果为：

使用短路逻辑运算符的结果为falsea的结果为5

解析：该程序使用到了短路逻辑运算符(&&)，首先判断 a<4 的结果为 false，则 b 的结果必定是 false，所以不再执行第二个操作 a++<10 的判断，所以 a 的值为 5。

赋值运算符

下面是Java语言支持的赋值运算符：

实例

面的简单示例程序演示了赋值运算符。复制并粘贴下面的Java程序并保存为Test.java文件，然后编译并运行这个程序：

public class Test {public static void main(String[] args) {int a = 10;int b = 20;int c = 0;c = a + b;System.out.println("c = a + b = " + c );c += a ;System.out.println("c += a = " + c );c -= a ;System.out.println("c -= a = " + c );c *= a ;System.out.println("c *= a = " + c );a = 10;c = 15;c /= a ;System.out.println("c /= a = " + c );a = 10;c = 15;c %= a ;System.out.println("c %= a = " + c );c <<= 2 ;System.out.println("c <<= 2 = " + c );c >>= 2 ;System.out.println("c >>= 2 = " + c );c >>= 2 ;System.out.println("c >>= 2 = " + c );c &= a ;System.out.println("c &= a = " + c );c ^= a ;System.out.println("c ^= a = " + c );c |= a ;System.out.println("c |= a = " + c );}}

以上实例编译运行结果如下：

c = a + b = 30

c += a = 40

c -= a = 30

c *= a = 300

c /= a = 1

c %= a = 5

c <<= 2 = 20

c >>= 2 = 5

c >>= 2 = 1

c &= a = 0

c ^= a = 10

c |= a = 10

条件运算符（?:）

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false

实例：

public class Test {public static void main(String[] args){int a , b;a = 10;// 如果 a 等于 1 成立，则设置 b 为 20，否则为 30b = (a == 1) ? 20 : 30;System.out.println( "Value of b is : " + b );// 如果 a 等于 10 成立，则设置 b 为 20，否则为 30b = (a == 10) ? 20 : 30;System.out.println( "Value of b is : " + b );}}

以上实例编译运行结果如下：

Value of b is : 30Value of b is : 20

instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

instanceof运算符使用格式如下：

( Object reference variable ) instanceof (class/interface type)

如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

下面是一个例子：

String name = "James";boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

如果被比较的对象兼容于右侧类型,该运算符仍然返回true。

看下面的例子：

class Vehicle {}public class Car extends Vehicle {public static void main(String[] args){Vehicle a = new Car();boolean result = a instanceof Car;System.out.println( result);}}

以上实例编译运行结果如下：

true

Java运算符优先级

当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。

例如，（1+3）＋（3+2）*2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。

再如，x = 7 + 3 * 2;这里x得到13，而不是20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 * 2得到6，然后再加7。

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

Java 循环结构 - for, while 及 do...while

顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,，就需要使用循环结构。

Java中有三种主要的循环结构：

while循环do…while循环for循环

在Java5中引入了一种主要用于数组的增强型for循环。

while 循环

while是最基本的循环，它的结构为：

while( 布尔表达式 ) {//循环内容}

只要布尔表达式为 true，循环就会一直执行下去。

实例：

public class Test {public static void main(String args[]) {int x = 10;while( x < 20 ) {System.out.print("value of x : " + x );x++;System.out.print("\n");}}}

以上实例编译运行结果如下：

value of x : 10value of x : 11value of x : 12value of x : 13value of x : 14value of x : 15value of x : 16value of x : 17value of x : 18value of x : 19

do…while 循环

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。

do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {//代码语句}while(布尔表达式);

注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

实例：

public class Test {public static void main(String args[]){int x = 10;do{System.out.print("value of x : " + x );x++;System.out.print("\n");}while( x < 20 );}}

以上实例编译运行结果如下：

value of x : 10value of x : 11value of x : 12value of x : 13value of x : 14value of x : 15value of x : 16value of x : 17value of x : 18value of x : 19

for循环

虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。

for循环执行的次数是在执行前就确定的。语法格式如下：

for(初始化; 布尔表达式; 更新) {//代码语句}

关于 for 循环有以下几点说明：

最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。执行一次循环后，更新循环控制变量。再次检测布尔表达式。循环执行上面的过程。

实例

public class Test {public static void main(String args[]) {for(int x = 10; x < 20; x = x+1) {System.out.print("value of x : " + x );System.out.print("\n");}}}

以上实例编译运行结果如下：

value of x : 10value of x : 11value of x : 12value of x : 13value of x : 14value of x : 15value of x : 16value of x : 17value of x : 18value of x : 19

Java 增强 for 循环

Java5 引入了一种主要用于数组的增强型 for 循环。

Java 增强 for 循环语法格式如下:

for(声明语句 : 表达式){//代码句子}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

实例

public class Test {public static void main(String args[]){int [] numbers = {10, 20, 30, 40, 50};for(int x : numbers ){System.out.print( x );System.out.print(",");}System.out.print("\n");String [] names ={"James", "Larry", "Tom", "Lacy"};for( String name : names ) {System.out.print( name );System.out.print(",");}}}

以上实例编译运行结果如下：

10,20,30,40,50,James,Larry,Tom,Lacy,

break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。

break 跳出最里层的循环，并且继续执行该循环下面的语句。

语法

break 的用法很简单，就是循环结构中的一条语句：

break;

实例：

public class Test {public static void main(String args[]) {int [] numbers = {10, 20, 30, 40, 50};for(int x : numbers ) {// x 等于 30 时跳出循环if( x == 30 ) {break;}System.out.print( x );System.out.print("\n");}}}

以上实例编译运行结果如下：

10

20

continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中，continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

语法

continue 就是循环体中一条简单的语句：

continue;

实例：

public class Test {public static void main(String args[]) {int [] numbers = {10, 20, 30, 40, 50};for(int x : numbers ) {if( x == 30 ) {continue;}System.out.print( x );System.out.print("\n");}}}

以上实例编译运行结果如下：

10204050

Java 条件语句 - if...else

一个 if 语句包含一个布尔表达式和一条或多条语句。

语法

if 语句的语法如下：

if(布尔表达式){//如果布尔表达式为true将执行的语句}

如果布尔表达式的值为 true，则执行 if 语句中的代码块，否则执行 if 语句块后面的代码。

public class Test {public static void main(String args[]){int x = 10;if( x < 20 ){System.out.print("这是 if 语句");}}}

以上代码编译运行结果如下：

这是 if 语句

if...else语句

if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。

语法

if…else 的用法如下：

if(布尔表达式){//如果布尔表达式的值为true}else{//如果布尔表达式的值为false}

实例：

public class Test {public static void main(String args[]){int x = 30;if( x < 20 ){System.out.print("这是 if 语句");}else{System.out.print("这是 else 语句");}}}

以上代码编译运行结果如下：

这是 else 语句

if...else if...else 语句

if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。

使用 if，else if，else 语句的时候，需要注意下面几点：

if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。

语法

if...else 语法格式如下:

if(布尔表达式 1){//如果布尔表达式 1的值为true执行代码}else if(布尔表达式 2){//如果布尔表达式 2的值为true执行代码}else if(布尔表达式 3){//如果布尔表达式 3的值为true执行代码}else {//如果以上布尔表达式都不为true执行代码}

实例：

public class Test {public static void main(String args[]){int x = 30;if( x == 10 ){System.out.print("Value of X is 10");}else if( x == 20 ){System.out.print("Value of X is 20");}else if( x == 30 ){System.out.print("Value of X is 30");}else{System.out.print("这是 else 语句");}}}

以上代码编译运行结果如下：

Value of X is 30

嵌套的 if…else 语句

使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。

语法

嵌套的 if…else 语法格式如下：

if(布尔表达式 1){如果布尔表达式 1的值为true执行代码if(布尔表达式 2){如果布尔表达式 2的值为true执行代码}}

你可以像 if 语句一样嵌套 else if...else。

实例：

public class Test {public static void main(String args[]){int x = 30;int y = 10;if( x == 30 ){if( y == 10 ){System.out.print("X = 30 and Y = 10");}}}}

以上代码编译运行结果如下：

X = 30 and Y = 10

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 语句。

switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。

实例

public class Test {public static void main(String args[]){//char grade = args[0].charAt(0);char grade = 'C';switch(grade){case 'A' :System.out.println("优秀"); break;case 'B' :case 'C' :System.out.println("良好");break;case 'D' :System.out.println("及格");break;case 'F' :System.out.println("你需要再努力努力");break;default :System.out.println("未知等级");}System.out.println("你的等级是 " + grade);}}

以上代码编译运行结果如下：

良好你的等级是 C

如果 case 语句块中没有 break 语句时，JVM 并不会顺序输出每一个 case 对应的返回值，而是继续匹配，匹配不成功则返回默认 case。

public class Test {public static void main(String args[]){int i = 5;switch(i){case 0:System.out.println("0");case 1:System.out.println("1");case 2:System.out.println("2");default:System.out.println("default");}}}

以上代码编译运行结果如下：

default

如果 case 语句块中没有 break 语句时，匹配成功后，从当前 case 开始，后续所有 case 的值都会输出。

public class Test {public static void main(String args[]){int i = 1;switch(i){case 0:System.out.println("0");case 1:System.out.println("1");case 2:System.out.println("2");default:System.out.println("default");}}}

以上代码编译运行结果如下：

12default

如果当前匹配成功的 case 语句块没有 break 语句，则从当前 case 开始，后续所有 case 的值都会输出，如果后续的 case 语句块有 break 语句则会跳出判断。

public class Test {public static void main(String args[]){int i = 1;switch(i){case 0:System.out.println("0");case 1:System.out.println("1");case 2:System.out.println("2");case 3:System.out.println("3"); break;default:System.out.println("default");}}}

以上代码编译运行结果如下：

123