Java语言基础（键盘录入、选择结构语句（if语句，switch语句）、循环结构、控制跳转语句)

Java语言基础

键盘录入

1. 【目的】：为了让程序的数据更符合开发的数据,让程序更灵活；
2. 【录入格式】：

第一步：导包，格式：import java.util.Scanner; 
   	                 位置：在class上面；
第二步：创建键盘录入对象，格式：Scanner sc = new Scanner(System.in);
第三步：通过对象获取数据	，格式：int x = sc.nextInt();

//实现使用键盘录入一个数；
import java.util.Scanner; 
class Demo{
	  public static void main(String[] args){
      Scanner sc = new Scanner(System.in);
	  System.out.println("请输入一个数：");
      int a = sc.nextInt();
	}
}

选择结构语句

• if 语句

格式1：
    if(比较表达式或者是boolean类型的值) {
	   语句体;
	}
执行流程：
		先计算比较表达式的值，看其返回值是true还是false。
		如果是true，就执行语句体；
		如果是false，就不执行语句体；
格式2：
    if(比较表达式) {
		语句体1;
	}else {
		语句体2;
	}
注意：else后面是没有比较表达式的，只有if后面有。
执行流程：
	首先计算比较表达式的值，看其返回值是true还是false。
	如果是true，就执行语句体1；
	如果是false，就执行语句体2；
格式3：
	if(比较表达式1) {
		语句体1;
	}else if(比较表达式2) {
		语句体2;
	}else if(比较表达式3) {
		语句体3;
	}
	...
	else {
		语句体n+1;
	}
执行流程：
	首先计算比较表达式1看其返回值是true还是false，
	如果是true，就执行语句体1，if语句结束。
	如果是false，接着计算比较表达式2看其返回值是true还是false，
	如果是true，就执行语句体2，if语句结束。
	如果是false，接着计算比较表达式3看其返回值是true还是false，
	...
	如果都是false，就执行语句体n+1。
比较表达式无论简单还是复杂，结果必须是boolean类型
一般来说：有左大括号就没有分号，有分号就没有左大括号.

/*考试成绩分等级，请根据键盘输入的成绩，输出对应的等级。
	90~100	A等。
	80-89	B等。
	70-79	C等。
	60-69	D等。
	60以下	E等。
*/
package org.westos.demo;

import java.util.Scanner;

public class Demo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入成绩：");
        double num1=sc.nextDouble();
        if (num1>=(double)90 & num1<=(double)100){
            System.out.println("A等");
        }else if (num1>=(double)80 & num1<=(double)89){
        System.out.println("B等");
        }else if (num1>=(double)70 & num1<=(double)79){
            System.out.println("C等");
        }else if (num1>=(double)60 & num1<=(double)69){
            System.out.println("D等");
        }else if (num1>=(double)0 & num1<=(double)59){
            System.out.println("E等");
        }else{
            System.out.println("请输入正确的格式");
        }
   }
}

• switch语句

格式:
	switch(表达式){
		case 值1:
			语句体1;
			break;
		case 值2:
			语句体2;
			break;
		case 值3:
			语句体3;
			break;
		....
		default：	
			语句体n+1;
			break;
	}
执行流程：
先计算表达式的值，然后和case后面的匹配，如果匹配成功就执行对应的语句，遇到break就会结束,否则执行default控制的语句。
(1):switch表达式的取值：byte,short,int,char;
(2):case后面跟的是要和表达式进行比较的值;
(3):语句体部分可以是一条或多条语句;
(4):break表示中断，结束的意思，结束switch语句;
(5):default语句表示与case匹配不上时，就执行该处的内容，和if语句的else相似

