Java基础学习（四）

流程控制

/*
控制流程语句之---if 判断语句

格式一： 只适用于一种情况下去使用。

    if(判断条件){
        符合条件执行的代码;
    }

格式二：适用于两种情况下去使用

    if(判断条件){
        符合条件执行的代码
    }else{
        不符合条件执行 的 代码
    }

]

格式3： 适用于多种情况使用的

    if(判断条件1){
        符合条件1执行的 语句;
    }else if(判断条件2){
        符合条件2执行 的语句;
    }else if(判断条件3){
        符合条件3执行 的语句;
    }else if(判断条件4){
        符合条件4执行 的语句;
    }......else{
        都不符合上述 条件执行的代码...
    }

*/
class Demo1
{
    public static void main(String[] args)
    {
        System.out.println("Hello World!");
    }
}

/*
控制流程语句之----switch选择判断语句 

switch语句的格式：

    switch(你的选择){

        case 值1：
            符合值1执行的代码
            break;
        case 值2：
            符合值 2执行的代码
            break;
        case 值3：
            符合值 3执行的代码
            break;
        case 值4：
            符合值 4执行的代码
            break;
        ......

        default:
            你的选择都符合上述的选项时执行的代码;
            break;
    }

switch语句要注意的事项：
    1. switch语句使用的变量只能是byte、 char、 short、int、 String数据类型，String数据类型是从jdk7.0的时候开始支持的。
    2. case后面跟 的数据必须是一个常量。
    3. switch的停止条件：
        switch语句一旦匹配上了其中的一个case语句，那么就会执行对应的case中的语句代码，执行完毕之后如果没有
        遇到break关键字或者是结束switch语句的大括号，那么switch语句不会再判断，按照代码的顺序从上往下执行
        所有的代码。直到遇到break或者是结束siwitch语句的大括号为止。

    4. 在switch语句中不管代码的顺序如何，永远都是会先判断case语句，然后没有符合的情况下才会执行default语句。

if--else if---else if 语句与switch语句非常的相似：

    switch语句的优点：switch语句的结构清晰。

    switch缺点：如果 判断的条件是一个区间范围的，使用switch操作就非常的麻烦了。

判断以下那些不是计算机语言( D  )

    A java    B C#   C javascript   D android

*/
class Demo2{

    public static void main(String[] args)
    {

        int option = 13;    //定义一个变量存储你的选择
        switch(option){

            case 1:
                System.out.println("java");

            case 2:
                System.out.println("C#");

            case 3:
                System.out.println("javascript");

            case 4:
                System.out.println("android");
            default:
                System.out.println("你的选择有误");

        }

        /*
        String str = "world";
        switch(str){
            case "hello":
                System.out.println("hello");
                break;
            case "world":
                System.out.println("world");
                break;
        }
        */

    }
}

/*

需求： 接受键盘录入一个月份， 根据对应的月份输出对应的季节。

    345  春天
    678 夏天
    9 10 11 秋天
    1 2 12 冬天

要求使用switch语句实现。

*/
import java.util.*;
class Demo4
{
    public static void main(String[] args)
    {
        System.out.println("请输入一个月份：");
        //创建一个扫描器
        Scanner scanner = new Scanner(System.in);
        //调用扫描器的nextInt方法
        int month = scanner.nextInt();
        switch(month){
            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;
            case 12:
            case 1:
            case 2:
                System.out.println("冬天");
                break;
            default:
                System.out.println("没有对应的季节");
                break;
        }

    }
}

/*
循环语句----while循环语句

while循环 语句的格式:

    while(循环的条件){
        循环语句；
    }

while循环语句要注意的事项：
    1. while循环语句一般是通过一个变量控制其循环的次数。
    2. while循环语句的循环体代码如果只有一个语句的时候，那么可以省略大括号。但是也是不建议大家省略。
    3. while循环语句的判断条件后面不能跟有分号，否则会影响到执行的效果。

需求： 在控制上打印五句hello world.

*/
class Demo5
{
    public static void main(String[] args)
    {
         int count = 0;
         while(count<5){
            System.out.println("Hello World!");
            count++;
         }
    }
}

/*
需求： 计算1+2+3+....+ 100的总和。

*/
class Demo6{

    public static void main(String[] args)
    {
        int num = 1;
        int sum  = 0;    //定义一个变量用于保存每次相加的结果
        while(num<=100){
            sum = sum+num; //  sum = 1
            num++;
        }

        System.out.println("sum = "+ sum);
    }
}

