面向对象程序设计-第二周

1、Java基础（流程控制）

        程序中最经典的三种执行顺序：顺序结构、分支结构、循环结构

        1.顺序结构：自上而下的执行代码顺序

        2.分支结构（if 和 switch）

                if分支有三种形式：

//题目：分数评级 [90-100] 优秀 [80-90) 良好 [70-80) 中等 [60-70) 及格 60 不及格
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入一个成绩：");
        int score = sc.nextInt();
        if (score <= 100 && score >= 90) {
            System.out.println("优秀");
        } else if (score < 90 && score >= 80) {
            System.out.println("良好");
        } else if (score < 80 && score >= 70) {
            System.out.println("中等");
        } else if (score < 70 && score >= 60) {
            System.out.println("及格");
        } else if (score < 60 && score >= 0) {
            System.out.println("不及格");
        } else {
            System.out.println("数据无效");
        }
    }

                switch分支通过比较具体值来决定执行哪条分支。

                switch分支的执行流程：

               （1）先执行表达式的值，再拿着这个值去与case后的值进行匹配。

               （2）与哪个case后的值匹配为true就执行哪个case块的代码，遇到break就跳出switch分支。

               （3）如果全部case后的值与之匹配都是false，则执行default块的代码。

Scanner sc = new Scanner(System.in);
String day = sc.nextLine();
switch (day) {
            case "周一":
                System.out.println("埋头苦干，解决bug");
                break;
            case "周二":
                System.out.println("请求大牛程序员帮忙");
                break;
            case "周三":
                System.out.println("今晚啤酒、龙虾、小烧烤");
                break;
            case "周四":
                System.out.println("KFC VME 50");
                break;
            case "周五":
                System.out.println("今晚吃鸡");
                break;
            case "周六":
                System.out.println("与王婆介绍的小芳相亲");
                break;
            case "周日":
                System.out.println("郁郁寡欢、准备上班");
                break;
            default:
                System.out.println("输入的日期有误");
                break;
        }

        if 和 switch的对比：当前条件是区间的时候，应该使用if分支结构； 当条件是与一个一个的值比较的时候，switch分支更合适。

        使用switch分支的几点注意事项：

        1.switch只能比较整型和字符、字符串，不支持比较小数

        2.case的值只能是精确值字面量，不能是变量，并且不能重复，如果没写break，会导致穿透

        3.但是穿透性可以帮忙完成某些功能，假设多个case分支执行的代码相同可以利用穿透性。

switch (day) {
            case "周一":
                System.out.println("埋头苦干，解决 bug");
                break;
            case "周二":
            case "周三":
            case "周四":
                System.out.println("请求大牛程序员帮忙");
                break;
            case "周五":
                System.out.println("自己整理代码");
                break;
            case "周六":
            case "周日":
                System.out.println("打游戏");
                break;
            default:
                System.out.println("输入的日期有误");
                break;
        }

        3.循环结构（for 和 while ）

        循环语句指的是一段代码可以重复执行多次。 

        for循环语句格式：

        for (初始化语句; 循环条件; 迭代语句)

         {     

                循环体语句(重复执行的代码);

        }

// 输出3次HelloWorld
for (int i = 0; i < 3; i++) {    
    System.out.println("Hello World");
}

        for循环简单案例：

//案例1：求和1-100 sum1
        int sum1 = 0;
        for (int i = 1; i <= 100; i++) {
            sum1 += i;
        }
        System.out.println(sum1);

//案例2：求和1-100奇数和 sum2 循环体判断是否为奇数
        int sum2 = 0;
        for (int i = 1; i <= 100; i++) {
            if(i %2 != 0){
                sum2 += i;
            }
        }
        System.out.println(sum2);//5050

//案例3：和案例2一样 循环体只能出现奇数
        int sum3 = 0;
        for (int i = 1; i <= 100; i+=2) {
            sum3 += i;
        }
        System.out.println(sum3);

        while循环语句的格式：

        初始化语句;

        while (循环条件)

        {    

                循环体语句(被重复执行的代码);    

                迭代语句;

        }

