Java简单语句、复合语句、控制语句(3.7-3.8)

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 11k 阅读时长 ≈ 10 分钟

 
 

简单语句和复合语句 & 控制语句

 
 

一、 简单语句和复合语句

1.1 变量定义语句

变量定义语句用来定义一个变量，基本格式为：
   类型 变量名1, 变量名2…；
例：char c=‘a’; int i,j=1;

1.2 赋值语句

赋值语句是将表达式的值赋给变量，其格式为：
  变量=表达式；
例： char c; c=‘a’;

1.3 方法调用语句

方法调用语句的一般形式为：
  对象.方法名( 实参数列表 );
例如 System.out.println(“Example!”);

1.4 空语句

方法调用语句的一般形式为：
  ；//这是一条空语句

1.5 标准输入输出（I/O）

输入和输出是Java程序的重要组成部分,它提供了人机交互的手段，它们属于方法调用语句。具体使用方法参考本博客IO使用方法。

1. 输入输出
输入是指把需要加工的数据放到程序中,read
输出则把程序处理的结果呈现给用户,write
2. 标准输入输出
一般用键盘作为标准的输入设备
显示器则是标准的输出设备
通过System.in和System.out对象分别与键盘和显示器发生联系进行输入和输出。

 
📒1. 标准输出System.out对象
System.out对象中包含的最常用的方法是：
println(参数) 向标准输出设备(显示器)打印一行文本并换行
print(参数) 向标准输出设备(显示器)打印一行文本但不换行
参数类型：boolean , char char[] ,double ,float ,int ,
long , Object,String

例如：System.out.println(“Example”);
System.out.print(“Input Name”);
int x=2; System.out.print(x);

 
📒2. 标准输入System.in对象
System.in是字节流,作用是从标准输入读一个字节,常用的方法如下:
int read()  从流中读取一个字节并将该字节作为整数返回,若没有数据则返回-1
int read(byte b[])  从流中读取多个字节放到b中, 返回实际读取到的字节数
int read(byte b[],int off,int len)  从流中读取最多len字节的数据, 放到数组b的下标off开始的单元中，返回读取到的字节数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
[例3-1] ReadChar.java 从键盘读一个字符
import java.io.*;
public class ReadChar{
   public static void main(String args[]){
    try{
         char ch=(char)System.in.read(); //将int转换为char
         System.out.println(ch);    
         }catch(IOException e){}
   } 
}

[例3-2] ReadString.java 从键盘读一串字符
import java.io.*;    
public class ReadString
{ public static void main(String args[])
     {  char c;
         try{
            do
           {  c=(char)System.in.read();  //使用循环来从输入流中读取一转字符
              System.out.print(c);
            }while(c!='\n');
         }catch(IOException e){  }                    
     }
}

[例3-3] ReadStringOrInt.java 从键盘读一数字串或一个整数
import java.io.*;
class ReadStringOrInt{
	public static void main(String args[]){
	      byte buf[]=new byte[20];  
	      String str;
           int anInt;         
	      try{    
               System.in.read(buf);  
	          str=new String(buf)
	          anInt=Integer.parseInt(str.trim()); 
	           }
	      catch(Exception e){  } 	
     }
}
//要将数字串转换成实数，则： 
  float  f=Float.parseFloat(str.trim());        //转成单精度数
  double d=Double.parseDouble(str.trim());      //转成双精度数

思考：如何接收用户向程序输入的参数?
通过System.in
通过main（String[] args）中的形参
class test{
public static void main(String[] args){
System.out.println(args[0]);
System.out.println(args[1]);
}
}
java test s1 s2
s1
s2

 

二、 控制语句句

  • [ ]2.1选择语句
    • 2.1.1 if-else语句
    • 2.1.2 switch语句
  • [ ]2.2循环语句
    • 2.2.1 while 语句
    • 2.2.2 do-while 语句
    • 2.2.3 for 语句
    • 2.2.4 循环的嵌套
  • [ ]2.3跳转语句
    • 2.3.1 break语句
    • 2.3.2 continue语句
    • 2.3.3 return 语句

2.1 选择语句

if-else语句

📒if-else语句的语法形式：
if (布尔表达式)
{ 语句块1 }
[ else
{ 语句块2 } ]
若语句块1，语句块2也是if-else语句便形成嵌套

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
例［3-4］：三个整数a,b,c，要求按从小到大的次序输出
解题思路：对a,b,c进行排序。先找出a、b、c中最小的，然后比较剩下的两个。
算法：    
        ①如果a>b，则将a和b互换（使得a是a、b中小的那个）
        ②如果a>c，则将a和c互换（使得a是a、b、c中最小的）
        ③如果b>c，则将b和c互换（最后c最大，b次之，a最小）
