语句

1:switch语句(掌握)
(1)格式：
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
…
default:
语句体n+1;
break;
}

    格式解释说明：  
        switch:说明这是switch语句。  
        表达式:可以是byte,short,int,char  
            JDK5以后可以是枚举  
            JDK7以后可以是字符串  
        case:后面的值就是要和表达式进行比较的值  
        break:表示程序到这里中断，跳出switch语句  
        default:如果所有的情况都不匹配,就执行这里,相当于if语句中的else  
(2)面试题  
    switch语句的表达式可以是byte吗?可以是long吗?可以是String吗?  
        可以,不可以,JDK7以后可以  
(3)执行流程:  
    A:首先计算表达式的值  
    B:和每一个case进行匹配，如果有就执行对应的语句体，看到break就结束。  
    C:如果没有匹配，就执行default的语句体n+1。  
(4)注意事项:  
    A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的  
    B:default可以省略吗?  
        可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。  
        特殊情况：  
            case就可以把值固定。  
            A,B,C,D  
    C:break可以省略吗?  
        可以省略，但是结果可能不是我们想要的。  
        会出现一个现象：case穿透。  
        最终我们建议不要省略  
    D:default一定要在最后吗?  
        不是，可以在任意位置。但是建议在最后。  
    E:switch语句的结束条件  
        a:遇到break就结束了  
        b:执行到末尾就结束了  
(5)案例：  
    A:键盘录入一个数字(1-7),输出对应的星期几。  
    B:单项选择题  
    C:键盘录入一个字符串的问题  
        String s = sc.nextLine();  
    D:根据给定的月份,输出对应的季节  
(6)if语句和switch语句各自的场景  
    A:if  
        针对boolean类型的判断  
        针对一个范围的判断  
        针对几个常量的判断  
    B:switch  
        针对几个常量的判断

2:循环语句(掌握)
(1)有三种:for,while,do…while
(2)for循环语句
A:格式
for(初始化语句;判断条件语句;控制条件语句){
循环体语句;
}

        执行流程：  
            a:执行初始化语句  
            b:执行判断条件语句  
                如果这里是true，就继续  
                如果这里是false，循环就结束  
            c:执行循环体语句  
            d:执行控制条件语句  
            e:回到b  
    B:注意事项  
        a:判断条件语句无论简单还是复杂，结果是boolean类型  
        b:循环体语句如果是一条，可以省略大括号，但是不建议  
        c:有分号就没有左大括号，有左大括号就没有分号  
    C:案例  
        a:输出10次HelloWorld  
        b:输出1-10的数据  
        c:输出10-1的数据  
        d:求1-10的和  
        e:求1-100的和,求1-100的偶数和,求1-100的奇数和  
        f:求5的阶乘  
        g:在控制台打印水仙花数  
        h:统计水仙花个数  
        i:改进版的回文数  
            一个五位数  
            个位 = 万位  
            十位 = 千位  
            个位 + 十位 + 千位 + 万位 = 百位  
        j:统计1-1000之间同时满足如下条件的数据有多少个  
            x%3==2  
            x%5==3  
            x%7==2  
(3)while循环  
    A:基本格式  
        while(判断条件语句) {  
            循环体语句;  
        }

        扩展格式：  
        初始化语句;  
        while(判断条件语句){  
            循环体语句;  
            控制条件语句;  
        }

        通过查看这个格式，我们就知道while循环可以和for循环等价转换。  
    B:while的练习  
        把for语句的练习用while改进  
    C:for和while的区别  
        a:使用上的区别  
            for语句的那个控制条件变量,在循环结束后不能在使用了。  
            而while的可以继续使用。  
        b:理解上的区别  
            for适合于一个范围的判断  
            while适合次数不明确的  
                举例:吃葡萄  
    D:案例：  
        a:珠穆朗玛峰问题  
        b:小芳存钱问题(break以后才能做)  
