java 基本语句是_[基础篇]-基础知识整理-04-JAVA常见语句分析

Java的基本语句分析

流程控制不论哪一种编程语言，都会提供两种基本的流程控制结构：分支结构和循环结构。其中分支结构用于实现根据条件来选择性地执行某段代码，循环结构则用于实现根据循环条件重复执行某段代码。

Java 同样提供了这两种流程控制结构的语法，Java提供了 if和switch两种分支语句，并提供了 while、do while 和for三种循环语句。除此之外，JDK5还提供了一种新的循环：foreach循环，能以更简单的方式来遍 历集合、数组的元素。

Java还提供了 break和continue来控制程序的循环结构。

分支结构

条件语句if

public class IfTest {

public static void main(String[] args) {

//if语句的三种形式/*** 1.if(条件表达式)* 执行语句;*/

if(true)

System.out.println("if语句形式1测试");

/*** 2.if(条件表达式)* 执行语句1;* else* 执行语句2;*/

if(true)

System.out.println("if语句形式2测试");

else

System.out.println("当条件表达式返回值为false执行这条语句");

/*** 3.if(条件表达式1)* 执行语句1;* else if(条件表达式2)* 执行语句2;* ......* else if(条件表达式n-1)* 执行语句n-1;* else* 执行语句n;*/

int age = 18;

if(age>0&&age<20)

System.out.println("年轻人...");

else if(age>=20&&age<30)

System.out.println("青年人");

else if(age>=30&&age<60)

System.out.println("中年人");

else

System.out.println("老年人");

}

}对于嵌套的 if 语句，只有当外层 if 的条件成立时，才会判断内层 if 的条件。

举例说明：

条件语句switch当需要对选项进行等值判断时，可使用switch语句简单明了。Switch语句由一个控制表达式和多个case标签组成，和if语句不同的是 Switch语句后面的表达式只能是byte、short、int、char 四种基本的数据类型 ，jdk1.7之后加强了Switch新增了String类型 。

执行过程：当 switch 后表达式的值和 case 语句后的值相同时，从该位置开始向下执行，直到遇到 break 语句或者 switch 语句块结束；如果没有匹配的 case 语句则执行 default 块的代码。

public class SwitchTest {

public static void main(String[] args) {

/*** switch语句测试：* switch语句后面的表达式可以由byte、short、int、char四种基本类型* jdk1.7后新增了String类型*/

char score = 'B';

switch(score)

{

case'A':

System.out.println("优秀");

break;

case'B':

System.out.println("良好");

break;

case'C':

System.out.println("中等");

break;

case'D':

System.out.println("及格");

break;

case'E':

System.out.println("不及格");

break;

default:

System.out.println("成绩输入格式错误，请重新进行操作！");

break;

}

}

}

public class SwitchStringTest {

public static void main(String[] args) {

String season = "夏天";

switch(season)

{

case"春天":

System.out.println("春暖花开");

break;

case"夏天":

System.out.println("夏日炎炎");

break;

case"秋天":

System.out.println("秋高气爽");

break;

case"冬天":

System.out.println("白雪皑皑");

break;

default:

System.out.println("季节输入格式错误，请重新输入！");

break;

}

}

}使用Switch语句时的注意事项：

switch 后面小括号中表达式的值可为byte、short、int、char、String类型

case 后面的值可以是常量数值(如1、2)；也可以是一个常量表达式(如2+2)，但不能是变量或带有变量的表达式(如 a * 2)

case 匹配后，执行匹配块里的程序代码，如果没有遇见 break会继续执行下一个的 case 块的内容，直到遇到 break 语句或者 switch 语句块结束

可以把功能相同的 case 语句合并起来，如

上述表示当判断的数据是1或2是可输出该语句，即如果一个case没有与之对应的语句(基本语句或跳转语句)，则继续执行下一步。default 块可以出现在任意位置，也可以省略

循环结构循环语句可以在满足循环条件的情况下，反执行某一段代码，这段被重复行的代码被称为循环体。当反复执行这个循环体时，需要在合适的时候把循环条件改为假，从而结束循环，否则循环将一直 执行下去，形成死循环。循环语句可能包含如下4个部分。

>初始化语句(init_statement):—条或多条语句，这些语句用于完成一些初始化工作，初始化语句在循环开始之前执行。

>循环条件(test_expression):这是一个boolean表达式，这个表达式能决定是否执行循环体。

>循环体(body_tatement):这个部分是循环的主体，如果循环条件允许，这个代码块将被重复 执行。如果这个代码块只有一行语句，则这个代码块的花括号是可以锊略的。

>迭代语句(iteration_statement):这个部分在一次循环体执行结束后，对循环条件求值之前执行， 通常用于控制循环基件中的变量，使得循环在合适的时候结束。

