JavaDay2

选择结构Switch

package shujia.day02.ketang;
import java.util.Scanner;

/*
    Switch选择语句：
        语句定义格式：
            switch(表达式){
                case 常量值1:
                    表达式1;
                    break;
                case 常量值1:
                    表达式1;
                    break;
                case 常量值1:
                    表达式1;
                    break;
                ...
                default:
                    表达式1;
                    break;
            }
            
 */
public class SwitchDemo1 {
    public static void main(String[] args) {
        //需求：假设我现在所带的金额必须是正好对应饮料的价格
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您所带的金额：");
        int money = sc.nextInt();

        switch (money){
            default:
                System.out.println("没有您所带金额的饮料！！！");
                break;
            case 3:
                System.out.println("欢迎购买 可乐 ！！");
                break;
            case 5:
                System.out.println("欢迎购买红牛！！");
                break;
            case 6:
                System.out.println("欢迎购买旺仔牛奶！！");
                break;
            case 1:
                System.out.println("欢迎购买纯露！！！");
                break;

        }
      
    }
}

注意事项：
1、在jdk1.8的版本中，switch表达式类型是有限定，byte,short,int,char,字符串String,枚举
2、case后面只能跟常量值，不能是变量
3、执行流程：严格按照以下顺序执行：
1）先计算表达式的结果值
2）拿着结果值去自上而下匹配对应的case后面的常量值
3）若其中一个case后面的常量值与计算的结果值一致，那么就会执行对应case中的表达式，执行完后遇到break结束整个switch
4）若所有的case都不匹配，才会执行default语句中的表达式，执行完后遇到break结束整个switch

思考：
1、break语句能不能不写？可以不写，但是可能会造成switch穿透
2、default语句能不能不写？可以不写，但是程序可能不会那么的严谨
3、default语句一定要写在最后吗？不一定，可以写siwtch语句中的任意位置

循环结构for

java中的循环结构
普通for循环语句
while循环语句

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

注意事项：
1、初始化条件语句只会在循环开始的时候执行一次，后续不会执行

​ 2、初始化条件语句一定要写在for循环中吗？若不写在里面有什么区别？

​ 答：不一定，但是写在for循环外面的话，循环结束后，可以继续使用该变量
若在for循环内部中定义，只能在循环内部中使用，for循环结束，外部不能使用该变量，作用域不同

​ 3、大括号能不能不写？可以，但是只有当循环体语句是一句话的时候才可以不写，推荐永远将大括号写上

​ 4、判断条件语句能不能不写？可以，语法上没问题，但是执行过程有问题，变成了死循环

​ 5、控制条件语句能不能不写？可以，语法上没问题，但是执行过程可能有问题，变成了死循环

package shujia.day02.ketang;

/*
    请在控制台输出数据1-10
    请在控制台输出数据10-1
    求出1-10之间数据之和
    求出1-100之间偶数和
    求出1-100之间奇数和
    求5的阶乘

 */
public class ForTest {
    public static void main(String[] args) {
        //请在控制台输出数据1-10
        for (int i = 1; i < 11; i++) {
            System.out.println(i);
        }
        System.out.println("---------------------------");
        //请在控制台输出数据10-1
        for (int i = 10; i > 0; i--) {
            System.out.println(i);
        }
        System.out.println("-----------------------------");
        int sum = 0;
        //求出1-10之间数据之和
        for (int i = 1; i < 11; i++) {
            sum += i;
        }
        System.out.println("1-10之间的和为：" + sum);
        System.out.println("------------------------------");
        //    求出1-100之间偶数和,奇数和
        int ouShuSum = 0;
        int jiShuSum = 0;
        for (int i = 1; i < 101; i++) {
            if (i % 2 == 0) {
                ouShuSum += i;
            } else {
                jiShuSum += i;
            }
        }
        System.out.println("1-100之间的偶数和为：" + ouShuSum);
        System.out.println("1-100之间的奇数和为：" + jiShuSum);
        System.out.println("------------------------------");
        int res = 1;
        //求5的阶乘
        for (int i = 2; i <= 5; i++) {
            res *= i;
        }
        System.out.println("1-5的阶乘为：" + res);
        
    }
}