/*请根据键盘输入的月份，打印出对应月份的天数。
1月：	31天
2月： 	28天
3月：	31天
4月：	30天
5月：	31天
6月：	30天
7月：	31天
8月：	31天
9月：	30天
10月：	31天
11月：	30天
12月：	31天  
*/
package org.westos.demo;
import java.util.Scanner;
public class Demo2 {
        public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入月份：");
        int i=sc.nextInt();
        switch (i){
            case 1: case 3: case 5: case 7: case 8: case 10: case 12:
                    System.out.println("31天");
                    break;
            case 4: case 6: case 9: case 11:
                    System.out.println("30天");
                    break;
            case 2:
                   System.out.println("28天");
                   break;
            default:
                   System.out.println("请输入正确的格式");
         }
     }
}

switch语句的注意和case的穿透现象：

1. case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的；
2. default可以省略，但是不建议，因为它的作用是对不正确的情况给出提示；
3. default可以在任意位置放，但是一般都放在最后；
4. switch语句的结束条件：1.遇到break就结束了；2.执行到末尾就结束了；
5. case的穿透现象：
   由于省略了break出现的现象。

//演示案例：
public class Demo{
    public static void main(String[] args) {
    int x = 2;
	int y = 3;
	switch(x){
		default:
			y++;
		case 3:
			y++;
		case 4:
			y++;
	}
	System.out.println("y="+y);//y=6，由于没有break结束switch语句，所以y需要在case 3：case 4：default：这三个语句体中都自增一次；
    }
}

if语句和switch语句的使用场景：
if语句：
1.针对结果是boolean类型的判断；
2.针对一个范围的判断；
3.针对几个常量值的判断；
switch语句：
主要是针对几个常量值的判断，

循环结构

假如我们要输出打印十次“Hello World”，引入循环结构就会极大的减少编写代码的工作量；循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

• for语句

循环结构for语句的格式：
	for(初始化表达式语句;判断条件语句;控制条件语句) {
		循环体语句;
	}
执行流程：
       1.执行初始化表达式语句;
	   2.执行判断条件语句,看其返回值是true还是false,如果是true，就继续执行;如果是false，就结束循环;
       3.执行循环体语句;
	   4.执行控制条件语句;
	   5.回到2中继续执行流程	
注意： 
    1.初始化表达式语句只执行一次;
    2.判断条件语句无论简单还是复杂结果是boolean类型;
	3.一般来说：有左大括号就没有分号，有分号就没有左大括号

//用for循环打印9*9乘法表
package org.westos.demo1;
public class Demo3 {
    public static void main(String[] args) {
        for (int i=1;i<=9;i++){  //i控制行数
        for (int j=1;j<=i;j++){  //j控制列数
                System.out.print(j+"*"+i+"="+i*j+'\t');//'\t'空出一个Tab位；
            }System.out.println();
        }
    }
}

结果：

• while语句

循环结构while语句的格式：
	    初始化条件语句;
	    while(判断条件语句) {
			 循环体语句;
			 控制条件语句;
	   }
执行流程：
	a:执行初始化条件语句;
	b:执行判断条件语句,看其返回值是true还是false
		如果是true，就继续执行
		如果是false，就结束循环
	c:执行循环体语句;
	d:执行控制条件语句
	e:回到b继续。

• do…while语句

循环结构do...while语句的格式；
		初始化条件语句;
		do {
			循环体语句;
			控制条件语句;
		}while(判断条件语句);
执行流程：
	a:执行初始化条件语句;
	b:执行循环体语句;
	c:执行控制条件语句;
	d:执行判断条件语句,看其返回值是true还是false
		如果是true，就继续执行
		如果是false，就结束循环
	e:回到b继续。

死循环：
1.一定要注意控制条件语句控制的那个变量的问题，不要丢失，否则就容易死循环；
2.两种最简单的死循环格式
while(true){…}
for(；；){…}
三种循环语句的区别:
(1)do…while循环至少执行一次循环体，而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句；
(2)如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环，不知道用for循环，因为变量及早的从内存中消失，可以提高内存的使用效率；
(3)建议优先考虑for循环，然后是while循环 ，最后是do…while循环

