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

时间:2022-09-08 17:03:47

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){} //没有,参数一样,返回值虽然不同,但是不是重载,并且这个函数不允许和给定的函数