/*
需求1:计算1-100,7的倍数总和。 7  14 21

如何产生一个随机数。

步骤：
    1. 创建一个随机数对象。
    2. 调用随机数对象的nextInt方法。
    3. 导包。
*/
class Demo7 {

    public static void main(String[] args){
        int num = 1;
        int sum = 0;    //定义一个变量用于保存每次相加的总和。

        while(num<=100){ // num = 1

            if(num%7==0){
                sum = sum+num;

            }
            num++;    

        }

        System.out.println("总和是："+ sum);

    }
}

/*
需求2： 实现猜数字游戏， 如果没有猜对可以继续输入你猜的数字，如果猜对了停止程序。

最多只能猜三次，如果还剩下最后一次机会的时候要提醒用户。

*/
import java.util.*;
class Demo8 {

    public static void main(String[] args)
    {
        //创建一个随机数对象
        Random random = new Random();
        //调用随机数对象的nextInt方法产生一个随机数
        int randomNum = random.nextInt(10)+1; //要求随机数是 1~10
        //创建一个扫描器对象
        Scanner scanner = new Scanner(System.in);

        while(true){
            System.out.println("请输入你要猜的数字:");
            //调用扫描器的nextInt方法扫描一个数字
            int guessNum = scanner.nextInt();
            if (guessNum>randomNum){
                System.out.println("猜大了..");
            }else if(guessNum<randomNum){
                System.out.println("猜小了..");
            }else{
                System.out.println("恭喜你，猜对了`..");
                break;
            }
        }

    }
}

/*
控制流程语句----do while循环语句

格式：
    do{

    }while(判断条件);

需求： 在控制上打印五句hello world.

while循环语句与do-while循环语句的区别：
    while循环语句是先判断后执行循环语句的，do-while循环语句
    是先执行，后判断。不管条件是否满足至少会执行一次。

*/
class Demo9{

    public static void main(String[] args)
    {
        /*
        int count =0;
        while(count<5){
            System.out.println("Hello World!");
            count++;
        }

        在java中，java编译器是不允许写废话。

        boolean flag = false;
        while(flag){
            System.out.println("Hello World!");
        }

        boolean flag = false;
        do{
            System.out.println("Hello World!");
        }while(flag);

        */

        int count = 0;
        do
        {
            System.out.println("hello world");
            count++;
        }while(count<5);

    }
}

/*
需求： 使用do-while算出1-100之间偶数的总和。

*/
class Demo10
{
    public static void main(String[] args)
    {
        int num = 1;
        int sum = 0;    //定义一个变量用于保存每次相加的总和
        do{
            if(num%2==0){
                sum += num;
            }
            num++;
        }while(num<101);

        System.out.println("sum = "+ sum);
    }
}

/*
控制流程语句之---for循环语句

for循环语句的格式:

    for(初始化语句;判断语句;循环后的语句){
        循环语句;
    }

for循环语句 要注意的事项：
    1. for(;;)这种写法 是一个死循环语句，相当于while(true);
    2. for循环语句的初始化语句只会执行一次，只是在第一次循环的时候执行而已。
    3. for循环语句的循环体语句只有一句的时候，可以省略大括号不写。但是不建议省略。

需求： 在控制上打印五句hello world.

*/
class Demo11
{
    public static void main(String[] args)
    {
        /*
        int count=0;
        while(count<5);{
            System.out.println("Hello World!");
            count++;
        }

        int count = 0 ;
        for(System.out.println("初始化语句A");count<5 ;System.out.println("循环后的语句C")){
            System.out.println("循环体语句B");
            count++;
        }
        */

        for(int count = 0 ; count<5;  count++){

        }

        {
            System.out.println("hello world");
        }

    }
}

/*
需求： 在控制台上打印一个 五行五列矩形/.

    *****
    *****
    *****
    *****
    *****

先打印一行

*/
class Demo12 {

    public static void main(String[] args)
    {
        for(int j = 0 ; j<5 ; j++){ //  控制行数
            for(int i = 0 ; i<5 ; i++){ // 控制列数
                System.out.print("*");
            }  // *****
                //换行
            System.out.println();

        }

    }
}

