A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

package day9Test;
/**
* 总结switch,for,while,do.跳转语句
* 1:switch语句
*   (1)格式:
*       switch(表达式){
*                       case 值1:
*                               语句体1;
*                   break;
*                       case 值1:
*                               语句体1;
*                   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:执行到末尾就结束了
* @author Administrator
*
*/
/*import java.util.Scanner;
public class SwithDemo1 {

        public static void main(String[] args) {
                Scanner sc=new Scanner(System.in);//键盘录入对象
                System.out.println("请输入第一个数据(1-7):");//控制键盘录入数据
                int week = sc.nextInt();
                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;
                }
        }

}
*/

        (5)案例:
                A:键盘录入一个数字(1-7),输出对应的星期几。
                B:单项选择题
                C:键盘录入一个字符串的问题
                        String s = sc.nextLine();
                D:根据给定的月份,案例:               
/*        A:
                键盘录入一个数据,根据这个数据,我们输出对应的星期?
                键盘录入1,对应输出星期一
                键盘录入2,对应输出星期二
                ...
                键盘录入7,对应输出星期日
                   
        分析:
                1:键盘录入,用Scanner实现
                2:判断我们既可以使用if语句,也可以使用我们要讲解的switch语句
               
        注意:
                A:遇到左大括号缩进一个tab的位置。
                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
               
                //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;
                }
        }
}

/*    B:       
        模拟单项选择题。
       
        分析:
                A:出一个选择题,然后供你选择。
                B:键盘录入选择的数据。
                C:根据选择来给出你选择的结论。
*/
import java.util.Scanner;

class SwitchTest2 {
        public static void main(String[] args) {
                //出一个选择题,然后供你选择。
                //由于我们现在没有办法键盘录入得到一个'A','B'
                //这样的东西,我就用65,66这样的值替代
                //将来我们获取到这样的值以后,强制转换为字符类型
                System.out.println("下面的几个人你最爱谁?");
                System.out.println("65 林青霞");
                System.out.println("66 张曼玉");
                System.out.println("67 刘德华");
                System.out.println("68 王力宏");
               
                //键盘录入选择的数据。
                Scanner sc = new Scanner(System.in);
               
                System.out.println("请输入你的选择:");
                int choiceNumber = sc.nextInt();
               
                //强制转换为字符类型
                char choice = (char) choiceNumber;
               
                switch(choice) {
                        case 'A':
                                System.out.println("恭喜你,选择正确");
                                break;
                        case 'B':
                                System.out.println("不好意思,你选择有误");
                                break;
                        case 'C':
                                System.out.println("不好意思,你选择有误");
                                break;
                        case 'D':
                                System.out.println("不好意思,你选择有误");
                                break;
                        default:
                                System.out.println("没有该选项");
                                break;
                }
        }
}