(4)do...while循环  
    A:基本格式  
        do {  
            循环体语句;  
        }while(判断条件语句);

        扩展格式：  
        初始化语句;  
        do {  
            循环体语句;  
            控制条件语句;  
        }while(判断条件语句);

        通过查看格式，我们就可以看出其实三种循环的格式可以是统一的。  
    B:三种循环的区别  
        a:do...while循环至少执行一次循环体  
        b:for和while必须先判断条件是否是true，然后后才能决定是否执行循环体  
(5)循环使用的注意事项(死循环)  
    A:一定要注意修改控制条件,否则容易出现死循环。  
    B:最简单的死循环格式  
        a:while(true){...}

        b:for(;;){}

3:控制跳转语句(掌握)
(1)break:中断的意思
A:用在循环和switch语句中，离开此应用场景无意义。
B:作用
a:跳出单层循环
b:跳出多层循环，需要标签语句的配合
(2)continue:继续
A:用在循环中，离开此应用场景无意义。
B:作用
a:跳出单层循环的一次，可以继续下一次
C:填空题
for(int x=1; x<=10; x++) {
if(x%3 == 0) {
//补齐代码
}
System.out.println("Java基础班");
}
如何让控制台输出2次：Java基础班
如何让控制台输出7次：Java基础班
如何让控制台输出13次：Java基础班
(3)return:返回
A:用于结束方法的，后面还会在继续讲解和使用。
B:一旦遇到return,程序就不会在继续往后执行。

switch语句格式：

switch语句格式：

/*
switch语句格式：
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
…
default:
语句体n+1;
break;
}

格式的解释：  
    switch:表示这是switch选择结构  
    表达式:这个地方的取值是有限定的  
        byte,short,int,char  
        JDK5以后可以是枚举  
        JDK7以后可以是字符串  
    case:后面跟的是要和表达式进行比较的值  
    语句体:要执行的代码  
    break:表示中断，结束的意思，可以控制switch语句的结束。  
    default:当所有的值都和表达式不匹配的时候，就执行default控制的语句。其实它就相当于if语句的else。

实例：  
    byte可以作为switch的表达式吗? 可以  
    long可以作为switch的表达式吗? 不可以  
    String可以作为switch的表达式吗?  **jdk7以后可以**

案例：  
    键盘录入一个数据，根据这个数据，我们输出对应的星期?  
        键盘录入1,对应输出星期一  
        键盘录入2,对应输出星期二  
        ...  
        键盘录入7,对应输出星期日

分析：  
    1:键盘录入，用Scanner实现  
    2:判断我们既可以使用if语句，也可以使用我们要讲解的switch语句

注意：  
    A:遇到左大括号缩进一个tab的位置。  
    B:关联不是很大的语句间空行  

*/
import java.util.Scanner;

class SwitchDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

    //控制键盘录入数据  
    System.out.println("请输入一个数据(1-7):");  
    int week = sc.nextInt(); //3

    //switch判断语句  
    switch(week) {  
        case 1:  
            System.out.println("星期一");  
            break;  
        case 2:  
            System.out.println("星期二");  
            break;  
        case 3:  
            System.out.println("星期三");  
            break;  
        case 4:  
            System.out.println("星期四");  
            break;  
        case 5:  
            System.out.println("星期五");  
            break;  
        case 6:  
            System.out.println("星期六");  
            break;  
        case 7:  
            System.out.println("星期日");  
            break;  
        default:  
            System.out.println("你输入的数据有误");  
            break;  
    }  
}  

}

switch语句注意事项：

/*
switch语句的注意事项：
A:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
B:default可以省略吗?
可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
特殊情况：
case就可以把值固定。
A,B,C,D
C:break可以省略吗?
可以省略，但是结果可能不是我们想要的。
会出现一个现象：case穿透。
最终我们建议不要省略
D:default一定要在最后吗?
不是，可以在任意位置。但是建议在最后。
E:switch语句的结束条件
a:遇到break就结束了，不是遇到default就结束，因为default可以不放在结尾
b:执行到末尾就结束了
*/
import java.util.Scanner;