代码如下：
     if(a>b)
	{
          t=a;a=b;b=t;
     }
	if(a>c)
	{
          t=a;a=c;c=t;
     }
	if(b>c)
	{
          t=b;b=c;c=t;
     }
    System.out.println(a+"< " +b+"< " +c);
**📒 if–else 语句的嵌套** if-else语句中内嵌的语句1或语句2又是if-else语句的情况称为if-else语句的嵌套。如： if（布尔表达式1） 语句1 else if（布尔表达式2） 语句2 … else if (布尔表达式m) 语句m else 语句n 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[例3-5] 求一元二次方程(aX2+bX+c=0)的根：
public class roots{
	public static void main(String args[]){
		int a,b,c;
		float x1,x2;
		int check;
		a=1;b=-2;c=1;
		check=b*b-4*a*c;
		if(check==0){
			x1=(-b)/(2*a);
			x2=x1;
			System.out.println("x1="+x1);
			System.out.println("x2="+x2);
		}
     else
        if (check>0) {
          x1=(-b+(float)Math.sqrt(check))/(2*a);
          x2=(-b-(float)Math.sqrt(check))/(2*a);
          System.out.println("x1="+x1);
          System.out.println("x2="+x2);
         }
         else
         {   /*请自己填写*/   }
     } }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
课堂练习：求最小数
import  java.io.*;             
public class Min
{
	public static void main(String args[]) throws IOException
 { 
   byte buf[]=new byte[20];  
   String str ;  int a, b, min;    
   System.out.println("请输入二个整数：");                    
   System.in.read(buf);        //从键盘读一数字串存于buf中
   str=new String(buf);              //buf 转换成字符串 
   a=Integer.parseInt(str.trim());  //数字串转换成整数
   System.in.read(buf);    str=new String(buf);                   
   b=Integer.parseInt(str.trim());        
    
   min=a;
   if (min>b) min=b;
   System.out.println("最小数是"+min);

 }
}

&emsp;

switch 语句

switch语句根据表达式的结果来执行多个可能操作中的一个，它的语法形式如下：

1
2
3
4
5
6
7
8
9
10
11
12
switch(表达式)
{
 case 常量1：语句1  
                [break;]
 case 常量2：语句2
                [break;]
 …
 case 常量n：语句n
                 [break;]
 [default: 缺省处理语句
                 break；]    //这儿的break语句不必要
 }

&emsp;
注意： “case 常量”只起语句标号的作用，并非在该处进行条件判断。在执行switch语句时，根据switch括号中表达式的值找到匹配的入口标号，就从此标号所标记的语句开始执行下去，不再进行判断，直到遇到break语句为止。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
演示有break及没有break的情况
public class switchBreak
{
      public static void main(String args[])
     {   …
         switch(2)
         { 
          case 1: System.out.println("case1");
                      break;
          case 2: System.out.println("case2");
                      break;
          case 3: System.out.println("case3");
                      break;
          default: System.out.println("default");
         }
      }
}

&emsp;
使用switch-case必须注意:
1. 表达式必须是符合byte,char,short和int类型的表达式,不能是浮点类型或字符串，case子句中常量的类型必须与表达式的类型相容,且每个常量必须不同；
2. case后面可以有多条语句，不用加{}；
3. default子句是可选的。如果有default，当表达式的值与case子句的值都不匹配时就会执行default分支，如果既没匹配也没default，那就什么也不执行；
4. break为跳转语句，表示跳出switch结构，即终止switch语句的执行。如果没有break语句，则switch在执行完一个case分支后，流程控制转移到下一个case继续执行，不再匹配，直到遇到break为止。
5. 多个case子句可以共享相同的语句块；
6. 通过if-else语句可以实现switch语句所有的功能。但通常使用switch语句更简练，且可读性强，程序的执行效率也高；
7. if-else语句可以基于一个范围内的值或一个条件来进行不同的操作，但switch语句中的每个case子句都必须对应一个单值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
[例3-6] 用switch语句判断一个月份属于一年哪个季节(春、夏、秋、冬)。
class SwitchDemo{
 public static void main(String args[]) { 
  int month=7;
  String season;
  switch (month)     //值为12、1和2时将都执行：season="冬季"; break;
  { case  12: 
    case  1:
    case  2:
      season="冬季";  
      break;
    case  3:
    case  4:
    case  5:
      season="春季"；
      break;
   case  6:
   case  7:
   case  8:  season="夏季"; 
                 break;
   case  9:
   case  10:
   case  11: season="秋季"；
                 break;
   default:  season="错!";
   }
   System.out.println("月份    季节");
   System.out.println(month+"    "+season);
 }
}
该程序运行后输出：月份    季节
                 7      夏季