/*    C:

        根据你键盘录入的字符串,判断是否有满足要求的,如果有就输出。
        否则,提示有误。
       
        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;
                }
        }
}

/*    D:

        用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穿透
                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("你输入的月份有误");
                }
        }
}

        扩展

        /*
        看程序写结果
*/
class SwitchTest {
        public static void main(String[] args) {
                int x = 2;
                int y = 3;
                switch(x){
                        default:
                                y++;
                                break;
                        case 3:
                                y++;
                        case 4:
                                y++;
                }
                System.out.println("y="+y);
                System.out.println("---------------");
               
                int a = 2;
                int b = 3;
                switch(a){
                        default:
                                b++;
                        case 3:
                                b++;
                        case 4:
                                b++;
                }
                System.out.println("b="+b);
        }
}
        (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
/*    a:
        循环语句: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");
                }
        }
}

/*    b:
        需求:请在控制台输出数据1-10
*/
class ForDemo2 {
        public static void main(String[] args) {
                //原始做法
                System.out.println(1);
                System.out.println(2);
                System.out.println(3);
                System.out.println(4);
                System.out.println(5);
                System.out.println(6);
                System.out.println(7);
                System.out.println(8);
                System.out.println(9);
                System.out.println(10);
               
                System.out.println("-------------");
               
                //如何改进呢?用循环改进
                for(int x=1; x<=10; x++) {
                        System.out.println(x);
                }
               
                System.out.println("-------------");
               
                //从0开始
                for(int x=0; x<10; x++) {
                        System.out.println(x+1);
                }
        }
}       

/*    d:
        需求:求出1-10之间数据之和
       
        分析:
                0+1=1
                        1+2=3
                                3+3=6
                                        6+4=10
                                                10+5=15
                                                        ...
                                                         
                由此可见我们要定义两个变量:
                        一个变量用于存储第一个加数,第一个加数其实保存的是以前的所有数据和。默认初始化值应该是0。
                        一个变量用于存储第二个加数,第二个加数其实就是每次的数据变化的值。
                       
        求和思想。               
*/
class ForDemo3 {
        public static void main(String[] args) {
                //原始做法
                System.out.println(1+2+3+4+5+6+7+8+9+10);
               
                //定义第一个加数
                int sum = 0;
               
                for(int x=1; x<=10; x++) {
                        //这里的x其实是第二个加数
                        sum = sum + x;
                        /*
                                0 + 1 = 1
                                                1 + 2 = 3
                                                                3 + 3 = 6
                                                                ...
                        */
                       
                        //sum += x;
                }
               
                System.out.println("sum:"+sum);
        }
}

/*    e:
        需求:
                A:求1-100之和。
                B:求出1-100之间偶数和
                C:求出1-100之间奇数和(自己做)
*/
class ForDemo4 {
        public static void main(String[] args) {
                //求1-100之和。
                int sum1 = 0;
               
                for(int x=1; x<=100; x++) {
                        sum1 +=x;
                }
               
                System.out.println("1-100之和是:"+sum1);
                System.out.println("------------------");
               
                //求出1-100之间偶数和
                //方式1
                int sum2 = 0;
               
                for(int x=1; x<=100; x++) {
                        if(x%2 == 0) {
                                sum2 += x;
                        }
                }
               
                System.out.println("1-100偶数之和是:"+sum2);
                System.out.println("------------------");
               
                //方式2
                int sum3 = 0;
               
                for(int x=0; x<=100; x+=2) {
                                sum3 += x;
                }
               
                System.out.println("1-100偶数之和是:"+sum3);
                System.out.println("------------------");
        }
}
/*    f:
        需求:求5的阶乘。
       
        什么是阶乘呢?
                n! = n*(n-1)! 规则
                n! = n*(n-1)*(n-2)*...*3*2*1
               
        求和思想。
        求阶乘思想。
*/
class ForDemo5 {
        public static void main(String[] args) {
                //定义最终结果变量
                int jc = 1;
               
                //这里的x其实可以直接从2开始
                //for(int x=1; x<=5; x++)
               
                for(int x=2; x<=5; x++) {
                        jc *=x;
                }
               
                System.out.println("1-5的阶乘是:"+jc);
        }
}
/*    g:
        天将降大任于斯人也,必先盗其QQ,封其微博,收其wifi,夺其手机。让其静心学习Java欧耶。

        需求:在控制台输出所有的”水仙花数”
       
        分析:
                我们都不知道什么叫"水仙花数",你让我怎么做呢?
               
                所谓的水仙花数是指一个三位数,其各位数字的立方和等于该数本身。
                举例: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);
                        }
                }
        }
}
/*    h:

        需求:统计”水仙花数”共有多少个
       
        分析:
                A:首先必须知道什么是水仙花数
                        所谓的水仙花数是指一个三位数,其各位数字的立方和等于该数本身。
                        举例:153就是一个水仙花数。
                        153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
                B:定义统计变量,初始化值是0
                C:三位数告诉了我们范围,用for循环就可以搞定
                D:获取每一个三位数的个,十,百的数据
                E:按照要求进行判断
                F:如果满足要求就计数。
*/
class ForDemo8 {
        public static void main(String[] args) {
                //定义统计变量,初始化值是0
                int count = 0;
               
                //三位数告诉了我们范围,用for循环就可以搞定
                for(int x=100; x<1000; x++) {
                        //获取每一个三位数的个,十,百的数据
                        int ge = x%10;
                        int shi = x/10%10;
                        int bai = x/10/10%10;
                       
                        //按照要求进行判断
                        if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
                                //如果满足要求就计数。
                                count++;
                        }
                }
               
                System.out.println("水仙花数共有"+count+"个");
        }
}
/*    i:

        练习:
                请在控制台输出满足如下条件的五位数
                个位等于万位
                十位等于千位
                个位+十位+千位+万位=百位
               
        分析:
                A:五位数就告诉了我们范围。
                B:分解每一个五位数的个,十,百,千,万位上的数据
                C:按照要求进行判断即可
*/
class ForDemo7 {
        public static void main(String[] args) {
                //五位数就告诉了我们范围。
                for(int x=10000; x<100000; x++) {
                        //分解每一个五位数的个,十,百,千,万位上的数据
                        int ge = x%10;
                        int shi = x/10%10;
                        int bai  = x/10/10%10;
                        int qian = x/10/10/10%10;
                        int wan = x/10/10/10/10%10;
                       
                        //按照要求进行判断即可
                        if((ge==wan) && (shi==qian) && (ge+shi+qian+wan==bai)) {
                                System.out.println(x);
                        }
                }
        }
}