class SwitchDemo2 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

    //控制键盘录入数据  
    System.out.println("请输入一个数据(1-7):");  
    int week = sc.nextInt(); //3

    //定义常量  
    //int number = 3;  
    //然后把case后面的值改为number，就会报错

    //switch判断语句  
    switch(week) {  
        case 1:  
            System.out.println("星期一");  
            break;  
        case 2:  
            System.out.println("星期二");  
            break;  
        case 3:  
            System.out.println("星期三");  
            break;  
        case 4:  
            System.out.println("星期四");  
            break;  
        case 5:  
            System.out.println("星期五");  
            break;  
        case 6:  
            System.out.println("星期六");  
            break;  
        case 7:  
            System.out.println("星期日");  
            break;  
        default:  
            System.out.println("你输入的数据有误");  
            //break;  
    }  
}  

}

根据你键盘录入的字符串，判断是否有满足要求的，如果有就输出。

/*
根据你键盘录入的字符串，判断是否有满足要求的，如果有就输出。
否则，提示有误。

String s = sc.nextLine();  

*/
import java.util.Scanner;

class SwitchTest3 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

    //录入数据  
    System.out.println("请输入你要判断的字符串：");  
    String s = sc.nextLine(); // 拿字符串类型

    switch(s) {  
        case "hello":  
            System.out.println("你输入的是hello");  
            break;  
        case "world":  
            System.out.println("你输入的是world");  
            break;  
        case "java":  
            System.out.println("你输入的是java");  
            break;  
        default:  
            System.out.println("没有找到你输入的数据");  
            //break;  
    }  
}  

}

if语句和switch语句的区别?

/*
用switch语句实现键盘录入月份，输出对应的季节

分析：  
    A:键盘录入一个月份，用Scanner实现  
    B:用switch语句实现即可

if语句和switch语句的区别?  
    if语句：  
        A:针对结果是boolean类型的判断  
        B:针对一个范围的判断  
        C:针对几个常量值的判断

    switch语句：  
        针对几个常量值的判断  

*/
import java.util.Scanner;

class SwitchTest4 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

    //录入数据  
    System.out.println("请输入月份(1-12)：");  
    int month = sc.nextInt();

    /\*  
    switch(month) {  
        case 1:  
            System.out.println("冬季");  
            break;  
        case 2:  
            System.out.println("冬季");  
            break;  
        case 3:  
            System.out.println("春季");  
            break;  
        case 4:  
            System.out.println("春季");  
            break;  
        case 5:  
            System.out.println("春季");  
            break;  
        case 6:  
            System.out.println("夏季");  
            break;  
        case 7:  
            System.out.println("夏季");  
            break;  
        case 8:  
            System.out.println("夏季");  
            break;  
        case 9:  
            System.out.println("秋季");  
            break;  
        case 10:  
            System.out.println("秋季");  
            break;  
        case 11:  
            System.out.println("秋季");  
            break;  
        case 12:  
            System.out.println("冬季");  
            break;  
        default:  
            System.out.println("你输入的月份有误");  
    }  
    \*/

    //这样写太麻烦了，我们使用一个我们不想使用的东西：case穿透。**但是不太美观。应该选用if语句对范围判断**  
    switch(month) {  
        case 1:  
        case 2:  
        case 12:  
            System.out.println("冬季");  
            break;  
        case 3:  
        case 4:  
        case 5:  
            System.out.println("春季");  
            break;  
        case 6:  
        case 7:  
        case 8:  
            System.out.println("夏季");  
            break;  
        case 9:  
        case 10:  
        case 11:  
            System.out.println("秋季");  
            break;  
        default:  
            System.out.println("你输入的月份有误");  
    }  
}  

}

for循环语句

for循环语句格式：

/*
循环语句：for循环,while循环,do…while循环。

for循环格式：  
    for(初始化语句;判断条件语句;控制条件语句) {  
        循环体语句;  
    }

    执行流程：  
        A:执行初始化语句  
        B:执行判断条件语句,看其返回值是true还是false  
            如果是true，就继续执行  
            如果是false，就结束循环  
        C:执行循环体语句;  
        D:执行控制条件语句  
        E:回到B继续。

注意事项：  
    A:判断条件语句无论简单还是复杂结果是boolean类型。  
    B:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。  
    C:一般来说：有左大括号就没有分号，有分号就没有左大括号

需求：请在控制台输出10次"HelloWorld"  

*/
class ForDemo {
public static void main(String[] args) {
//最原始的做法
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("----------");

    //这种做法不好,代码的重复度太高。  
    //所以呢，我们用循环改进  
    for(int x=1;x<=10;x++) {  
        System.out.println("HelloWorld");  
    }  
}  

}

