JAVA笔记：第二章：Java控制语句（if、switch、while、for、contintue和break）

Java控制语句
（if、switch、while、for、contintue和break）

数据输入（Scanner）
一：使用Scanner类的键盘输入的语法：
首先要在函数前写：import java .util.Scanner；
在函数中输入：Scanner object-name= new Scanner（“System . in”）；
Object-name可以是任意java标识符

在函数中输入变量的方法：
int +变量=object_name . nextInt()；//读取一个int类型的值
double+变量=object_name.nextDouble（）；//读取一个double类型的值
String+变量=object_name.next（）；//读取字符串
String+变量=object_name.nextLine()； //读取上行结束后的其余内容
实例：
{
Scanner key=new Scanner（System . in）；
int number=key . nextInt（）；
double cost=key.nextDouble（）；
String word=key.next()；
String Line=key.nextLine；
}

     行终止符（\n）的处理

Scanner类的nextLine方法读取一行中从上一个键盘读取结束处开始的其余文本。
如：import java.util.Scanner;

public class Test {

 public static void main(String[] args) 
{
 Scanner  key =new Scanner(System .in);
             int a=key.nextInt();
        String s1=key.nextLine();
        String s2=key.nextLine();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(a);      
    }
}

假设在键盘上输入 ： 2 heads are
better than

          注： 当按enter键输入第三行时，程序不给输入，直接输出结果
    程序输出的结果：    s1=  heads are
                        s2=better  than
                        a=2
           解析： 程序自动将整型2赋值给a，第一个nextLine调用读取包含2的行上的其余内容： heards  are，第二个nextLine调用读取第二行的其余部分better  than 

      但若将输入改成：
             2
             heads are better than
   注： 当按enter键输入第三行时，程序不给输入，直接输出结果

            程序输出结果：
                            s1=
                                 s2=heads are better than
                                 a=2    

解析：
2是整型，将被截取给a，第一个nextLine调用读取包含2的行上的其余内容，但该行没有任何东西（除了\n）因此s1返回空字符串，第二个nextLine调用读取第二行输入的所有代码
键盘输入示例：
import java.util.Scanner;

public class Test {

 public static void main(String[] args) 
{
     int  n1,n2;
     Scanner  blm=new Scanner(System.in); // 创建Scanner类的一个对象，
                                                 并将该对象命名为blm
      System.out.println("输入2个整数"); 
      n1=blm.nextInt();         // 从键盘上读取一个int值
      n2=blm.nextInt();
      System.out.println("你输入了："+n1+"和"+n2);
      System.out.println("输入另外两个数：");
      double d1,d2;
     d1=blm.nextDouble();                    // 从键盘上读取一个double值
     d2=blm.nextDouble();
     System.out.println("你输入了;"+d1+"和"+d2);
     System.out.println("请输入另外两个数：");
          String m1=blm.next();              // 从键盘上读取一个单词
          String m2=blm.next();
     System.out.println("你输入了："+m1+"和"+m2);
     System.out.println("请输入最后一行字符串");
           String  zf  = blm.nextLine ();          

/* 注意：“编程陷阱：行终止符（\n） 的处理”,zf将读取上行输入的其余文本，因为上行无任何东西了，则zf结果为空，zfcc将读取上行的字符串。 如果没有这行代码，下边的字符串zfcc将输出空字符
*/

      String  zfcc =  blm.nextLine ();       // 读取上行结束后的所有文本
      System.out.println("你输入了："+zfcc); 
    }
}

程序运行结果：
输入2整数
1 1
你输入了：1和1
输入另外两个数：
2 2
你输入了;2.0和2.0
请输入另外两个数：
3 3
你输入了：3和3
请输入最后一行字符串
whn
你输入了：whn

注意： 若程序有多个输入，若遇到输入字符串zf，则需要在字符串zf输入之前多写一个输入zff，用该输入被赋值，上行结束的空字符串，则zf接收键盘输入的字符串

随机数

运行结果：

if语句

   if （表达式）     
          语句1；
          else                
          语句2；

   注意：else不是一条独立语句，它只是if的一部分，else总是与前面最近的不带else 
         的if相结合


       例题1：

           public class Test2

{

 public static void main(String[] args)
{
     int x=1 ,y=2 ,z= 3;
     if(x>=y)
     if(y<=z)
    System.out.println(++z);
     else
    System.out.println(++y);
    System.out.println(x++);
}

}
程序将输出: 1
例题2：
输入一个double值，保留两位小数点。
public static void main(String[] args) {
double m,p1,m1,m3;
int p,m1_1;
System.out.println(“帅哥，请输入100以内的double值：”);
Scanner w=new Scanner(System.in);
m=w.nextDouble();
if((int)(m*1000)%10>=5)
{
m=((int)(m*100)+1)/100.0;
}
else{
m=((int)(m*100))/100.0;
}
System.out.println(m);
}