/*    j:
        需求:请统计1-1000之间同时满足如下条件的数据有多少个:
                        对3整除余2
                        对5整除余3
                        对7整除余2

        分析:
                A:定义统计变量,初始化值是0
                B:1-1000之间是一个范围,用for很容易就可以实现。
                C:每个数据要同时满足如下要求
                        x%3==2
                        x%5==3
                        x%7==2
                D:如果满足条件,统计数据++即可,最后输出统计变量
*/
class ForDemo9 {
        public static void main(String[] args) {
                //定义统计变量,初始化值是0
                int count = 0;
       
                //1-1000之间是一个范围,用for很容易就可以实现。
                for(int x=1; x<=1000; x++) {
                        /*
                                每个数据要同时满足如下要求
                                x%3==2
                                x%5==3
                                x%7==2
                        */
                        if(x%3==2 && x%5==3 && x%7==2) {
                                count++;
                                System.out.println(x);
                        }
                }
               
                //输出数据
                System.out.println("满足这样条件的数据共有:"+count+"个");
        }
}

        (3)while循环
                A:基本格式
                        while(判断条件语句) {
                                循环体语句;
                        }
                       
                        扩展格式:
                        初始化语句;
                        while(判断条件语句){
                                循环体语句;
                                控制条件语句;
                        }
                        通过查看这个格式,我们就知道while循环可以和for循环等价转换。
/*
        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++;
                }
               
        }
}
                B:while的练习
                        把for语句的练习用while改进

/*
        练习:用while循环实现
        左边:求出1-100之和
        右边:统计水仙花数有多少个
       
        初始化语句;
        while(判断条件语句) {
                循环体语句;
                控制条件语句;
        }
       
       
       
        for(初始化语句;判断条件语句;控制条件语句) {
                循环体语句;
        }

*/
class WhileDemo2 {
        public static void main(String[] args) {
                //求出1-100之和
                //for语句版本
                int sum = 0;
               
                for(int x=1; x<=100; x++) {
                        sum+=x;
                }
               
                System.out.println("sum:"+sum);
                System.out.println("--------");
                //while语句版本
                int sum2 = 0;
               
                int y=1;
                while(y<=100) {
                        sum2+=y;
                        y++;
                }
               
                System.out.println("sum2:"+sum2);
                System.out.println("--------");
        }
}

/*
        需求:统计水仙花数有多少个
*/
class WhileDemo3 {
        public static void main(String[] args) {
                //for循环版本
                int count = 0;
               
                for(int x=100; x<1000; x++) {
                        int ge = x%10;
                        int shi = x/10%10;
                        int bai = x/10/10%10;
                       
                        if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
                                count++;
                        }
                }
               
                System.out.println("count:"+count);
                System.out.println("------------");
               
                //while循环版本
                int count2 = 0;
               
                int y = 100;
                while(y<1000) {
                        int ge = y%10;
                        int shi = y/10%10;
                        int bai = y/10/10%10;
                       
                        if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) {
                                count2++;
                        }
                       
                        y++;
                }
               
                System.out.println("count2:"+count2);
        }
}
               
                C:for和while的区别
                        a:使用上的区别
                                for语句的那个控制条件变量,在循环结束后不能在使用了。
                                而while的可以继续使用。
                        b:理解上的区别
                                for适合于一个范围的判断
                                while适合次数不明确的
                                        举例:吃葡萄
/*
        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技术哪家强,中国北京传智播客");
                }
                //这里不能在继续访问了
                //System.out.println(x);
               
                //while循环实现
                int y = 0;
                while(y<10) {
                        System.out.println("学习Java技术哪家强,中国北京传智播客");
                        y++;
                }
                //这里是可以继续访问的
                System.out.println(y);
        }
}
                D:案例:
                        a:珠穆朗玛峰问题
                        b:小芳存钱问题(break以后才能做)
/*    a:

        我国最高山峰是珠穆朗玛峰:8848m,我现在有一张足够大的纸张,厚度为:0.01m。
        请问,我折叠多少次,就可以保证厚度不低于珠穆朗玛峰的高度?

        分析:
                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+"次");
        }
}

/*    b:
        需求:小芳的妈妈每天给她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++;
                }
        }
}
懂得分享才能学好Java,
Java开源有你的一份力量
你有好的资源可以分享给我;
记得写上你的名字,发表时会署名
邮箱:719329011@163.com

0 个回复

您需要登录后才可以回帖 登录 | 加入黑马