函数

                                                            函数的定义

一：

1. 函数就是定义在类中的具有特定功能的一段独立小程序。

2. 函数也称为什么。

二：函数的格式

    修饰符    返回值类型    函数名（参数类型   形式参数1；参数类型   形式参数2；……）

{

      执行语句；

        return返回值；

}

返回值类型：函数运行后的结果的数据类型。

参数类型：是形式参数的数据类型。

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

实际参数：传递给形式参数的具体数值。

return：用于结束函数。

返回值：该函数运算后的结果，该结果会返回给调用者。

class DemoTab{

    public static void main(String[] args){

            int  c=add(3,4);

            Systen.out.println("c="+c)

    }

    public static int  add(int  a,int  b){

            return  a+b;

    }

}

                                                    定义函数的格式

修饰符              返回值类型   函数名  （参数类型   形式参数1，参数类型   形式参数）

public static    int                add            int            a                   int            b

{

        //执行语句      返回值；

           return          a+b；

}

注：函数名起一个阅读性强的名字，函数名如果两个单词后面。

第一个用大写

（例：addAdd）

格式：

例：

class DemoTab2{

      public static void main(String[] args){

            myPrint();

        }

      public static void myPrint(){

            System.out.println('Hello world');

        }   

}

函数——细节

特殊情况:

功能没有具体的返回值。

这时return的后面直接用分号结束。

返回值类型怎么体现呢？

因为没有具体指，所以不可以写具体的数据类型。在java中只能用一个

关键字来表示这种情况。关键字是：void

总结：没有具体返回值时，返回值类型用void来表示。

注意：如果范沪指类型是void，那么函数中的return语句

可以省略不写。

class DemoTab3{

        public static void main(String[] args){

            myPrint();//下次调用写

        }

        public static void myPrint(){

            System.out.println("Hello java");

             return;

        }

}

​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​

    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​函数的特点

一，定义函数可以将功能代码进行封装。

二，便于对该功能进行复用

三，函数只有被调用才会被执行

四，函数的出现提高了代码的复用性

五，注意：

1.函数中只能调用函数，不可以在函数内部定义函数。

2.定义函数时，函数的结果应该返回给调用者，交由调用者处理。

例：      定义函数时，函数的结果应该返回给调用者，交由调用者处理（下面用两个例子比较一下）

class DemoCtri{

    ​public static void main(String[] args)

    ​{

    ​    ​    ​int x=add(3,5);

    ​    ​    ​System.out.println("x="+x);

    ​}

    ​public static int add(int a,int b) 

    ​{

    ​return a+b;

    }

}    ​    ​    ​    ​    ​注：两个比较这个比较好。

---

class DemoCtri2{

    ​public static void main(String[] args)

    ​{

    ​    ​  add(3,5);

    ​ }

     public static void add(int a,int b)

    ​​{

    ​    ​  System.out.println(a+b);

    ​    ​   return;

    ​}

}

注：这个方式没有上面的好

    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​

    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​函数——两个明确

需求1：定义个一个功能，完成两个整数的和的获取。

思路：既然定义功能，就是可以用函数来体现。

如何定义一个函数呢？

通过两个明确来完成。

明确一：这个功能的结果是什么？

是和。

是功能的结果，所以该功能的返回值是int类型。

其实就是在明确函数的返回值类型

明确二：这个功能实现过程中是否需要未知内容参与运算?

有。

加数和被加数。这就是函数的参数列表（参数的个数，参数的类型）其实

就是在明确参数列表。

注意：返回值类型和参数类型没有直接的关系。

需求二：定义一个功能，画一个矩形在控制台

明确一：这个功能的结果是什么？

没有结果。因为打印到了，控制台。并未返回给调用者，用void表示。

明确二：这个功能实现过程中是否需要未知内容参与运算?

有。

行和列不确定。两个整数int。

例：

class DemoCtri3{

    ​public static void main(String[] args)

    ​{

    ​ public static void draw(int  row,int  col)   

    ​}

    ​{    ​  

  ​    ​    ​    ​for(int x=1;x<=row;x++) {

    ​    ​    ​    ​    ​   for(int y=1;y<=col;y++)

    ​    ​    ​    } ​  ​  ​    ​{

    ​    ​    ​    ​    ​    ​    ​    ​System.out.print("*");    ​    ​    ​    ​

    ​    ​    ​    ​    ​   ​    ​} ​

    ​    ​    ​    ​    ​    System.out.println();    ​

    ​}

}