&emsp;
&emsp;

2.2 循环语句

while 语句

while语句形式如下：
&emsp;&emsp; while (布尔表达式) {语句块}
说明：while：语句的关键字； 布尔表达式：循环条件； 语句块：循环体，是一个语句，若是多个语句则应构成复合语句。
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[例3-7] Sum1.java用while循环语句计算s=1+1/2+1/3+…+1/100
class Sum {
  public static void main(String args[]) {
    int n=100;　                //循环总数n=100
    int  i=1;　　     　　      //循环次数，初值为１
    float s=0;                 //和s为实型
    while (i<=100) 　　　      //循环条件,循环总数100
    {
     s=s+(1.0f/i);            //s增加1/i ,1.0f表示是float型
     i++;                    //循环次数加１
    }
    System.out.println(“s=”+s);
  }
}

&emsp;
&emsp;

do-while 语句

do-while语句的语法形式如下：
&emsp;&emsp; do{
&emsp;&emsp; 语句块
&emsp;&emsp; }while（布尔表达式）;

说明：do：语句的关键字； 语句块：循环体，是一个语句，若是多个语句则应构成复合语句； 布尔表达式：循环条件。
 

1
2
3
4
5
6
7
8
9
10
11
12
[例3-8] Sum2.java 用do-while循环语句计算s=1+2+3+……100
class Sum2{
	public static void main(String args[]){
		int i=1;         //循环次数，初值为１
		int s=0;         //累加和s初值为0
		do{              //开始无条件循环
			s=s+i;       //s增加i
			i++;         //循环次数加１
		}while(i<=100);  //循环总数100
		System.out.println("s="+s);
	}
}

&emsp;
&emsp;

for 语句

for语句的语法形式为：
&emsp;&emsp;for（表达式1；表达式2；表达式3）
&emsp;&emsp; { 语句块
&emsp;&emsp; }

说明：（表达式1；表达式2；表达式3）：循环条件； 语句块：循环体，是一个语句，若是多个语句则应构成复合语句。

for语句的执行过程如下：
（1）按表达式1将初值赋给循环控制变量；
（2）按表达式2判断循环是否成立，如果成立则执行循环体，否则退出循环；
（3）执行一次循环后，执行表达式3修改控制变量。
 

1
2
3
4
5
6
7
8
9
[例3-9] sum3.java 编程求S=12+22+…92 
public class sum3{
	public static void main(String args[]){
		int s=0;
		for(int i=1;i<=9;i++)
		   s=s+i*i;
		   System.out.println("s="+s);
	}
}
**for语句使用注意：** 1. 逗号语句分隔的语句系列,被看作一个语句，这样就可以在只能放一个语句的地方放任意多个语句，只须用逗 号将它们分隔开。如： for ( i=1,j=10;i < j;i++,j--) { …… } 2. 表达式1、表达式2及表达式3都可以为空语句(但分号不能省略) 如： for( ; ; ) { … } 相当于while(true)

循环的嵌套：
一个循环体内又包含另一个完整的循环结构 ，称为循环的嵌套。内嵌的循环中还可以嵌套循环，这就是多重
循环。上述三种循环（while循环，do-while循环和for循环）语句之间可以相互嵌套使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[例3-10] 百鸡问题。
      已知公鸡5元1只，母鸡3元一只，小鸡1元3只，要求用100元刚好买100只鸡，问有多少种采购方案。

     分析: 设变量I、J、K分别代表公鸡数、母鸡数及小鸡数，则应满足下列一些条件:
① I+J+K=100(只)，I,J,K0;
② 5I+3J+K/3=100（元）;
③ 若用100元全部买公鸡，最多只能买20只, 所以I≤20;若全部买母鸡最多只能买33只，所以J≤33; 
  而小鸡数目就是100-I-J;(简化计算)
     根据以上分析，可编程如下：