在控制台输出所有的”水仙花数”：

/*

需求：在控制台输出所有的”水仙花数”

分析：  
    我们都不知道什么叫"水仙花数"，你让我怎么做呢?

    所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。  
    举例：153就是一个水仙花数。  
    153 = 1\*1\*1 + 5\*5\*5 + 3\*3\*3 = 1 + 125 + 27 = 153

    A:三位数其实是告诉了我们范围。  
    B:通过for循环我们就可以实现获取每一个三位数  
      但是麻烦是如何获取这个三位数的个,十,百位上的数据

      我们如何获取一个数据的个,十,百呢?  
        假设有个一个数据:153  
        ge:    153%10 = 3  
        shi: 153/10%10 = 5 //除号/，只能得到整数，要得到小数，需要有一个为小数  
        bai：153/10/10%10 = 1  
        qian：x/10/10/10%10  
        wan:  x/10/10/10/10%10  
        ...

    C:让ge\*ge\*ge+shi\*shi\*shi+bai\*bai\*bai和该数据比较  
      如果相同，就把该数据在控制台输出。  

*/
class ForDemo6 {
public static void main(String[] args) {//三位数其实是告诉了我们范围。
for(int x=100; x<1000; x++) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;

        //让ge\*ge\*ge+shi\*shi\*shi+bai\*bai\*bai和该数据比较  
        if(x == (ge\*ge\*ge+shi\*shi\*shi+bai\*bai\*bai)) {  
            //如果相同，就把该数据在控制台输出。  
            System.out.println(x);  
        }  
    }  
}  

}

while循环

while循环基本格式：

/*
while循环的基本格式：
while(判断条件语句) {
循环体语句;
}

    扩展格式：

    初始化语句;  
    while(判断条件语句) {  
         循环体语句;  
         控制条件语句;  
    }

    通过这个格式，我们就可以看到其实和for循环是差不多的。

    for(初始化语句;判断条件语句;控制条件语句) {  
        循环体语句;  
    }  

*/
class WhileDemo {
public static void main(String[] args) {
//输出10次"HelloWorld"
//for语句版
for(int x=0; x<10; x++) {
System.out.println("HelloWorld");
}
System.out.println("--------------");
//while语句版
int x=0;
while(x<10) {
System.out.println("HelloWorld");
x++;
}

}  

}

while循环和for循环的区别?

/*
while循环和for循环的区别?
使用区别：如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。
不知道用for循环。
因为变量及早的从内存中消失，可以提高内存的使用效率。

    其实还有一种场景的理解:  
        如果是一个范围的，用for循环非常明确。  
        如果是不明确要做多少次，用while循环较为合适。  
            举例：吃葡萄。  

*/
class WhileDemo4 {
public static void main(String[] args) {
//for循环实现
for(int x=0; x<10; x++) {
System.out.println("学习Java技术哪家强,中国北京传智播客");
}
//这里不能在继续访问x了，因为这个x这是在大括号里有效
//System.out.println(x);

    //while循环实现  
    int y = 0;  
    while(y<10) {  
        System.out.println("学习Java技术哪家强,中国北京传智播客");  
        y++;  
    }  
    //这里是可以继续访问y  
    System.out.println(y);  
}  

}

厚度为0.01m的纸张折叠多少次，就可以保证厚度不低于珠穆朗玛峰8848m的高度?

/*
我国最高山峰是珠穆朗玛峰：8848m，
请问，厚度为0.01m的纸张折叠多少次，就可以保证厚度不低于珠穆朗玛峰8848m的高度?

分析：  
    A:定义一个统计变量，默认值是0  
    B:最高山峰是珠穆朗玛峰：8848m这是最终的厚度  
      我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度  
    C:我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?  
      折叠一次有什么变化呢?就是厚度是以前的2倍。  
    D:只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++  
    E:输出统计变量。  

*/