第四节：switch语句

          一般形式：
                  switch（表达式）
              {
                case 常量表达式1：
                语句1；
                break；
                case 常量表达式2：
                语句2；
                break；
                case 常量表达式3：
                语句3；
                break；
             ｝

  注意点：    
        1： case 后面必须是整数或字符常量。

      2： switch一旦遇到第一次case匹配，程序将跳转到这个标签位置。

开始顺序执行以后所有的程序代码，直到碰到break为止。

3.如果将default语句放在了第一行，程序会从default开始执行直到第一个break出现。

4.当循环嵌套时：
* break：跳出当前循环，不再执行循环语句。
* continue：跳过后面的代码，直接进入下一次循环
* return：直接结束当前方法

案例：
public class Test2

{
public static void main(String[] args)
{
int x= 1,y= 0,a= 0,b= 0;
switch(x)
{
case 1:
switch(y)
{
case 0:a++;
1
case 1 :b++;
break;‘’
}
case 2:a++;b++;break;
case 3 :a++;b++;
}
System.out.println(a+”\n”+b);
}
}

              程序输出 ： 2
                          1

解析： x=1，因此执行第一条switch语句中case 1：后的语句，即进入嵌套的switch语句；
y=0，执行case 0：后面语句，得 a=1，遇到break 退出嵌套的switch
语句。由于第一条switch中的case 1：后面没有break ，因此继续
执行case 2 后面的语句。得，a=2，b=1 遇到break退出第一条switch
语句。

3：switch语句中，多个case可以共用一条执行语句。
如;
case ‘A’：
case ‘B’：
printf（“>60”）；
break；

   下面做一个输出学生成绩的等级程序

          import java.util.Scanner;

       public class Test2

     {
        public static void main(String[] args)
   {
    System.out.println("请输入成绩： ");
    Scanner m=new Scanner(System.in);
    int grade=m.nextInt();
if (grade>100||grade<0)
    System.out.println("成绩数据错误");

else
{
switch(grade/10)
{
case 10:
case 9:
{
System.out.println(“优等”);
break;
}
case 8:
{
System.out.println(“良”);
break;
}
case 7:
{
System.out.println(“中等”);
break;
}
case 6:
{
System.out.println(“及格”);
break;
}
default:
{
System.out.println(“不及格”);
}
}
}
}
}

例 2:
public class Test2

{
public static void main(String[] args)
{
int i;
for(i=0;i<3;i++)
switch( i)
{
case 0:System.out.print(i);
case 2:System.out.print(i);
default:System.out.print(i);
}
}
}

        程序运行后输出结果是： 000122

解析：
程序中for循环了三次，第一次i=O，执行switch语句中case0：分支，直到遇到default语句，退出switch，这里共执行了3个输出语句分别输出0、0、0，第二次循环i=1，switch语句中没有匹配的分支，故只执行default语句输出1，退出switch语句；第三次循环i=2， 从switch语句中的case2：开始执行，由于没有break，则继续执行default，又输出2. 最后输出的结果为000122

 例3：

 public class Test2

{
public static void main(String[] args)
{
int i;
for(i=1;i<3;i++)
{
Scanner ww=new Scanner(System.in);
int k=ww.nextInt();
switch(k)
{
case 0:System.out.println(“abc\n”);
case 1:System.out.println(“qwe\n”);
}
}
}
}

注意：此程序运行后可实现连续输入两次

           运行结果：
                     当输入0, 程序输出： abc

                                 qwe
                    当输入1，程序输出： qwe

第五节： While循环的一般形式
（1）当while后的表达式值为false时，表示条件为假，当表达式值为true，表示条件为真。

        （2）如果第一次计算表达式的值false，则循环语句一次不被执行，
                 流程直接跳过while语句，执行下一条语句。---------------------------------------------------------------------
   （1）  下边是计算 1+2+3+............+100 的代码    


               public static void main(String[] args) 
                {
                         int i=1，sum=0；
                         while（i<=100）
                              {
                                  sum+=i；
                                  i++；
                               }
                      System.out.println(sum);                               
                  }
                }
                        结果输出：5050   

 （2） 
           public static void main(String[] args)
         {
            int  y=10;
            while(y--!=0);
           System.out.println(“y=”+y);
         }
         程序输出y=-1   
         解释：while后面加了；号，他是结束语，意味着需要while循环结束后才运行System.out.println(“y=”+y);

 （3）
         public static void main(String[] args)
         {
            int x=0,y=5,z=3;
            while(z--=>0&&++x<5)
            y--;
            System.out.println(x’’\n’’+y+’’\n’’+z);
           }
         }

            程序输出：  3                          
                        2
                       —1

      （4）将一个数逆序输出
       public class Test2
    {
      public static void main(String[] args)
   {
         int i;
         Scanner ww=new Scanner(System.in);
        int m=ww.nextInt();
        while(m!=0)
     {
          i=m%10;
          System.out.print(i);
          m= m/10; 
       }
    }
  }