上面4个部分只是一般性的分类，并不是每个循环中都非常清晰地分出了这4个部分。

循环语句 while

执行过程：先判断，后执行判断 while 后面的条件是否成立( true / false )

当条件成立时，执行循环内的操作代码 ，然后重复执行1、2步骤直到循环条件不成立为止

public class WhileTest {

public static void main(String[] args) {

//1.打印1-10中的奇数int i = 1;

while(i<=10)

{

if(i%2==1)

System.out.println(i);

i++;

}

//2.求1-10的总和int x = 1;

int count = 0;

while(x<=10)

{

count+=x;

x++;

}

System.out.println("1-10的总和为："+count);

}

}

循环语句 do...while

执行过程：先执行，后判断

1. 先执行一遍循环操作，然后判断循环条件是否成立

2. 如果条件成立，继续执行1、2步骤，直到循环条件不成立为止

即使循环条件不满足，do...while 语句保证循环至少被执行一次！

public class DoWhileTest {

public static void main(String[] args) {

/*** do...while...与while的区别在于* do...while...语句无论如何都会先执行一次* 而while语句只有当括号里的表达式的值返回true时，才执行相关语句*/

int x = 3;

while(x<3)

{

System.out.println("x="+x);

x++;

}

int y=3;

do{

System.out.println("y="+y);

y++;

}while(y<3);

}

}

循环语句 for

for( 表达式1 ; 表达式2; 表达式3){

循环体语句4 ;

}表达式1 ：一般是一个赋值语句，它是用来给变量进行赋初值。

表达式2：是一个布尔类型的表达式，它决定什么时候退出循环。

表达式3： 一般是用来修改变量，控制每次循环的方式是什么。

执行过程：

1、执行循环变量初始化部分，设置循环的初始状态，此部分在整个循环中只执行一次

2、进行循环条件的判断，如果条件为 true ，则执行循环体内代码；如果为 false ，则直接退出循环

3、执行循环变量变化部分，改变循环变量的值，以便进行下一次条件判断

4、依次重新执行2、3、4步骤，直到退出循环

public class ForTest {

public static void main(String[] args) {

//循环打印1-10for(int i=1;i<=10;i++)

System.out.println(i);

//与for循环语句相关的面试题int x = 1;

for(System.out.println("a");x<3;System.out.println("c"))

{

System.out.println("d");

x++;

}

/*** 分析：for(初始化语句;循环条件;循环条件控制表达式)* {* 执行语句;* }* 初始化语句只执行一次* 循环条件用于判断是否继续执行相关语句* 循环条件控制表达式用以控制循环条件以防止陷入死循环* 执行顺序：1.当初始化条件执行完毕后，判断是否满足当前的循环条件* 2. 如果满足，则执行相关语句，随后执行循环条件控制表达式* 3.继续判断是否满足循环条件，满足则执行第2步* 4.如果不满足则跳出循环，结束循环语句！* 按照上述分析，可以得到“a d c d c ”*/

}

}使用for循环语句时的注意事项：

for 关键字后面括号中的三个表达式必须用 “ ;” 隔开，三个表达式都可以省略，但 “ ; ” 不能省略。

省略“循环变量初始化”，可以在 for 语句之前由赋值语句进行变量初始化操作，如:

省略“循环条件”，可能会造成循环将一直执行下去，也就是我们常说的“死循环”现象，如:

在编程过程中要避免“死循环”的出现，因此，对于上面的代码可以在循环体中使用 break 强制跳出循环(关于 break 的用法会在后面介绍)。省略“循环变量变化”，可以在循环体中进行循环变量的变化，如：

for 循环变量初始化和循环变量变化部分，可以是使用 “,” 同时初始化或改变多个循环变量的值，如：

代码中，初始化变量部分同时对两个变量 i 和 j 赋初值，循环变量变化部分也同时对两个变量进行变化，运行结果：

循环条件部分可以使用逻辑运算符组合的表达式，表示复杂判断条件，但一定注意运算的优先级，如：

代码中，必须同时满足变量 i 小于 10 ，并且 i 不等于 5 时才会进行循环，输出变量 i 的值。

多重循环

循环体中包含循环语句的结构称为多重循环。三种循环语句可以自身嵌套，也可以相互嵌套，最常见的就是二重循环。在二重循环中，外层循环每执行一次，内层循环要执行一圈。

举例分析：

使用 * 打印长方形：

实现代码为：

//嵌套的循环语句:打印长方形

for(int i=0;i<5;i++)

{

for(int j=0;j<5;j++)

{

System.out.print("*");

}

System.out.println();

}

执行流程：当 i = 1 时，外层循环条件成立，进入内层循环，开始打印第一行内容。此时， j 从 1 开始，循环 8 次，内层循环结束后换行，实现第一行 8 个 * 的输出。接下来返回外层循环 i 变为 2 ，准备打印下一行，依此类推，直到完成长方形的打印。