class WhileDemo5 {
public static void main(String[] args) {
//定义一个统计变量，默认值是0
int count = 0;

    //最高山峰是珠穆朗玛峰：8848m这是最终的厚度  
    //我现在有一张足够大的纸张，厚度为：0.01m这是初始厚度  
    //为了简单，我把0.01变成1，同理8848就变成了884800  
    int end = 884800;  
    int start = 1;

    while(start<end) {  
        //只要每次变化的厚度没有超过珠穆朗玛峰的高度，就折叠，统计变量++  
        count++;

        //折叠一次有什么变化呢?就是厚度是以前的2倍。  
        start \*= 2;

        System.out.println("第"+count+"次厚度是"+start);  
    }

    //输出统计变量。  
    System.out.println("要叠"+count+"次");  
}  

}

do…while

do…while语句格式：

/*
do…while循环的基本格式：
do {
循环体语句;
}while(判断条件语句);

    扩展格式；  
    初始化语句;  
    do {  
        循环体语句;  
        控制条件语句;  
    }while(判断条件语句);  

*/
class DoWhileDemo {
public static void main(String[] args) {

    //求和1-100  
    int sum = 0;  
    int a = 1;  
    do {  
        sum += a;  
        a++;  
    }while(a<=100);

    System.out.println(sum);  
}  

}

for、while于do..while语句区别

/*
循环语句的区别:
do…while循环至少执行一次循环体。
而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。

那么，我们一般使用哪种循环呢?  
    优先考虑for，其次考虑while，最后考虑do...while  

*/
class DoWhileDemo2 {
public static void main(String[] args) {
int x = 3;
while(x < 3) {
System.out.println("我爱林青霞");
x++;
}

    System.out.println("--------------");

    int y = 3;  
    do {  
        System.out.println("我爱林青霞");  
        y++;  
    }while(y < 3);  
}  

}

注意死循环

/*
注意死循环：
A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
B:两种最简单的死循环格式
while(true){…}
for(;;){…}

*/
class DoWhileDemo3 {
public static void main(String[] args) {
int x = 0;
while(x < 10) {
System.out.println(x);
x++;
}
System.out.println("--------------");

    /\*  
    while(true) {  
        System.out.println("今天我很高兴，学习了死循环");  
    }  
    \*/

    /\*  
    死循环  
    for(;;){  
        System.out.println("今天我很高兴，学习了死循环");  
    } \*/

    //System.out.println("--------------");  
}  

}

在控制台输出在控制台输出九九乘法表：

/*
需求：在控制台输出九九乘法表。

首先我们写出九九乘法表：  
    1\*1=1  
    1\*2=2    2\*2=4  
    1\*=3    2\*=6    3\*=9  
    1\*4=4    2\*4=8    3\*4=12    4\*4=16  
    ...  
    1\*9=9    2\*9=18    3\*9=27    ...

我们先把这个九九乘法表看出是这样的一个形状：  
    \*  
    \*\*  
    \*\*\*  
    \*\*\*\*  
    \*\*\*\*\*  
    \*\*\*\*\*\*  
    \*\*\*\*\*\*\*  
    \*\*\*\*\*\*\*\*  
    \*\*\*\*\*\*\*\*\*

注意：  
    '\\x' x表示任意，这种做法叫转移字符。

    '\\t'    tab键的位置  
    '\\r'    回车  
    '\\n'    换行  

*/
class ForForDemo3 {
public static void main(String[] args) {
for(int x=0; x<9; x++) {
for(int y=0; y<=x; y++) {
System.out.print("*");
}
System.out.println();
}
System.out.println("--------------");
//为了使用数据，我们从1开始
for(int x=1; x<=9; x++) {
for(int y=1; y<=x; y++) {
System.out.print(y+"*"+x+"="+y*x+"\t");
}
//我们可以通过空的输出语句实现换行：System.out.println();
System.out.println();
}
}
}

break、continue、return语句

break:中断：

/*
控制跳转语句：
break:中断
continue:继续
return:返回

break:中断的意思  
使用场景：  
    A:switch语句中  
    B:循环语句中。  
        (循环语句中加入了if判断的情况)  
    注意：离开上面的两个场景，无意义。

如何使用呢?  
    A:跳出单层循环  
    B:跳出多层循环 ---用得比较少  
        要想实现这个效果，就必须知道一个东西。带标签的语句。  
        格式：  
            标签名: 语句  

*/
class BreakDemo {
public static void main(String[] args) {
//在 switch 或 loop 外部中断
//break;

    //跳出单层循环  
    for(int x=0; x<10; x++) {  
        if(x == 3) {  
            break;  
        }  
        System.out.println("HelloWorld");  
    }

    System.out.println("over");  
    System.out.println("-------------");

    //跳出多层循环  
    wc:for(int x=0; x<3; x++) {  
        nc:for(int y=0; y<4; y++) {  
            if(y == 2) {  
                //break nc;//跳出单层循环  
                break wc; //这里跳出多层循环  
            }  
            System.out.print("\*");  
        }  
        System.out.println();  
    }  
}  

}

continue:继续：

/*
continue:继续

使用场景：  
    循环中。离开此场景无意义。

测试，找到和break的区别：  
    break:跳出单层循环  
    continue:跳出一次循环，进入下一次的执行

练习题：  
    for(int x=1; x<=10; x++) {  
        if(x%3==0) {  
            //在此处填写代码  
        }  
        System.out.println(“Java”);  
    }

    我想在控制台输出2次:“Java“  
        break;

    我想在控制台输出7次:“Java“  
        continue;

*/
class ContinueDemo {
public static void main(String[] args) {
for(int x=0; x<10; x++) {
if(x == 3) {
//break;
continue;
}

        System.out.println(x);  
    }  
}  

}

return语句：

/*
return:返回

其实它的作用不是结束循环的，而是结束方法的。  

*/
class ReturnDemo {
public static void main(String[] args) {
for(int x=0; x<10; x++) {
if(x == 2) {
System.out.println("退出");
//break;
//continue;
return;
}

        System.out.println(x);  
    }

    System.out.println("over");  
}  

}

执行结果：return后面的语句都不会执行。

实例：

需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，
每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，
请问，经过多少天，小芳才可以存到100元钱。

/*
需求：小芳的妈妈每天给她2.5元钱，她都会存起来，但是，
每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，
请问，经过多少天，小芳才可以存到100元钱。

分析：  
    A:小芳的妈妈每天给她2.5元钱  
        double dayMoney = 2.5;  
    B:她都会存起来  
        double daySum = 0;  
    C:从第一天开始存储  
        int dayCount = 1;  
    D:经过多少天，小芳才可以存到100元钱。  
        double result = 100;  
    E:这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，  
        说明要判断dayCount的值，如果对5整除就减去6元钱。  
            daySum -= 6;  
      由此还隐含了一个问题，就是如果不是5的倍数天的话，钱要累加  
            daySum += dayMoney;  
    F:因为不知道是多少天，所以我用死循环，一旦超过100元我就退出循环。  

*/
class WhileDemo {
public static void main(String[] args) {
//每天要存储的钱是2.5元
double dayMoney = 2.5;

    //存钱的初始化值是0  
    double daySum = 0;

    //从第一天开始存储  
    int dayCount = 1;

    //最终存储不小于100就不存储了  
    int result = 100;

    //因为不知道是多少天，所以我用死循环，  
    while(true) {  
        //累加钱  
        daySum += dayMoney;

        //一旦超过100元我就退出循环。  
        if(daySum >= result) {  
            System.out.println("共花了"+dayCount+"天存储了100元");  
            break;  
        }

        if(dayCount%5 == 0) {  
            //花去6元钱  
            daySum -= 6;  
            System.out.println("第"+dayCount+"天花了6元钱");  
        }

        //天数变化  
        dayCount++;  
    }  
}  

}

执行结果：