int i = 0;
while (i < 3) 
{    
    System.out.println("Hello World");
    i++;
}

        while循环案例：纸张折叠成珠穆朗玛峰的高度

        需求：世界最高山峰珠穆朗玛峰高度是：8848.86米=8848860毫米，假如我有一张足够大的纸，它的厚度是0.1毫米。请问：该纸张折叠多少次，可以折成珠穆朗玛峰的高度？

double peakHeight = 8848869; 
double paperHeght = 0.1;
//定义变量存储珠穆朗玛峰的高度、纸张的高度。
int count = 0;
//定义变量存储折叠次数
while (paperHeght < peakHeight) //循环条件是（纸张厚度<山峰高度）
{
    paperHeght = paperHeght * 2;
    count ++;
}
System.out.println("当前折叠了"+count);
System.out.println(paperHeght);

        小结：for循环和while循环的执行流程是一模一样的，功能上无区别，for能做的while也能做，反之亦然。 for和while的使用场景：如果已知循环次数建议使用for循环，如果不清楚要循环多少次建议使用while循环。

        死循环：可以一直执行下去的一种循环，如果没有干预不会停下来。

//死循环的基本写法
for ( ; ; ) 
{
    System.out.println("Hello World1");
}
while (true) 
{
    System.out.println("Hello World2");
}

        嵌套循环：指在循环中又包含循环。

        特点：外部循环每循环一次，内部循环会全部执行完一轮。

        案例1：输出4行5列的*

        for (int i = 0; i < 4; i++) {   //i外循环 i行数
            for (int j = 0; j < 5; j++) {  //j内循环 j列数
                System.out.print("*");      //内循环*连续打印一行
            }
            System.out.println();            //外循环换行
        }

        案例2：输出99乘法表

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

        掌握循环体里面跳转关键字break和continue的使用：

        break ：跳出并结束当前所在循环的执行。

        continue：用于跳出当前循环的当次执行，直接进入循环的下一次执行。

        //1.break 惹老婆生气罚我洗碗，我每天要洗碗洗了5天，第三天洗完表现不错，45就不需要了
        for (int i = 1; i <= 5; i++) {
            System.out.println("洗碗"+i);
            if (i == 3)
            {
                break;//直接跳出整个循环体
            }
        }

        System.out.println("------");
        //2.continue 洗碗 5天  第三天出去吃大餐 不用洗  1245是需要的
        for (int i = 1; i <= 5; i++) {
            if (i ==3)
            {
                continue; //结束当次  执行下一次循环
            }
            System.out.println("洗碗"+i);
        }

        

        多学习一点内容：生成随机数Random

        利用random生成随机数步骤如下：

        1.导包import random （IDEA软件自动导包，不需要我们写代码）

        2.创建一个random对象，用来生成随机数

        3.调用random提供的功能，nextint（）得到随机数0到9

        Random r = new Random(); 

        for (int i = 0; i < 20; i++) {
            int data = r.nextInt(10);      //默认从0开始，生成的是0-9
            //随机数范围 只会生成整数[0, x)   左取右不取
            System.out.println(data);
        }

        //生成1-10   
        for (int i = 0; i < 20; i++) {
            int data = r.nextInt(10)+1; 
            System.out.println(data);
        }

        //生成3-17    [3,18)  
        for (int i = 0; i < 20; i++) {
            int data = r.nextInt(3,18);
            System.out.println(data);
        }

2、Java基础（数组）

        数组是一个容器，用来存一批同种类型的数据。

        例子：存放整数类型数据用到int[ ]  存放字符串类型数据使用String[ ]

        数组定义的方式： 数据类型[ ]  变量名 = new  数据类型[ ] {数据1，数据2，...}

        简化写法： 数据类型[ ] 变量名 = {数据1，数据2，...}

//20, 10, 80, 60, 90
int[] arr = {20, 10, 80, 60, 90};