需求三：定义一个功能，比较两个数是否相等。

明确一：这个功能的结果是什么？

有boolean

明确二：这个功能实现过程中是否需要未知内容参与运算?

有。两个整数。

例：

class DemoCtri4{

    ​public static void main(String[] args)

    ​{

    ​public static boolean equals(int  a,int  b)

    ​}    ​    ​    ​    ​    ​    ​    ​    //相等的意思

    ​    ​{

//    ​    ​    ​if(a==b)

//    ​    ​    ​    ​    ​return  true;

//    ​    ​    ​else

//    ​    ​    ​    ​    ​return  false;

    ​    ​    ​return a==b;//这个是简写)

    ​    ​}

}

需求四：定义一个功能，获取两个整数中最大的那个数。

明确一：这个功能的结果是什么？

有，其中一个数。int

明确二：这个功能实现过程中是否需要未知内容参与运算?

有。参与比较的两个整数int。

例：

class DemoCtri4{

    ​public static void main(String[] args)

    ​{

    ​public static int getMax(int  a,int  b)

    ​}

    ​    ​    {

  /*  ​    ​    ​    ​ if(a>b)

    ​    ​    ​    ​    ​    ​return  a;

    ​    ​    ​    ​  else

   */ ​    ​    ​    ​    ​    ​ return  b;

    ​    ​    ​    ​return  a>b?a:b//这个是简写，三元运算符

    ​    ​    ​}

}

定义功能，打印99乘法表

class DemoCtri5{

    ​public static void main(String[] args)

  ​ {

    public static void print99()

    ​    ​{

    ​    ​    ​for(int x=1;x<=9;x++){

    ​    ​    ​    ​for(int y=1;y<=x;y++){

    ​    ​    ​    ​    ​System.out.print(y"*"+x+"="+y*x+"\t");

    ​    ​    ​    ​    ​}    ​

    ​    ​        System.out.println();​

    ​    ​    ​}

    ​    ​}  ​

    ​}

}

 

根据考试成绩获取学生分数对应的等级

例：

90~100      A

80~89    ​    ​B

70~79    ​    ​C

60~69    ​    ​D

60以下    ​    ​E

结果：等级；字符；char

参数：分数；int

class DemoCtri6{

    ​public static void main(String[] args){

    ​}

    ​ ​public static char getleve(int num)

     {

    ​    ​char level;

    ​    ​if(num>=90&&num<=100){

    ​    ​    ​    ​level='A';

    ​    ​    ​}    ​

    ​      else if(num>=80&&num<=89 ){

    ​    ​    ​    ​ level='B' ;

    ​ ​    ​    ​}​

        ​   else if(num>=70&&num<=79){

    ​    ​    ​    ​  level='C';

    ​    ​    ​}​

    ​        ​else if(num>=60&&num<=69){

    ​    ​    ​    ​   level='D';

    ​    ​    ​}​

    ​      ​   else{

    ​    ​    ​    ​    ​level='E';

    ​    ​    ​ }

    ​    ​    ​  return level;

    ​    ​}   ​

}

    ​    ​    ​    ​    ​    ​        ​    ​    ​    ​    ​    ​    ​    ​    ​函数的重载

函数的重载

1，同一个类

2，同名

3，参数个数不同。or（或者）参数类型不同。

4，函数重载和返回值类型无关。

5，java是严谨性语言，如果函数出现的调用的不确定性。会编译失败。

需求：函数的重载

//加法运算。两个整数的和

class DemoCtri6{

    ​    ​public static void main(String[] args){

    ​    ​}

    ​    public static int add(int  a,int  b){

    ​    ​    ​    ​return  a+b;

    ​    ​}  ​

}

//加法运算。两个小数的和

class DemoCtri7{

    ​    ​public static void main(String[] args){

    ​    ​}

    ​    ​public static double add(double  a,double  b){

    ​    ​    ​    ​return  a+b;

    ​    ​    ​}

}

//加法运算。三个整数的和

class DemoCtri8{

    ​    ​public static void main(String[] args){

    ​    ​}

    ​    ​public static int add(int  a,int  b,int  c){

    ​    ​    ​    ​return  a+b+c;    ​

    ​    ​    ​}

}    ​注：两个整数的和和三个整数的和重载可以这样写（rutern  （a，b）+c）

注：我没有必要起过多的函数名，来提高代码的阅读性，起一个名字就可以了。

只不过通过参数列表来区分同名函数的特点。

                                                            函数的定义

一：

1. 函数就是定义在类中的具有特定功能的一段独立小程序。

2. 函数也称为什么。

二：函数的格式

    修饰符    返回值类型    函数名（参数类型   形式参数1；参数类型   形式参数2；……）

{

      执行语句；

        return返回值；

}

返回值类型：函数运行后的结果的数据类型。

参数类型：是形式参数的数据类型。

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

实际参数：传递给形式参数的具体数值。

return：用于结束函数。

返回值：该函数运算后的结果，该结果会返回给调用者。

class DemoTab{

    public static void main(String[] args){

            int  c=add(3,4);

            Systen.out.println("c="+c)

    }

    public static int  add(int  a,int  b){

            return  a+b;

    }

}

                                                    定义函数的格式

修饰符              返回值类型   函数名  （参数类型   形式参数1，参数类型   形式参数）

public static    int                add            int            a                   int            b

{

        //执行语句      返回值；

           return          a+b；

}

注：函数名起一个阅读性强的名字，函数名如果两个单词后面。

第一个用大写

（例：addAdd）

格式：

例：

class DemoTab2{

      public static void main(String[] args){

            myPrint();

        }

      public static void myPrint(){

            System.out.println('Hello world');

        }   

}

函数——细节

特殊情况:

功能没有具体的返回值。

这时return的后面直接用分号结束。

返回值类型怎么体现呢？

因为没有具体指，所以不可以写具体的数据类型。在java中只能用一个

关键字来表示这种情况。关键字是：void

总结：没有具体返回值时，返回值类型用void来表示。

注意：如果范沪指类型是void，那么函数中的return语句

可以省略不写。

class DemoTab3{

        public static void main(String[] args){

            myPrint();//下次调用写

        }

        public static void myPrint(){

            System.out.println("Hello java");

             return;

        }

}

​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​

    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​函数的特点

一，定义函数可以将功能代码进行封装。

二，便于对该功能进行复用

三，函数只有被调用才会被执行

四，函数的出现提高了代码的复用性

五，注意：

1.函数中只能调用函数，不可以在函数内部定义函数。

2.定义函数时，函数的结果应该返回给调用者，交由调用者处理。

例：      定义函数时，函数的结果应该返回给调用者，交由调用者处理（下面用两个例子比较一下）

class DemoCtri{

    ​public static void main(String[] args)

    ​{

    ​    ​    ​int x=add(3,5);

    ​    ​    ​System.out.println("x="+x);

    ​}

    ​public static int add(int a,int b) 

    ​{

    ​return a+b;

    }

}    ​    ​    ​    ​    ​注：两个比较这个比较好。

---

class DemoCtri2{

    ​public static void main(String[] args)

    ​{

    ​    ​  add(3,5);

    ​ }

     public static void add(int a,int b)

    ​​{

    ​    ​  System.out.println(a+b);

    ​    ​   return;

    ​}

}

注：这个方式没有上面的好

    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​

    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​    ​函数——两个明确

需求1：定义个一个功能，完成两个整数的和的获取。

思路：既然定义功能，就是可以用函数来体现。

如何定义一个函数呢？

通过两个明确来完成。

明确一：这个功能的结果是什么？

是和。

是功能的结果，所以该功能的返回值是int类型。

其实就是在明确函数的返回值类型

明确二：这个功能实现过程中是否需要未知内容参与运算?

有。

加数和被加数。这就是函数的参数列表（参数的个数，参数的类型）其实

就是在明确参数列表。

注意：返回值类型和参数类型没有直接的关系。

需求二：定义一个功能，画一个矩形在控制台

明确一：这个功能的结果是什么？

没有结果。因为打印到了，控制台。并未返回给调用者，用void表示。

明确二：这个功能实现过程中是否需要未知内容参与运算?

有。

行和列不确定。两个整数int。

例：

class DemoCtri3{

    ​public static void main(String[] args)

    ​{

    ​ public static void draw(int  row,int  col)   

    ​}

    ​{    ​  

  ​    ​    ​    ​for(int x=1;x<=row;x++) {

    ​    ​    ​    ​    ​   for(int y=1;y<=col;y++)

    ​    ​    ​    } ​  ​  ​    ​{

    ​    ​    ​    ​    ​    ​    ​    ​System.out.print("*");    ​    ​    ​    ​

    ​    ​    ​    ​    ​   ​    ​} ​

    ​    ​    ​    ​    ​    System.out.println();    ​

    ​}

}

需求三：定义一个功能，比较两个数是否相等。

明确一：这个功能的结果是什么？

有boolean

明确二：这个功能实现过程中是否需要未知内容参与运算?

有。两个整数。

例：

class DemoCtri4{

    ​public static void main(String[] args)

    ​{

    ​public static boolean equals(int  a,int  b)

    ​}    ​    ​    ​    ​    ​    ​    ​    //相等的意思

    ​    ​{

//    ​    ​    ​if(a==b)

//    ​    ​    ​    ​    ​return  true;

//    ​    ​    ​else

//    ​    ​    ​    ​    ​return  false;

    ​    ​    ​return a==b;//这个是简写)

    ​    ​}

}

需求四：定义一个功能，获取两个整数中最大的那个数。

明确一：这个功能的结果是什么？

有，其中一个数。int

明确二：这个功能实现过程中是否需要未知内容参与运算?

有。参与比较的两个整数int。

例：

class DemoCtri4{

    ​public static void main(String[] args)

    ​{

    ​public static int getMax(int  a,int  b)

    ​}

    ​    ​    {

  /*  ​    ​    ​    ​ if(a>b)

    ​    ​    ​    ​    ​    ​return  a;

    ​    ​    ​    ​  else

   */ ​    ​    ​    ​    ​    ​ return  b;

    ​    ​    ​    ​return  a>b?a:b//这个是简写，三元运算符

    ​    ​    ​}

}

定义功能，打印99乘法表

class DemoCtri5{

    ​public static void main(String[] args)

  ​ {

    public static void print99()

    ​    ​{

    ​    ​    ​for(int x=1;x<=9;x++){

    ​    ​    ​    ​for(int y=1;y<=x;y++){

    ​    ​    ​    ​    ​System.out.print(y"*"+x+"="+y*x+"\t");

    ​    ​    ​    ​    ​}    ​

    ​    ​        System.out.println();​

    ​    ​    ​}

    ​    ​}  ​

    ​}

}

 

根据考试成绩获取学生分数对应的等级

例：

90~100      A

80~89    ​    ​B

70~79    ​    ​C

60~69    ​    ​D

60以下    ​    ​E

结果：等级；字符；char

参数：分数；int

class DemoCtri6{

    ​public static void main(String[] args){

    ​}

    ​ ​public static char getleve(int num)

     {

    ​    ​char level;

    ​    ​if(num>=90&&num<=100){

    ​    ​    ​    ​level='A';

    ​    ​    ​}    ​

    ​      else if(num>=80&&num<=89 ){

    ​    ​    ​    ​ level='B' ;

    ​ ​    ​    ​}​

        ​   else if(num>=70&&num<=79){

    ​    ​    ​    ​  level='C';

    ​    ​    ​}​

    ​        ​else if(num>=60&&num<=69){

    ​    ​    ​    ​   level='D';

    ​    ​    ​}​

    ​      ​   else{

    ​    ​    ​    ​    ​level='E';

    ​    ​    ​ }

    ​    ​    ​  return level;

    ​    ​}   ​

}

    ​    ​    ​    ​    ​    ​        ​    ​    ​    ​    ​    ​    ​    ​    ​函数的重载

函数的重载

1，同一个类

2，同名

3，参数个数不同。or（或者）参数类型不同。

4，函数重载和返回值类型无关。

5，java是严谨性语言，如果函数出现的调用的不确定性。会编译失败。

需求：函数的重载

//加法运算。两个整数的和

class DemoCtri6{

    ​    ​public static void main(String[] args){

    ​    ​}

    ​    public static int add(int  a,int  b){

    ​    ​    ​    ​return  a+b;

    ​    ​}  ​

}

//加法运算。两个小数的和

class DemoCtri7{

    ​    ​public static void main(String[] args){

    ​    ​}

    ​    ​public static double add(double  a,double  b){

    ​    ​    ​    ​return  a+b;

    ​    ​    ​}

}

//加法运算。三个整数的和

class DemoCtri8{

    ​    ​public static void main(String[] args){

    ​    ​}

    ​    ​public static int add(int  a,int  b,int  c){

    ​    ​    ​    ​return  a+b+c;    ​

    ​    ​    ​}

}    ​注：两个整数的和和三个整数的和重载可以这样写（rutern  （a，b）+c）

注：我没有必要起过多的函数名，来提高代码的阅读性，起一个名字就可以了。

只不过通过参数列表来区分同名函数的特点。