循环结构while

while

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

java中的普通for循环和while循环可以相互转换的

当一个需求明确了循环的范围的时候，优先考虑for循环
当一个需求不明确循环的范围，但是明确了结束循环的条件的时候，优先考虑while循环

package shujia.day02.ketang;

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

 */
public class WhileTest {
    public static void main(String[] args) {
        int high = 884800;
        int thickness = 1;
        int count = 0;
        while (thickness < high) {
            thickness *= 2;
            count++;
        }

        System.out.println("共折叠 " + count + " 次，纸张的厚度为：" + thickness);
    }
}

do..while

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

do..while循环会先执行一遍循环体语句内容，再进行判断，至少会有一次执行
while循环先判断，结果为true的时候才会执行，可能一次都不执行。

public class DoWhileDemo {
    public static void main(String[] args) {
        //打印1-5
        for(int i=1;i<0;i++){
                System.out.println(i);
        }
        System.out.println("================");
        int j=1;
        while (j<0){
            System.out.println(j);
            j++;
        }
        System.out.println("================");
        int a = 1;
        do{
            System.out.println(a);
            a++;
        }while (a<0);

        System.out.println("==================");
        //死循环
        while (true){
            //xxx
        }
    }
}

循环控制语句

break

//break: 在switch语句或者循环语句中进行使用

public class BreakDemo {
    public static void main(String[] args) {
        //break; // 不能单独使用break,break只能在特殊的场景下进行使用

        for(int i=1;i<=10;i++){
            if(i==5){
                break; // 结束整个for循环
            }

            System.out.println(i);
        }

        System.out.println("over");

        System.out.println("===========================");
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= 9; j++) {
                if(j==5){
                    break; // 单独使用的时候，结束的是最近的循环
                }
                System.out.print("*\t");
            }
            System.out.println();
        }

        System.out.println("over");

        System.out.println("===========================");
        wc: for (int i = 1; i <= 9; i++) {
            nc: for (int j = 1; j <= 9; j++) {
                if(j==5){
//                    break; // 单独使用的时候，结束的是最近的循环
                    break wc; // 给嵌套循环分别起名字，将来使用名字退出对应的循环
                }
                System.out.print("*\t");
            }
            System.out.println();
        }

        System.out.println("over");

    }
}

continue

//  continue：跳过当次循环，继续下一次循环

public class ContinueDemo {
    public static void main(String[] args) {
        //continue; // 只能存在于循环中使用

       for(int i=1;i<11;i++){
           if(i==5){
               continue;
           }
            System.out.println(i);
        }

        System.out.println("好好学习，天天向上！");
    }
}

return

// return: 在方法中使用，主要是用于结束一个方法，或返回一个结果值。存在于方法的最后一句话定义。
public class ReturnDemo {

    public static void main(String[] args) {

//        System.out.println("好好学习，天天向上！");
        
        for (int i = 1; i < 11; i++) {
            if (i == 5) {
                return;
            }
            System.out.println(i);
        }
        System.out.println("好好学习，天天向上！");
    }
}

方法Function

方法定义的语句格式：
修饰符 返回值类型 方法名(参数类型1 参数名1,参数类型2 参数名2,参数类型3 参数名3,...){
方法体;
return 返回值;
}

名词解释：
修饰符：public static
返回值类型：调用完方法后得到的数据的类型
方法名：符合标识符命名规则
参数列表【参数类型，参数个数】
形式参数：方法定义上小括号中的参数，用于接收实际传入的值
实际参数：将来方法调用时真正传入值
方法体：方法中具体要做的事情
return：用于结束整个方法，将返回值返回给调用者
返回值：要符合返回值类型保持一致或者继承或者实现关系