//牛二, 西门, 全蛋
String[] names = {"牛二", "西门", "全蛋"};

        定义数组有两种方式：静态初始化数组和动态初始化数组。

        1、静态初始化数组：定义数组的时候直接给数组赋值。注：定义结束后长度已经固定，不可添加或删除数据，但可修改数组中的数据。       数组存放的是数据在的地址，从下标0开始存储。

        int[] x = {10,20,30}; //数组地址从0开始
        //静态初始化数组   x.length 长度为3  x[0]=10 x[1]=20 x[2]=30
        for (int i = 0; i < x.length; i++) {
            System.out.println(x[i]);
        }  //遍历数据

        System.out.println(x[2]);    //当前x[2]=30
        x[2] = 100;                 // x[2]=30改为100
        System.out.println(x[2]);    //x[2]=100
        for (int i = 0; i < x.length; i++) {
            System.out.println(x[i]);
        }

        System.out.println(x.length); //当前静态初始化数组长度固定为3

       静态初始化数组案例1：对数组内的数据进行求和。

        int[] money = {16, 26, 36, 6, 100};//求和
        int sum =0;
        for (int i = 0; i < money.length; i++) {
            sum += money[i];  //16 + 26 +36 +6 +100
        }
        System.out.println(sum);

        静态初始化数组案例2： 求一组成绩数据中及格的人数。

        double[] score = {99, 100, 62, 15, 48, 65, 98, 99, 5, 59.5, 75};
        int count = 0;   //统计及格人数变量
        for (int i = 0; i < score.length; i++) {
            if(score[i]>60)
            {
                count++;
            }
        }
        System.out.println(count);

         2、动态初始化数组：定义数组时先不存入具体的数据，只确定数组存储的数据类型和数组的长度。

        例如：数据类型 []  数组名 = new 数据类型[长度];

                int[ ] a= new int[3];   //定义了一个数组变量a，长度为3，能装3个整形数据

        注意：静态初始化和动态初始化数组的写法是独立的，不可以混用。

                int[ ] arr = new int[3]{30，40，50};   //这种混合定义方式是错的

        在定义了一个动态初始化数组后，如果没有数据赋值的情况下，数组里面是有默认值的。默认值类型如下表所示：

数据类型	明细	默认值
基本类型	byte、short、char、int、long	0
	float、double	0.0
	boolean	false
引用类型	类、接口、数组、String	null

                int[ ] a= new int[3]; //例如这是数组a，直接输出结果为3个0的默认值。

        动态初始化数组案例分析：评委打分案例

        某歌唱比赛，需要开发一个系统：可以依次录入6名评委的打分，录入完毕后立即输出平均分做为选手得分。

//1.定义一个动态初始化数组，长度为6
    double[] scores = new double[6];
//2.遍历数组中的每个位置，每次提示用户录入一个评委的分数
// 并存入到数组对应的位置。
//3.循环遍历过程中对每个元素进行求和，最终算出平均分打印出来即可。
    Scanner sc = new Scanner(System.in);
    double sum = 0;
    for (int i = 0; i < scores.length; i++) 
    {
        System.out.println("请输入第"+(i+1)+"个评分的分数：");
        scores[i] = sc.nextDouble();
        sum += scores[i];
    }

    System.out.println("选手的最终得分为"+sum / scores.length);

        思考题：上述案例中6个分数，如果去掉最高分，去掉最低分，再求平均分，请改写程序。

        数组案例拓展1：求数组最大值

        //把数据用数组装起来。求最大值
        int[] facesocres = {15, 9000, 10000, 20000, 9500, -5};
        //定义一个变量用于记录最终的最大值。
        int max = facesocres[0]; //建议赋值第一个数据，如果初始为0，数组都是负数则无效
        //从第二个位置开始：遍历数组的数据，如果遍历的当前数据
        // 大于max变量存储的数据，则替换变量存储的数据为当前数据。
        for (int i = 0; i < facesocres.length; i++) {
            if (facesocres[i] > max) {
                max = facesocres[i];
            }
        }
        System.out.println(max);

        数组案例拓展2：数组反转输出

        //数组数据反转输出
        //1.定义一个数组
        int[] arr = {10,20,30,40,50,60,70,80,90};
        //2.循环体中定义两个变量分别指向数组第一个和数组最后一个
        for (int i = 0, j = arr.length -1; i < j; i++,j--) 
        {
            //定义一个临时变量用于首尾互换
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        //3.遍历数组 反转输出数据 加空格隔开
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }