Java语言基础（二）---程序流程控制语句、函数

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/yecjl/article/details/44984671

Java语言基础组成：关键字、标识符、注释、常量和变量、运算符、语句、函数、数组

一. 程序流程控制语句

1. 顺序结构：

简单的语句都是顺序结构的。

2. 判断结构：

【if 语句定义】	（1） if（条件表达式）    {      执行语句;    }	（2） if（条件表达式）    {      执行语句;    }    else    {      执行语句;    }	（3） if（条件表达式）    {      执行语句;    }    else if（条件表达式）    {      执行语句;    }    else    {      执行语句;    }
【if-else 语句 与 三元表达式区别】	三元运算符：    好处：可以简化if-else代码    弊端：因为是一个运算符，所以运算完后必须要有结果    【实例】: int a = 3, b;        b = a > 2 ? System.out.println(“haha”) : a; // 是错误的！ if-else 语句： 运算完后不一定有结果

【实例 1】：根据用户定义的数值不同，打印对应的星期英文

int num = 2;
if(num == 1)
{
    System.out.println("Monday");
}
else if(num == 2)
{
    System.out.println("Tuesday")
}
else if(num == 3)
{
    System.out.println("Wednesday")
}
else if(num == 4)
{
    System.out.println("Thursday")
}
else if(num == 5)
{
    System.out.println("Friday")
}
else if(num == 6)
{
    System.out.println("Saturday")
}
else if(num == 7)
{
    System.out.println("Sunday")
}
else
{
    System.out.println("nono");
}

【实例 2】：根据用户指定月份，打印该月份所属的季节（3,4,5春季；6,7,8夏季；9,10,11秋季；12,1,2冬季）
      （【注】见switch进行改写）

int x = 4;
if(x > 12 || x < 1)
{
    //一定要先对数据进行判断，只有正确的数值才能进行相应的处理，非正确的数值应该人性化地提示用户。
    System.out.println("月份不存在"); 
}
else if(x >= 3 && x <= 5)
{
    System.out.println("春季");
}
else if(x >= 6 && x <= 8)
{
    System.out.println("夏季");
}
else if(x >= 9 && x <= 11)
{
    System.out.println("秋季");
}
else
{
    System.out.println("冬季");
}

3. 选择结构：

【switch 语句定义】	switch（表达式） {   case 取值1 :      执行语句;          break;   ……   default :      执行语句;      break; }	表达式类型：    byte，short，int，char，Enum（枚举），    JDK1.7增加了对字符串的判断。但是不支持long。 case 取值1 :   case： 定义备选答案，没有顺序的，可以随便排列，        定义位置可 随性。   取值1： 答案的具体内容。 default： 默认，default最后的break可以不用写。   若default放在case前，在读取时，也先读取case，   再最后读取default。
【switch 与 if-else 区别】 if-else： 能判断具体数值，区间，boolean型 switch：判断区间很费劲，要全部写出来，并且不能判断boolean型。
【switch 与 if-else 如何选择】 如果进行具体数值判断，数值不多用switch（因为switch效率稍高） 对区间判断，对结果为boolean型判断，使用if（if的使用范围广）

【实例 1】：分析代码执行结果

int x = 3; 
switch(x) 
{
    default : System.out.println(“d”); 
   case 4 : System.out.println(“a”); 
   case 6: System.out.println(“b”); break; 
   case 2: System.out.println(“c”); break; 
} 
//结果为：d(回车)a(回车)b(回车) 

//分析为：第一次读取时，case都没有符合，读到default，执行后既没有break也没有大括号（}）， 
//       那么继续向下执行，而不再进行判断case，把下面能执行的都执行完，直到碰到break或大括号（}）。

【实例 2】：根据用户指定月份，打印该月份所属的季节（3,4,5春季；6,7,8夏季；9,10,11秋季；12,1,2冬季）
      （【注】对上面的if-case进行改写）

int x = 4;
switch(x)
{
    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("月份不存在"); 
}

4. 循环结构：

当要对某些语句执行很多次，就使用循环结构。

while	while（条件表达式） {   循环体; }	【while 与 do-while 区别】 while： 先判断条件，只有条件满足才执行循环体 do-while：先执行循环体，再判断条件，       条件满足，再执行循环体。   => 简单一句话：     do-while：无论条件是否满足，循环体至少执行一次。
do-while	do {   循环体; }while（条件表达式）；
for	for（初始化表达式; 循环条件; 循环后的操作表达式） {   执行语句; } 【for 语句特点】 初始化表达式只参与1次 只要条件不满足，跳出循环 【for 语句中变量的作用域】   [e.g.] for( int x = 0; x $<$ 3; x++ ){ }    变量x只在for语句中有效，离开{ } ，x在内存中消失了，    即for语句结束后，x在内存中消失了 【for与 while 区别】 如果需要定义循环增量，用for更适合 【无限循环的最简单表现形式】 for( ; ; ){ }  //循环条件默认为true while(true){ }

【实例 1】：分析下面的代码

int x = 1;
for(System.out.println("a"); x < 3; System.out.println("b"))
{
    System.out.println("c");
    x++;
}

//结果为：a(回车)c(回车)b(回车)c(回车)b(回车)
/*分析为：(1)【初始化表达式】：不一定要写成int x = 1; 只要是合法表达式就可以
         (2)【循环条件】：循环条件表达式必须要有真假
         (3)【循环后的操作表达式】：当表达式多时，用"，"隔开，可以写多条语句
*/

/*【扩展】: for(int y = 0; y < 3; y++){ }
        => 可以改成：
           int y = 0;
           for(; y < 3;)  //表达式可以为空
           {
              y++;
           }
*/

【实例 2】：获取1~10的和，并打印

/*【累加思想】：
sum += num; => 每次加的内容有可能不一样
原理： 通过变量记录住循环操作后的结果， 一个数不断地变大或变小，以记录住每次变化的结果，
      通过循环的形式进行累加动作，通常为累加一个变量或一个循环增量。
      [e.g.] 字符串的不断延长
*/

int sum = 0;
for(int num = 1; num <= 10; num++)
{
    sum += num;
}
System.out.println("sum=" + sum);

【实例 3】：1~100之间 7的倍数的个数，并打印。

/*【计数器思想】：
count++; => 符合条件有多少个，立刻想到计数器
原理： 通过一个变量记录住数据的状态变化，也需要通过循环完成。
*/

//方法一：
int count1 = 0;
for(int i = 1; i <= 100; i++)
{
    if(i % 7 == 0)
    {
        System.out.print("i=" + i + ' ');
        count1++;
    }
}
System.out.println("个数为：" + count1);

//方法二：
int multiplication = 7; //7的倍数值
int count2 = 0;
for(int i = 2; multiplication <= 100; i++)
{
    count2++;
    System.out.print("mul=" + multiplication + ' ');
    multiplication = 7 * i; //更新7的倍数值
}
System.out.println("个数为：" + count2);

【实例 4】：打印矩形

/*
利用for循环嵌套打印图形
******
******
******
******
*/
    /**
     * 打印矩形
     * @param x 行
     * @param y 列
     */
    public static void printJuxing(int x,int y)
    {
        for(int n = 0; n < x; n++)  //对于打印长方形，外循环控制行数
        {
            for (int m = 0; m < y ; m++ )  //内循环控制的是每一行的列数，也就是一行中元素的个数
            {
                System.out.print("*");
            }
            System.out.println();  //用于换行
        }
    }

【实例 5】：打印倒直角三角形

        /*
        利用for循环嵌套，打印图形。
        ****
        ***
        **
        *
        方法一：
        思路： 1.因为for循环嵌套的，外循环是控制行数的，内循环是控制每一行的列数的。
              2.行数为4，n由0开始，进行4次循环，n最大为3。
              3.列数m不断地变小，第0行4个，第1次3个，由此可见，第n行为4-n。
              补充：
              第0行，m变化的区间为，0-4，共4个。
              第1行，m变化的区间为，0-3，共3个。
              第2行，m变化的区间为，0-2，共2个。
              第n行，m变化的区间为，0-n，共n个。
              所以m的初始值为0，m的条件为，m<4-n。

        */
        for(int n = 0; n < 4; n++)
        {
            for(int m = 0;m < 4 - n;m++)
            {
                System.out.print("*");
            }
            System.out.println();
        }

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

        /*
        方法二：
        思路：第0行，m变化的区间为，0-4，共4个。
              第1行，m变化的区间为，1-4，共3个。
              第2行，m变化的区间为，2-4，共2个。
              第n行，m变化的区间为，n-4，共4-n个。
              所以m的初始值在变化，m<4是不变的。
        */
        for(int n = 0; n < 4; n++ )
        {
            for(int m = n; m < 4; m++)
            {
                System.out.print("*");
            }
            System.out.println();
        }

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

【实例 6】：打印顺直角三角形

        /*
        利用for循环嵌套，打印图形。
        *
        **
        ***
        ****
        思路：1.因为for循环嵌套的，外循环是控制行数的，内循环是控制每一行的列数的。
              2.行数为4，n由0开始，进行四次循环，n最大为3。
              3.列数m不断增加，第0行1个，第1行2个，由此可见，第n行为n+1。
        */
        for(int n = 0; n < 4; n++)
        {
            for(int m = 0; m < n + 1; m++)
            {
                System.out.print("*");
            }
            System.out.println();
        }

【打印三角形的规则】：

• 1. 尖朝上，可以改变条件，让条件随外循环变化
• 2. 尖朝下，可以改变初始值，让初始值随外循环变化

【实例 7】：按规则打印数字

        /*
        打印：
        1
        12
        123
        1234
        12345
        思路:尖朝上，改变条件。
        */
        for(int n = 1; n <= 5; n++)
        {
            for(int m = 1; m <= n; m++)
            {
                System.out.print(m);
            }
            System.out.println();
        }

【实例 8】：打印九九乘法表

        /**
        打印九九乘法表：
        1*1=1
        1*2=1 2*2=4
        1*3=3 2*3=6 3*3=9
        */
        for (int n = 1; n <= 9 ; n++)
        {
            for(int m = 1; m <= n; m++)
            {
                System.out.print(m + "*" + n + "=" + ( m * n) + "\t");
            }
            System.out.println();
        }