/*
需求： 在控制台上打印一个正立的直角三角形 。

*
**
***
****
*****

多行多列的图形。

行数 5行

列数： 会发生变化 的.

分析列数:

    i = 0 ; i<5; j=0 ; j<=i     1个星号
    i = 1 ; i<5 ;j=0 ; j<=1     2个星号
    i = 2 ; i<5; j=0 ; j<=2    3个星号
    .....

*/
class Demo13
{
    public static void main(String[] args)
    {
        for(int i = 0 ; i< 5 ; i++){
            for(int j = 0 ; j<=i ; j++){ //控制列数
                System.out.print("*");
            }
            //换行
            System.out.println();
        }
    }
}

/*
需求： 打印一个倒立的直角三角形。

*****
****
***
**
*

5行

列数会发生变化
                      j<(5-i)
    i= 0 ; i<5; j=0 ; j<5 ;    五个星号
    i = 1; i<5; j=0 ; j<4;     四个星号
    i = 2; i<5; j=0 ; j<3;     三个星号

*/

class Demo14
{
    public static void main(String[] args)
    {
        for(int i = 0 ; i<5;  i++){
            for (int j = 0 ; j<(5-i)  ;j++ ){
                System.out.print("*");
            }
            //换行
            System.out.println();
        }
    }
}

/*
需求： 打印一个九九乘法表.

*/
class Demo15
{
    public static void main(String[] args)
    {
        for(int i = 1 ; i<=9 ; i++){
            for(int j = 1 ; j<=i ; j++){ //控制列数
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
            //换行
            System.out.println();
        }
    }
}

/*
转义字符：特殊字符使用”\”把其转化成字符的本身输出，那么使用”\”的字符称作为转移字符。

需求： 在控制台上打印一个 hello" world 

常见的转义字符有：
    \b    Backspace （退格键）
    \t    Tab    制表符(制表符的作用就是为了让一列对齐)  一个tab一般等于四个空格。

    \n    换行
    \r    回车  把光标移动到一行的首位置上。

注意： 如果是在windows系统上操作文件的时候需要换行，是需要\r\n一起使用的。
如果是在其他的操作系统上需要换行，仅需要\n即可。

*/
import java.io.*;
class Demo16 {

    public static void main(String[] args) throws Exception
    {
        //System.out.println("Hello哈哈\rworld!");

        File file = new File("F:\\a.txt");
        FileWriter  out = new FileWriter(file);
        out.write("大家好\r\n");
        out.write("你们好");
        out.close();

    }
}

/*
break、 

break适用范围：只能用于switch或者是循环语句中。

break作用：
    1. break用于switch语句的作用是结束一个switch语句。
    2. break用于循环语句中的作用是结束当前所在的循环语句。

笔试题目：break目前位于内层的for循环，如何才能让break作用于外层的for循环。
    可以标记解决

标记的命名只要符合标识符的命名规则即可。

*/
class Demo17
{
    public static void main(String[] args)
    {
        aaa:for(int j = 0 ; j<3 ; j++){ // j=0 外层for循环
            bbb:for(int i = 0 ; i< 2 ; i++){  // i=0 内层for循环
                System.out.println("hello world"); // 1
                break aaa;
            }

        }

    }
}

/*
continue关键字

continue的适用范围： continue只能用于循环语句。

continue的作用：continue的作用是跳过本次的循环体内容。继续下一次。

continue要注意的事项：
    1. 在一种情况下，continue后面不能跟有其他语句，因为是永远都无法执行到。
    2. continue 也可以配合标记使用的。

*/

class Demo18
{
    public static void main(String[] args)
    {
        /*
        for(int i = 0 ; i<5 ; i++){ // i=1  2
            if(i==1){
                continue;
            }
            System.out.println("hello "+i);
        }

        outer:for(int i = 0 ; i<3; i++){ // i= 0;  i =1 i=2 3
            inner:for(int j = 0 ; j<2 ; j++){ //j=0
                System.out.println("hello"); //1 2 3
                continue outer;
            }
        }

        需求： 计算1-100的偶数总和.
        */

        int sum = 0 ;
        for(int num = 1 ; num<=100 ; num++){
            if(num%2!=0){
                continue;  //如果是奇数就跳过本次循环。
            }

            sum  = sum+num;
        }

        System.out.println("总和："+ sum);

    }
}

/*
函数（方法）: 

函数的作用： 提高功能代码的复用性。

需求：做两个数的加法功能。

目前存在的问题：以下的代码都是在做一个加法功能，而
这里加法功能 的代码目前是没有任何的复用性的。

解决方案： 如果一个功能的代码要被复用起来，那么这时候可以把
这里的功能代码封装起来，在java中把功能代码封装起来的是以函数的形式体现的。

函数的定义格式：

    修饰符  返回值类型  函数名(形式参数..){
        需要被封装的功能代码；
        return 结果;
    }

分析函数：
    public static int add(){
        int a =2;
        int b =3;
        return a+b;
    }

    修饰符: public static

    返回值类型： int 。 返回值类型就是指函数运行完毕后，返回的结果的数据类型。
    注意： 某些函数是没有结果返回给调用者的,那么这时候返回值类型是void。

    函数名： add   函数名的作用：如果需要调用该函数就需要使用的函数名。 函数名只要符合标识符的命名规则即可。
             函数名的命名规范： 首单词全部小写，其他单词的首字母大写，其他小写。

    形式参数： 如果一个函数在运行的时候，存在着数据是要调用者确定 的，那么这时候就应该定义形式参数。

    return ： 把一个结果返回给调用者。

函数的特点：
    1. 函数定义好之后，是需要被调用才会执行的。 main函数是有jvm调用的，不需要我们手动调用。

*/
class Demo1
{
    public static void main(String[] args){
        //int sum = add(2,3); //调用了add名字 的函数。
        //System.out.println("结果："+ sum);

        add(2,3);
    }

/*
    //做加法功能的函数
    public static int add(int a,int b){ // int a,int b 形式参数: 形式参数的值是交给调用者确定的。
        return a+b;
    }

需求： 定义一个函数做加法功能，不需要返回结果给调用者，直接输出结果即可。
*/