解析：为了要把输入的数逆序输出，先把该数整除10，得个位数，再用printf输出此数。然后，把输入的数除以10的商作为下一次处理的数。如此重复，直到sum的商为0时处理结束，程序无换行依次输出了个位、十位、百位。

第六节：do......while循环结构的一般形式

 （1）语法：
               do
             ｛
                循环语句；
              ｝
           while（表达式）；

（1） 在while（表达式）后的分号“；”不可丢，他表示do......while 语句的结束
（2） do.......while语句先执行语句后判断表达式的值，所以说，do......while语句至少被执行一次


         下边是计算 1+2+3+............+100 的代码

                  public class Test2

                  {
                     public static void main(String[] args)
                 {
                        int  i=1,sum=0;
                    do
                     {
                            sum+=i;
                            i++;
                      }
                          while(i<=100);
                     System.out.println(sum);
                    }
                 }

习题巩固：

          （1）以下程序运行后的输出结果是：
                  {
                          int  k=2，s=0；
                          do
                           {
                               if（（k%2）！=0）
                               continue；
                               s+=k；k++；
                            }
                                 while（k>10）；
                            System.out.println（“s=”+s）；                                
                                                                 }


               答案： s=2

解析：其中k的初始值是2，s的初始值是0，在执行while判断之前先执行下面的输出语句一次 System.out.println（“s=”+s）；即：输出s=2. 此时，判断k的值不满足while（k>10），故程序跳出循环

（2）以下程序运行后的输出结果：
public static void main(String[] args)
{
int x=2;
do
{

        System.out.print(“—2”);                       

        }
          while(--x!=0);
     }
  }

    解析：先执行do语句，输出 —2，然后判断——x！=0即判断1！=0，条件成立，输出—2，再判断——x！=0即判断0！=0，条件不成立，跳出循环。


  （3）有以下程序：
        public static void main(String[] args)
     {
              int i,n=0;
             for(i=2;i<5;i++)
       {            
            do
         {
           if(i%3!=0) 
           continue;
           n++;
          }
         while(i==1);
            n++;
       }
           System.out.println(n+”\n”);
 }

}

   程序执行后输出结果是：    n=4  

解析：
i=2：i%3(i除以3取余为2)，if条件成立，continue执行，后续n++不执行，
直接判 断while(i==1)，i==1为假，退出do/while循环，执行while后面的n++，n=1，
再执行下一次for循环。
i=3：i%3(i除以3取余为0)，if条件不成立，n++执行，n=2。再判断while(i==1)，i==1为假，退出do/while循环，执行while后面的n++，n=3，
再执行下一次for循环
i=4：i%3(i除以3取余为1)，if条件成立，continue执行，后续n++不执行，
直接判断while(i==1)，i==1为假，退出do/while循环，执行while后面的n++，n=4，再执行下一次for循环
最后，n=4

第七节： for循环结构

 for（表达式1；表达式2；表达式3）
         {
           循环体；
         }

（1）for语句中的表达式1可以省略，即 ：
for（；表达式2；表达式3）
{
循环语句；
}
注意：省略表达式1时，应在for之前给变量赋值

（2）如果省略表达式2，即：

     for（表达式1 ；表达式3）
              {
                 循环语句；
                   }

则，表示表达式2的值始终为真，产生死循环。

（3） 如果省略表达式3，即：

       for（表达式1；表达式2；）
            {
              循环语句；
                  }

此时，也将产生死循环，若要保证循环正常结束，可以将循环变量的修改部分（即表达式3）放在循环语句中

（4） for（表达式1；表达式2；表达式3）
{
；
}

         这是一个空语句

当循环嵌套时：
* break：跳出当前循环，不再执行循环语句。
* continue：跳过后面的代码，直接进入下一次循环
* return：直接结束当前方法

 continue案例：

public static void main(String[] args) {
// TODO Auto-generated method stub
for(int i=1;i<=10;i++)
{
if(i%3==0)
{
continue；
}
System.out.print(i+” “);
}
System.out.println(“循环结束！ “);
}
结果输出：1 2 4 5 7 8 10 循环结束！

break案例：
public static void main(String[] args) {
// TODO Auto-generated method stub
for(int i=1;i<=10;i++)
{
if(i%3==0)
{
break;
}
System.out.print(i+” “);
}
System.out.println(“循环结束！ “);
}
结果输出：1 2 循环结束！
return案例：

public static void main(String[] args) {
// TODO Auto-generated method stub
for(int i=1;i<=10;i++)
{
if(i%3==0)
{
return;
}
System.out.print(i+” “);
}
System.out.println(“循环结束！ “);
}
结果输出： 1 2

例题:

下边是计算 1+2+3+…………+100 的代码

      {
        int i，sum=0；
          for（i=1；i<=100；i++）
        {
             sum+=i；
          }
          System.out.println(sum);      
    }

章节列题：
（1）：求如下循环输出的结果（ 1024 10 ）
int n =1024；
int m=0；
for（int i=1；i