Foreach语句

在jdk1.5之后Java提供了一种更简单的循环，该种循环可以迭代遍历数组和集合。语法规则如下：

for( 存储是数据类型 标识符 : 要迭代的集合)

{

执行语句;

}

public class ForEachTest {

public static void main(String[] args) {

//循环遍历数组、集合中的数据String[] hobbies = new String[]{"看电视","打游戏","阅读","打代码"};

//1.用for循环语句实现for(int i=0;i

{

System.out.println("第"+(i+1)+"本书："+hobbies[i]);

}

//2.用增强后的for语句实现(foreach)int count=1;

for(String s : hobbies)

{

System.out.println("第"+count+"本书："+s);

count++;

}

}

}

控制循环Java中没有goto关键字，而是作为保留字。所谓的保留字是指当前版本中没有使用，但是也禁止你当做标识符使用，以后的版本可能使用。

Java语言没有提供goto语句来控制循环跳转。这种做法提高了程序流程的可读性，但是程序的灵活性降低，为了弥补不足java提供了continue和break来控制循环体除此以外还有return语句可以结束整个方法。

跳转语句 breakbreak语句是终止当前整个循环体

public class BreakTest {

public static void main(String[] args) {

//break语句用于终止当前循环for(int x=0;x<5;x++)

{

if(x==1)

break;//跳出循环、终止循环System.out.println("x="+x);

}

/*** 上述语句执行后只输出了“x=0”，因为当x取值为1的时候，此时满足if* 条件语句，执行break操作，直接跳出了当前循环，之后的输出内容不再执行* 因此最终只显示了“x=0”的输出信息*/

//对循环体进行命名，可以用break语句指定要跳出来的循环outer:for(int i=0;i<5;i++)

inner:for(int j=0;j<5;j++)

{

System.out.println("i="+i);

//break outer;break inner;

}

/*** 分析：上述语句执行结果显示：由break语句指定当前要跳出的循环* break outer:跳出外循环outer-->当输出“i=0”之后，执行break outer语句* 直接跳出外循环，且无其他语句可执行，因此输出结果为“i=0”这句话* break inner:跳出内循环inner-->当输出相应的“i=0”之后，执行break inner语句* 随后判断还是满足外循环的条件，因此再次执行内循环操作，以此类推进行分析，* 最终分别输出每次外循环执行时当前的i值* 即“i=0 i=1 i=2 i=3 i=4”*/

}

}

跳转语句 continuecontinue 的作用是跳过循环体中剩余的语句执行下一次循环。

public class ContinueTest {

public static void main(String[] args) {

//continue语句的作用：跳过当前循环剩余的语句，执行下一次循环(执行下一条语句)for(int x=0;x<5;x++)

{

if(x==1)

continue;//跳过本次循环,进入下一次循环System.out.println("x="+x);

}

/*** 上述语句执行后输出结果为“x=0 x=2 x=3 x=4”* 当判断到x=1时，满足if语句的条件，因此执行continue语句，从而跳过当前循环，* 进入下一次循环，继续输出相关信息*/

//对循环体进行命名，可以用break语句指定要跳出来的循环outer:for(int i=0;i<5;i++)

inner:for(int j=0;j<5;j++)

{

System.out.println("i="+i);

//continue outer;continue inner;

}

/*** 分析：上述语句执行结果显示：由continue语句指定当前要跳出的循环* continue outer:跳出当前的外循环outer-->当输出“i=0”之后，执行continue outer语句* 直接跳出当前的外循环，从而进入下一次循环，以此类推进行分析，因此输出结果为* “i=0 i=1 i=2 i=3 i=4”* continue inner:跳出内循环inner-->当输出相应的“i=0”之后，执行break inner语句* 直接跳出当前的内循环，随后判断还是满足内循环的条件，因此再次执行内循环操作，以此类推进行分析，* 最终输出“i=0(*5) i=1 (*5) i=2(*5) i=3(*5) i=4(*5)”*/

}

}

跳转语句 returnreturn语句：结束整个方法

public class ReturnTest {

public static void main(String[] args) {

//return:直接结束整个方法for(int i=0;i<3;i++)

{

System.out.println("i="+i);

if(i==1)

return;

}

System.out.println("return结束整个方法");

/*** 分析：上述语句执行分析为，按照for循环语句的执行顺序一步步进行分析* 当i=0时，满足循环条件，输出“i=0”，随后i执行加1操作，进入下一步判断* 当i=1时，满足循环条件，输出“i=1”，随后判断i=1时满足if语句，则执行* return语句，结束整个方法，最后的输出提示也不会输出，因此最终显示的信* 息时“i=0 i=1”*/

}

}