    public static  void add(int a ,int b){
        int sum = a+b;
        System.out.println("结果："+ sum);
    }

}

/*

函数的定义格式：

    修饰符  返回值类型  函数名(形式参数..){
        需要被封装的功能代码；
        return 结果;
    }

如何定义一个函数：
    1. 返回值类型。
    2. 是否存在未知的参数(是否存在要由调用者确定的参数)。---->形式参数

*/

class Demo2
{
    public static void main(String[] args)
    {
        //System.out.println("Hello World!");
        //int max = getMax(14,5); //调用了函数   实际参数
        //System.out.println("最大值："+ max);
        getMax(3,7);
    }

    //需求2：定义一个函数比较两个int类型的数据大小， 不需要把最大值返回给调用者,直接打印即可。
    public static void getMax(int a, int b){
        int max = 0; //定义一个变量用于保存最大值的
        if(a>b){
            max = a;
        }else{
            max = b;
        }
        System.out.println("最大值："+ max);
    }

/*

    //需求1： 定义一个函数比较两个int类型的数据大小， 把最大值返回给调用者。
    public static int  getMax(int a, int b){  // 形式参数
        int max = 0; //定义一个变量用于保存最大值的
        if(a>b){
            max = a;
        }else{
            max = b;
        }
        return max;    //把结果返回给调用者
    }
*/

}

/*
需求1： 定义一个函数判断一个分数的等级，把分数的等级返回给调用者。
            "A等级" ”B等级“

如何 定义函数：
    1. 返回值类型。  String
    2. 未知的参数--->形式参数。  分数

需求2： 定义一个函数打印一个乘法表，不需要返回任何数据。
    1. 返回值类型。  void
    2. 未知的参数--->形式参数。  到底是什么乘法表

函数的特点：
    1. 函数的作用就是把一个功能代码给封装起来，已达到提高功能代码的复用性。
    2. 函数定义好之后是需要被调用才会执行的。
    3. 如果一个函数没有返回值返回给调用者，那么返回值类型必须是使用void表示。

*/

class Demo3
{
    public static void main(String[] args) {
        //String result = getGrade(189);
        //System.out.println(result);
        print(7);
    }

    //需求2： 定义一个函数打印一个乘法表，不需要返回任何数据。
    public static void  print(int row){
        for(int i = 1 ; i<= row ; i++){
            for (int j = 1 ;j<=i  ;j++ ){
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
            //换行
            System.out.println();
        }
    }

    //需求1： 定义一个函数判断一个分数的等级，把分数的等级返回给调用者。
    public static String getGrade(int score){
        String grade = "";    //定义一个变量存储等级
        if(score>=90&&score<=100){
            grade = "A等级";
        }else if(score>=80&&score<=89){
            grade = "B等级";
        }else if(score>=70&&score<=79){
            grade = "C等级";
        }else if(score>=60&&score<=69){
            grade = "D等级";
        }else if(score>=0&&score<=59){
            grade = "E等级";
        }else{
            grade = "补考等级";
        }
        return grade;    //把等级返回给调用者
    }

}