每周记录我的编程学习–Java篇2

流程控制语句

到目前为止，之前的所有的程序运行都维持一个原则，从main方法开始，从上往下顺序执行；因此之前的所有程序结构都是典型的顺序结构；但是java中程序的执行，往往根据业务的不同，程序的执行顺序也会有一些相应变化，java中针对实际业务来说提供了另外的一些执行结构：

一、条件分支语句

Java中的分支语句分为两种常见结构：
（1）if…else
( 2 ) switch…case

1.if…else语句

语法：

if(布尔条件表达) {
		
			 //条件成立时（true）执行
		}else {
			 //条件不成立（false）时执行
		}

关于if…else语句也分为三种执行结构：
1.

if(布尔表达式){
//条件成立执行
				}

根据输入的一个年份，如果该年份是闰年，则输出”闰年“ 否则不做任何操作

代码如下：	
Scanner sc = new Scanner(System.in);
int y = sc.nextInt();
if((y % 4 == 0 && y % 100 != 0)  || y % 400 == 0) {
System.out.println(y+"是闰年");
}

=================================
2.

if(布尔类型表达式){
//条件成立时执行
		}else{
//条件不成立时执行
						}

=================================
3.

if(布尔表达式){
//条件成立执行
	}else if(布尔表达式){
//条件成立执行
	}else if(布尔表达式){
//条件成立执行
	}else{
//以上条件均不满足时执行
	}

完成一个商品打折功能的方法，提供商品的单价和购买数，根据购买数量的不同给出相应的折扣,购买数：

  • 小于 5 原价
  • 5~10(不含)之间 打95折
  • 10~20(不含)之间 打9折
  • 20以上 打8折
  • 求总价格并返回价格
代码如下：
   public double totalPrice(double price,int count) 			{
     //初始折扣为0
     double offset = 0.0;
     //根据购买数量动态调整折扣
     if(count < 5) {
         offset = 1;
     }else if(count < 10) {
         offset = 0.95;
     }else if(count < 20) {
         offset = 0.9;
     }else {
         offset = 0.8;
     }
     return offset * price * count;
 }

 public static void main(String[] args) {

     Demo d = new Demo();
     double total = d.totalPrice(5.5, 20);
     System.out.println("总价格:"+total);
 }

}

2.switch…case语句

Switch用在编程中，它经常跟Case一起使用，是一个判断选择代码。其功能就是控制流程流转的。

直线翻译：switch语句，即“切换”语句；case即“情况”。

switch语句的语法如下

(switch，case，break和default是关键字)：

switch ( 变量表达式 )
{
case 常量1 :语句;break;
case 常量2 :语句;break;
case 常量3 :语句;break;
...
case 常量n:语句;break;
 
default :语句;break;
}

当变量表达式（固定值）所表达的量与其中一个case语句中的常量相等时，就执行此case语句后面的语句，并依次下去执行后面所有case语句中的语句，除非遇到break;语句跳出switch语句为止 如果变量表达式的量与所有case语句的常量都不相符，就执行default语句中的语句。

遵守switch语句规则

switch语句非常有用，但在使用时必须谨慎。所写的任何switch语句都必须遵循以下规则：

  1. byte short int
  2. char
  3. String （JDK1.7+）
  4. enum（枚举，JDK1.5+）

case标签必须是惟一性的表达式；也就是说，不允许两个case具有相同的值。

switch 语句举个栗子：

用switch …case 语句写一个对应季节就输出一句对应季节的诗

String s = SPRING;
    switch(s) {
    case SPRING:
        System.out.println("春眠不觉晓，处处闻啼鸟");
        break;
    case SUMMER:
        System.out.println("小荷才露尖尖角，早有蜻蜓立上头");
        break;
    case AUTUMN:
        System.out.println("停车坐爱枫林晚，霜叶红于二月花");
        break;
    case WINTER:
        System.out.println("孤舟蓑笠翁，独钓寒江雪");
        break;
}

二、循环控制语句

在以上对于条件分支的案例中，发现，有些程序在执行过程中如果不满足条件需要重复执行，而分支语句没法做到反复执行的能力，因此，Java中提供对于循环操作相关的解决方案；

循环可以用于反复执行某一个代码片段，必须循环打印输出，对某些结果集的遍历操作；
Java中的循环方分为以下几类:

  • for循环
  • while循环
  • do…while循环
  • *forEach（又称增强for循环）
    {由于初学者目前还不能很好的认识foreach，我重点讲解前三个类型}

1.for循环

语法：

for(初始变量;条件判断;更改变量) {
    //循环体
}

举个栗子：

for(int i = 1; i <= 100; i++) {
    System.out.println(i);
}

while循环

java中while循环包含两种呈现方式：

  1. while
  2. do…while
while语法
while(条件判断){
    //循环体
}
int i = 1;
while(i <= 100) {
    System.out.println(i);
    i++;
}
do…while语法
do{
    //循环体
}while(条件判断)
int j = 1;
do {
    System.out.println(j);
    j++;
}while(j <= 100);

while循环执行0次或多次

do…while执行1次或多次

for循环一般用于对循环次数确定的需求

while循环一般用于对循环次数不确定的需求

学完这些可以完成很多功能了，但是对于图形的打印，电影票选座等问题还不是很能完成所以引出接下来的…

嵌套循环

嵌套循环，即在循环语句中包含另一个循环

嵌套循环的执行流程：
从外向内，内层执行完毕再返回外层执行。
举个乘法表的栗子：

//行
for(int i = 1;i <= 9;i++) {
//列
for(int j = 1;j <= i;j++) {
    System.out.print(j + "*" + i + "=" + (i * j) + " ");
}
System.out.println();
}

结果如下：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

循环中断

通常情况下，循环语句只有在满足循环结束条件时才会结束，对于某些特殊需要，比如数到7的倍数跳过等需求；java中也提供用于跳出循环的关键字：

  • continue
    continue用于跳出循环结构中的某一次循环，后续次数的循环不受影响
for(int i = 1; i < 1000; i++) {
    if(i % 7 == 0) {
        //一旦i是7的倍数时，本次循环结束（不影响下一次）
        continue;
    }
    System.out.println(i);
}
  • break
    break在case语句中用于结束case；在循环中用于结束一层循环，如果有多层循环嵌套，也只会结束其中一层循环（循环标签除外）
for (int n = 0; n < 10; n++) {
  for(int i = 1; i < 1000; i++) {
  if(i % 7 == 0) {
      //内层循环结束（外层循环不受影响）
      break;
  }
  System.out.println(i);
  }
  }