方法使用的注意事项：
1、java中，方法不能嵌套定义，方法于方法之间是平级关系
2、方法不调用不执行
3、当方法有返回值的时候，返回值可以直接使用或者使用一个变量接收方法的返回值

public class FunctionDemo1 {


    public static void main(String[] args) {
//        System.out.println(sum(10,20));

        int res = sum(10, 20);
        System.out.println(res);
    }

    //需求：定义一个方法，求两个int类型数值的和
    public static int sum(int a, int b) {
        int c = a + b;
        return c;
    }

}

/*
    需求：定义一个方法，传入行数和列数，输出对于行数和列数的矩形

    java针对没有返回值的方法，提供一个关键字进行表示，叫做void
    将来你看到一个方法的返回值是void，就表示该方法没有返回值
 */
public class FunctionDemo2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入行数：");
        int rowNumber = sc.nextInt();
        System.out.println("请输入列数：");
        int colNumber = sc.nextInt();
        //调用方法
        printStar(rowNumber,colNumber);

        System.out.println("----------------------------");
        //xxxxxx
        printStar(rowNumber,colNumber);

    }

    public static void printStar(int rowNumber,int colNumber){
        for(int i=1;i<=rowNumber;i++){
            for(int j =1;j<=colNumber;j++){
                System.out.print("*\t");
            }
            System.out.println();
        }

//        return; // 若方法没有返回值，最后一句话可以不写return
    }
}

/*
    当一个类中，出现方法名相同，但是方法的参数列表不同，这个现象，称之为方法的重载。
 */
public class FunctionDemo3 {
    public static void main(String[] args) {
        //需求1：定义一个方法，求两个int类型数据的和
        int a = 3;
        int b = 4;
        System.out.println(sum(a, b));

        //需求1：定义一个方法，求三个int类型数据的和
        int c = 5;
        System.out.println(sum(a, b, c));
        //将来方法调用的是哪一个，由JVM根据调用的方法名和方法参数列表一起决定的。

        //需求1：定义一个方法，求四个int类型数据的和
        int d = 6;
        System.out.println(sum(a, b, c, d));


    }

    public static int sum(int a, int b, int c, int d) {
        return a + b + c + d;
    }

    public static int sum(int a, int b, int c) {
        return a + b + c;
    }

    public static int sum(int a, int b) {
        return a + b; // return后面是可以直接接一个语句体
    }
}

数组

数组：
1、是一个可以存储同一种数据类型元素的容器，对于同一个数组而言，里面的元素数据类型都是一样。
2、数组长度是固定大小的，其实一块内存中的连续空间，数组一旦创建，长度不可变
3、数组具有索引的概念，从左向右，从0开始

如何去定义一个数组呢？
一维数组：
语句定义格式：
数据类型[] 数组名;【推荐写法】
数据类型 数组名[];

如何对一维数组进行初始化？
动态初始化
语句定义格式： 数据类型[] 数组名 = new 数据类型[m];
静态初始化

public class ArrayDemo1 {
    public static void main(String[] args) {
        //数据类型[] 数组名;
        //定义一个存储int类型元素的数组
        // 数据类型 变量名 = 初始化值;
//        int[] arr1;
        //定义并创建一个可以存储3个int类型元素的一维数组
        /**
         *  左边：
         *      int: 表示该数组中的元素是int类型
         *      []: 表示该数组是一个一维数组
         *      arr1: 数组的名字，符合变量名的命名规则
         *  右边：
         *      new: 将来看到new，就意味着在内存中开辟空间
         *      int: 表示该数组中的元素是int类型
         *      []: 表示该数组是一个一维数组
         *      3: 表示该一维数组的大小或者长度为3
         */
        int[] arr1 = new int[3];
        System.out.println(arr1); // [I@4554617c
    }
}