• 控制跳转语句
  1.什么是控制跳转语句
  前面我们已经说过了，Java中的goto是保留字，目前不能使用。虽然没有goto语句可以增强程序的安全性，但是也带来很多不便，比如说，我想在某个循环执行到某一步的时候就结束，现在就做不了这件事情，为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断。
  2.控制跳转语句的分类
  break 中断
  continue 继续
  return 返回
• break语句
  1.break语句的使用场景：
  (1).在选择结构switch语句中;
  (2).在循环语句中
  注意：离开使用场景的存在是没有意义的
  2.作用:
  (1).退出单层循环;
  (2).退出多层循环(几乎不使用)
  要想实现这个效果，就必须知道一个东西;带标签的语句；
  格式：标签名：语句
• continue语句
  1.continue的使用场景:
  (1).在循环语句中
  (2).离开使用场景的存在是没有意义的
  2.作用:
  跳出一次循环，执行下一步操作
• return 语句：
  return的作用：
  return 就是退出一个方法，跳转到上层调用的方法。

例1：

 public static void main(String[] args) {
       for (int i=0; i<3; i++) {
       for (int j=0; j<3; j++) {
       if (i == j) {
       break;}
System.out.println("i=" + i + ", j=" + j);
      }
}
/*运行结果：i=1, j=0
           i=2, j=0
           i=2, j=1
分析：第一个for循环，i=0,由判断语句i<3，可得为true，进入循环体语句，循环体包括第二个for循环；
      j=0，由判断语句j<3，可得为true，继续执行循环体语句，if（i==j），if语句值为true，所以进入if语句中；
      由于break存在，故跳出第二个for循环，再返回去执行第一个for循环中的控制条件语句i++，i变为2；再次对i<3进行判断，再进入循环体即第二个for语句，再判断if语句，if结果为false，此时i=1,j=0;打印i，j；
      再去执行第二个for循环的控制条件语句j++，此时i=1,j=1；if（i==j）值为true，由于break存在，故跳出第二个for循环执行完毕；
      再去执行第一个for中的i++，此时i=2，进入第二个for语句，此时j=0，执行if语句结果为false，打印i，j的值，i=2，j=0，再去执行第二个for循环的 j++，j=1，if语句判断结果为false，所以打印i=2，j=1，再次执行第二个for语句中的j++，if（i==j）值为true，由于break存在，故第二个for循环执行完毕；再返回进入第一个for中循环中的i++，i为3，结束整个循环，程序结束*/

例2：

 public static void main(String[] args) {
         for (int i=0; i<3; i++) {
          for (int j=0; j<3; j++) {
           if (i == j) {
           continue;}
System.out.println("i=" + i + ", j=" + j);
  }
}
/*运行结果：i=0, j=1
           i=0, j=2
           i=1, j=0
           i=1, j=2
           i=2, j=0
           i=2, j=1
分析：先执行第一个for循环，i=0，进入第二个for循环中，j=0，if语句结果为true，由于continue存在，所以跳过此次循环；
     返回第二个for循环中的j++，j=1，if 语句值为false，打印i=0，j=1，再次返回第二个for循环中的j++，j=2，if值为false，打印i=0，j=2；
     再次返回第二个for循环中的j++，j=3，由于j<3，所以第二个for循环结束，返回第一个for循环的i++，i=1，重复进行以上操作，
*/

例3：

int i=1,j=10;
do {
if ( i++>--j ) 
continue;
} while ( i<5 );
System.out.println("i=" + i + ", j=" + j);
/*运行结果： i=5，j=6
分析：先执行初始化语句int i=1,j=10;
     再执行循环体语句if ( i++>--j )；i=1，j=9，if值为false，i再自增为2；
     由于continue，所以跳过此次循环，继续执行代码，i++< --j；
     i=2，j=8，if值为false，i再自增为3，由于continue，所以再次跳过此次循环，直到i=5，j=6打印即可*/

//下篇再见…谢谢