【实例 9】：打印等腰三角形

        /*
        打印。
        ----*
        ---* *
        --* * *
        -* * * *
        * * * * *
        */
        //方法一
        for (int n = 1; n <= 5; n++ )
        {
            for (int m = 5; m >= 1; m-- )
            {
                if(m <= n)
                {
                    System.out.print("* ");
                }
                else
                {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }

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

        //方法二
        for (int n = 0; n < 5 ; n++ )
        {
            for (int m = n + 1; m < 5 ; m++ )
            {
                System.out.print(" ");
            }
            for (int z = 0; z <= n ;z++ )
            {
                System.out.print("* ");
            }
            System.out.println();
        }

5. 其他程序流程控制语句：

break（跳出）	【作用语句】： switch 循环结构：用于跳出所在循环
continue（跳出）	【continue 的意思】： 结束本次循环，继续下一循环 【作用语句】： 只能用于循环结构：继续循环
【break，continue语句 注意事项】： 1. 都有自己的作用范围，离开了作用范围，是没有意义的。 2. 单独存在时，下面不可以有任何语句，因为执行不到。 【错误】：     for(int x = 0; x $<$ 3; x++)     {       continue;       System.out.println(x); //continue下面不可以有任何语句     } 【正确】：     for(int x = 0; x $<$ 3; x++)     {       if(x % 2 == 1);         continue;       System.out.println(x);     } 3. 使用标号：标号只能用于循环上，给循环起名字的一种方式。 【e.g. break】：     w: for(int x = 0; x $<$ 3; x++)     {       q: for(int y = 0; y $<$ 4; y++)       {         System.out.println(x);         break w;  //直接跳出外围for循环，不写w，默认跳出内循环。       }     }     //结果为：0 【e.g. continue】：     w: for(int x = 0; x $<$ 3; x++)     {       q: for(int y = 0; y $<$ 4; y++)       {         System.out.println(x);         continue w;  //直接跳出外围for循环，不写w，默认跳出内循环。       }     }     //结果为：0(回车)1(回车)2(回车)

二. 函数

1. 函数的定义：

函数就是定义在类中的具有特定功能的一段独立小程序，函数也成为方法。

【函数的格式】：  修饰符 返回值类型 函数名（参数类型 形式参数1）  {    执行语句；    return 返回值；  }	【修饰符】：对函数进行外加功能的定义，        让函数具备更多含义 【函数名】：    1. 用于标识函数，方便调用    2. 用于通过这个名称，体现这个函数的功能 【返回值类型】：数据类型，即函数运行的结果 【参数类型 形式参数1】：1. 定义变量，               2. 多个参数用”,”隔开 【形式参数与实际参数的区别】：    1. 形式参数：是一个变量，用于存储调用函数时，          传递给函数的实际参数。    2. 实际参数：传递给形式参数的具体数值。 【return 返回值】：    1. return：用于结束函数    2. 谁调用返回给谁
【函数的意义】：    为了提高代码的复用性，对代码进行抽取，将这个部分定义成一个独立的功能，方便日后使用，    Java中对功能的定义是通过函数的形式体现的。 【函数的注意点】：    1. 函数只有被调用才执行。    2. 函数放的位置：放在主函数上下都可以。    3. 函数中只能调用函数，不可以在函数内部定义函数，     定义函数时，函数的结果应该返回给调用者，由调用者处理。

【实例】：如何定义函数，调用函数的实例

    public static void main(String[] args) {

        int x = getResult(4); //可以重用
        System.out.println("x=" + 4);
    }

    public static int getResult(int num) //定义函数
    {
        return num * 3 + 5;
    }

2. 函数的特点：

【函数的特点】：

1. 定义函数可以将功能代码进行封装。
2. 便于对功能进行复用。
3. 函数只有被调用才会执行。
4. 函数的出现提高了代码的复用性。
5. 当函数运算后，没有具体返回值时，这时返回值类型用一个特殊的关键字标识，该关键字就是void。
   void 代表的是函数没有具体返回值的情况。
   当函数的返回值类型是void时，函数中的return 可以省略不写，系统会自己加的。

3. 函数的应用：

  我们编写程序，其实就是在不断地实现功能，Java中最小的功能单元就是函数，所以以后在写代码的时候，只要在处理或定义功能，都把它定义到独立的函数功能中去，而不要把代码换七八糟塞到主函数中，主函数的功能就只有一个，就是调用函数。

【如何定义函数？】：

1. 明确返回值类型：既然函数是一个独立的功能，那么该功能的运算结果是什么就要先明确。
2. 明确参数列表：再明确在定义该功能的过程中，是否需要未知的内容参与运算，即是否需要参数。
   参数列表包括参数的类型和参数的个数。

【实例 1】：定义一个功能，完成 3 + 4 的运算，并将结果返回给调用者

    public static void main(String[] args) {

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

    /**
     * 功能：计算 3 + 4
     * @return 返回总数
     */
    public static int getSum()
    {
        return 3 + 4;
    }

【实例 2】：为了方便用户需求，由用户来指定加数和被加数，这样功能才有意义

    public static void main(String[] args) {

        int sum = getSum(3, 4);
        System.out.println("sum=" + sum);
    }

    /**
     * 功能：计算两数相加
     * @return 返回总数
     */
    public static int getSum(int x, int y)
    {
        return x + y;
    }

【实例 3】：判断两个数是否相同

    public static void main(String[] args) 
    {
        boolean num = compare(6,6); //比较两个值是否相等
        if(num)
            System.out.println("相同");
        else
            System.out.println("不相同");
    }

    /**
     * 功能：判断两个数是否相同
     * @return boolean值
     */
    public static boolean compare(int x, int y)
    {
        /*
        方法一：
        if(x == y)
            return true;
        else
            return false;
        */

        /*
        方法二：三元运算符
        return x == y ? true : false;
        */

        //方法三：最简单的
        return x == y;
    }

【实例 4】：比较两个数，获取最大的数

    public static void main(String[] args) 
    {
        int max= getMax(4,6); //求最大值
        System.out.println("最大值为：" + max);
    }

    /**
     * 功能：比较两个数，获取最大的数
     * @return max
     */
    public static int getMax(int x,int y)
    {
        return x > y ? x : y;
    }

【实例 5】：查找出下面代码中，错误的定义思想

    public static void main(String[] args) 
    {
        System.out.println(getMax(4,6)); //[错误1]
    }

    /**
     * 功能：比较两个数，获取最大的数
     */
    public static void getMax(int x,int y)
    {
        System.out.println("最大值为：" + x > y ? x : y);  //[错误2]
    }

    /*【错误分析】：

    [错误1]：getMax方法返回值类型为void时，输出语句不知道要输出什么，不能打印，直接调用就行了。

    [错误2]：定义函数只要完成相对应的功能就好了，不要做过多的功能，
            至于打印是由调用者来完成，不要在getMax功能中完成。
    */

【实例 6】：定义功能，用于打印矩形。

    /*
    定义功能，用于打印矩形。
    思路：1.需要知道行数和列数。
          2.不需要返回值。
    */
    public static void main(String[] args) {

        printJuxing(4, 6);
    }

    /**
     * 功能：用于打印矩形
     * @param row 行
     * @param col 列
     */
    public static void printJuxing(int row,int col)
    {
        for(int n = 0; n < row; n++)
        {
            for (int m = 0; m < col ; m++ )
            {
                System.out.print("*");
            }
            System.out.println();
        }
    }

【实例 7】：定义一个打印99乘法表功能的函数。

    /*
    定义一个打印99乘法表功能的函数。
    思路：1.需要值。
          2.不需要返回值，直接打印。
    */
    public static void main(String[] args) {

        mul(9);
    }

    /**
     * 功能：打印99乘法表功能的函数
     * @param x 最大到几（例如9）
     */
    public static void mul(int x)
    {
        for(int n = 1; n <= x; n++)
        {
            for (int m = 1; m <= n ; m++ )
            {
                System.out.print( m + "*" + n + "=" + m * n + "\t");
            }
            System.out.println();
        }
    }

4. 函数的重载：

  在同一个类中，允许存在一个以上的同名函数，参数个数或者参数类型不同的同名函数就叫做重载。重载的特点：与返回值无关，只看参数列表。
  当定义的功能相同，但参与运算的未知内容不同，那么，就定义一个相同的函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分多个同名函数。

【实例 1】：add方法出现了重载的形式，名称保证一致

public static void main(String[] args)
{
    //功能一致，所以功能用的名字也一致
    add(4, 5);
    add(4, 5, 6); //通过参数列表来区分调用哪个函数
}

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

public static int add(int a, int b, int c)
{
    return a + b + c; //简化为：return add(a, b) + c; 提高代码的复用性。
}

【什么时候用重载？】
  当定义的功能相同，但参与运算的未知内容不同，那么，这时就定义一个函数名称以表示其功能，方便阅读。而通过参数列表的不同来区分多个同名函数。

【实例 2】：定义一个打印99乘法表功能的函数。用重载，一个是自定义num，一个是标准的9；

    public static void main(String[] args) {

        mul(8); //八八乘法表
        mul();  //九九乘法表
    }

    /**
     * 功能：自定义数值99乘法表
     * @param x 最大到几（例如9）
     */
    public static void mul(int x)
    {
        for(int n = 1; n <= x; n++)
        {
            for (int m = 1; m <= n ; m++ )
            {
                System.out.print( m + "*" + n + "=" + m * n + "\t");
            }
            System.out.println();
        }
    }

    /**
     * 功能：标准版99乘法表
     */
    public static void mul()
    {
        mul(9);
    }

【实例 3】：给定一个函数，比较下面有没有和它重载

void show(int a, char b, double c){}//原函数

//[a]
void show(int x, char y, double z){} //没有，因为和原函数一模一样

//[b]
int show(int a, double c, char b){}//重载了，因为参数类型不同，注意：重载和返回值类型无关，参数也是有顺序的

//[c]
void show(int a, double c, char b){} //重载了，参数是有顺序的

//[d]
boolean show(int c, char b){} //重载了，因为参数个数不同

//[e]
void show(double c){} //重载了，因为参数个数不同

//[f]
double show(int x, char y, double z){} //没有，参数一样，返回值虽然不同，但是不是重载，并且这个函数不允许和给定的函数