public class  Loop_Loop {
    public static void main(String args[]) {
      int I,J,K;
      System.out.println(" I    J    K ");
      for  (I=0;I<=20;I++ )
       { for ( J=0;J<=33;J++)
            { K=100-I-J;                
              if (5*I+3*J+K/3.0==100)         //注意“K/3.0”
              System.out.println(I+"   "+J+"   "+K);
            } 
       }
   }  
}

&emsp;
&emsp;

2.3 跳转语句

break语句

作用： 使程序的流程从一个语句块的内部跳转出来。
(1) 从switch语句的分支中跳出来
(2) 从循环体内跳出来

对上述的(1)(2)举例如下：(1) break用于跳出switch语句 

1
2
3
4
5
6
7
switch(grade)
{ 
case 'A': 
case 'B': 
case 'C': System.out.println("及格\n "); break;
case ‘D’: System.out.println(“不及格\n "); break;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
习题1：分析该程序的输出结果
int x=5;
do{
          switch(x%2)
          {
                case 1: x--;
                            break;
                case 0: x++;
                            break;
           }
           x--;
           System.out.println(x);
     }while(x>0);
运行结果：
3
1
-1



习题2：分析该程序的输出结果
int a=5,b=6,i=0,j=0;
switch(a)
{
        case 5: switch(b)
                    {
                          case 5:i++;break;
                          case 6:j++;break;
                          default:i++;j++;
                     }
         case 6: i++;j++;
                     break;
         default: i++;j++;
}
System.out.println(i+","+j);
运行结果：
1,2

&emsp;
(2) break用于跳出循环体

break可用于跳出for循环、while循环、do while循环。

1
2
3
4
5
6
7
int sum=0;      
for(int i=1;i<=100;i++)
{
      sum=sum+i;
      if(i==50)break;
}
System.out.println(sum);    //结果为1275

&emsp;
&emsp;
如果break在多重循环中，只退出break所在的那层循环到外层循环中。 

1
2
3
4
5
6
7
int sum=0;      
for(int i=1;i<=100;i++)
{
       sum=sum+i;
       while(i==50){i=100;break;}
}
System.out.println(sum);       //结果为1275

&emsp;
&emsp;

continue 语句

作用：用来结束所在循环语句块的本次循环
注意:continue语句只能在循环语句中使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
[例3-11] ConDemo.java
public class ConDemo{
public static void main(String args[]){
  int index=0;
  while(index<=99)
 {
	index+=10;
           if(index==40)  continue; 
	System.out.println("   The index is "+index);
		}
	}

程序运行结果：
   The index is 10
   The index is 20
   The index is 30
   The index is 50
   The index is 60
   The index is 70
   The index is 80
   The index is 90
   The index is 100

&emsp;
&emsp;
循环体中使用break语句和continue语句的区别：
Break语句 结束整个循环,不再判断执行循环的条件;
Continue语句只结束本次循环,而不是终止整个循环的执行。

&emsp;
&emsp;

return 语句

格式： return 表达式;
用途：
(1) 结束方法的运行，并返回一个值；
(2) 如果该方法没有返回值（void），则return后不能跟表达式。

例如： return 0;
&emsp;&emsp;&emsp; return;

思考:分析以下程序运行结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
1. 
public class ArithmeticOp{
    public static void main(String args[ ]){
       int a,b,c;
       a=b=c=2;
       a=++b - ++c;     //0 3 3
       System.out.println（″a=″+a+″b=″+b+″c=″+c）;
       a =b++ + c++;    //6 4 4
       System.out.println（″a=″+a+″b=″+b+″c=″+c）;
       a =b-- + c--;    //8 3 3
       System.out.println（″a=″+a+″b=″+b+″c=″+c）;
     }
}

2.
public class TestSwitch{
    public static void main(String args[ ]){
       int  x=1,y=2,i=0,j=0;
       switch(x){
          case 1: switch(y){
                   case 1: i++;
                   break;
                   case 2: j++;
                   break;
                   default:i++;
                    j++;}           //i=0 j=1

          case 2: i++;
                  j++;              //i=1 j=2
                  break;
          default:i++;
                  j++;
       }
      System.out.println("i="+i);
      System.out.println("j="+j);
    }                              //i=1
}                                  //j=2


3.
public class J_Test{
  static boolean mb_fun(char c)
  {    System.out.print(c);
       return true;
  }
  public  static void main(String args[]){
       int i=0;
       for(mb_fun(‘A’);mb_fun(‘B’)&&(i<2);mb_fun(‘C’))
       {   i++;
           mb_fun(‘D’);
       }
  }
}     //结果： A B D C B D C B

&emsp;
&emsp;
&emsp;
&emsp;