函数——Java

函数

从小我们接触过的函数都是基于变量上的，表面意思就是知道一个变量的具体某一个值，进而求得另一个变量的值，即映射关系。但是函数在编程语言的层面它是属于一个方法，即自己可以单独的可以实现某一个功能。具体如下：

在几何层面——给定一个数集A，假设其中的元素为x。现对A中的元素x施加对应法则f，记作f（x），得到另一数集B。假设B中的元素为y。则y与x之间的等量关系可以用y=f（x）表示。我们把这个关系式就叫函数关系式，简称函数。

在Java编程语言层面——函数就是一个方法。

方法能解决怎样的问题？

1、方法是解决一类问题的步骤的有序组合；

2、方法包含于类或对象中；

3、方法在程序中被创建，在其他地方被引用。

方法在该程序中的优点是什么？

1、对于主函数来说，简短而清晰；

2、便于程序的维护；

3、可以提高程序开发的效率；

4、提高了代码的重用率。

函数（方法）的命名

方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：isAdd.

函数（方法）的定义

方法（函数）的定义：1、主要解决的是那些具有重复的且独立功能的代码块；2、将这些独立的代码块进行封装，可以使整个程序模块化。

函数（方法）的格式：

访问权限 函数类型 返回值类型 函数名（参数列表）{

    函数体；
    
    return 返回值；
}

1、访问权限——函数的适用范围（内部和外部）

Java有四种访问权限， 其中三种有访问权限修饰符，分别为private，public和protected，还有一种不带任何修饰符（默认不写）。

private: Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的类、属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。

2、函数类型——static（静态函数）、默认不写（成员函数）、abstract（抽象函数）、native（本地函数）、synchronized（同步函数）

3、返回值类型

void——有return，但是可以省略不写

int double String boolean——必须有return+返回值。

4、函数名——为了使其他人能够清楚地知道该模块所在该程序中执行的功能

函数（方法）的分类

1、有参无返回值类型

2、有参有返回值类型

3、无参无返回值类型

4、无参有返回值类型

函数（方法）基于栈的运行过程

栈（先进先出）——进栈是把元素存放在栈顶后面一个位置，栈顶往后移；出栈是删除栈顶元素，栈顶往前移。适合栈元素数量比较确定的情况。

具体操作时如下：

/*
下面有两个函数——一个函数main（）和一个函数fuZhi（）
具体在栈中是怎样运行的，首先内存中拥有栈空间，因为每一个函数执行的入口都是main（）函数
    1、main（）函数先进入栈中，栈顶指向main（）函数，因为每一个栈都是从栈顶开始的，先进后出，因此先是
    创建两个变量，a、b，并把a、b在常量地址池中所对应的地址给所创建的变量
    2、fuZhi（）函数开始进入栈中，栈顶移向fuZhi（）函数，又开始如上操作，最后把c中所存放的
    常量在常量池所对应的地址返回并赋值给b，fuZhi（）函数弹栈即出栈，栈顶又指向main（）
    函数，知道运行完为止，main（）函数弹栈，即整个程序运行完毕。
*/
public static void main(String[] args){
    int a=10;
    int b=0;
    b=fuZhi(a);
    System.out.print(b);
}
public static int fuZhi(int c){
    return c;
}

图解：

 

例：

import java.util.Scanner;
class Demo01{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        System.out.print("请输入一个数num：");
        long num=input.nextInt();
        int sum=sumDigits(num);
        System.out.println(sum);
    }
    public static int sumDigits(long n){
        long temp=n;
        int sum=0;
        while(true){
            n=temp%10;
            sum+=n;
            temp/=10;
            if(temp==0){
                break;
            }

        }
        return sum;
    }
}

特别提醒：在一段源程序当中，这段源程序的中间却写了return+返回值，在此之后还有输出语句，如果是这种情况，该程序执行到return就不会再往下执行了，该程序运行直接结束，因此，这也是return的一个功能。

常用函数

Java在Math类中提供了许多实用的方法，用来计算常用的函数。例如：1、三角函数方法；2、指数函数方法；3、取整方法；4、取绝对值方法；5、random方法。切记——在Math类中，还有两个常用的常数：1、Math.E——表示自然对数e；2、Math.PI——表示π。

一、三角函数方法 

1、sin   (参数——角度值)  ：返回三角正弦函数值；

2、cos（参数——角度值）：返回三角余弦函数值；

3、tan（参数——角度值）：返回三角正切函数值；

4、toRadians（参数——弧度值）：返回角度值，即多少度；

5、toDegrees（参数——角度值）：返回值为弧度值；

6、asin（参数——数值）：返回值为反三角正弦函数值；

7、acos（参数——数值）：返回值为反三角余弦函数值；

8、atan（参数——数值）：返回值为反三角正切函数值。

class Test06{
    public static void main(String[] args){
        System.out.println("1——正弦函数值为："+Math.sin(Math.PI/6));
        System.out.println("2——余弦函数值为："+Math.cos(Math.PI/3));
        System.out.println("3——正切函数值为："+Math.tan(Math.PI/4));
        System.out.println("4——π/2转化为角度值为："+Math.toRadians(Math.PI/2));
        System.out.println("5——90度转化为弧度值为："+Math.toDegrees(90));
        System.out.println("6——反正弦函数值为："+Math.asin(0.5));
        System.out.println("7——反余函数值为："+Math.acos(0));
        System.out.println("8——正弦函数值为："+Math.atan(0.25));
    }
}


运行结果：
1——正弦函数值为：0.49999999999999994
2——余弦函数值为：0.5000000000000001
3——正切函数值为：0.9999999999999999
4——π/2转化为角度值为：0.027415567780803774
5——90度转化为弧度值为：5156.620156177409
6——反正弦函数值为：0.5235987755982989
7——反余函数值为：1.5707963267948966
8——正弦函数值为：0.24497866312686414

二、指数函数方法

1、exp（参数——x）：返回e的x次方；

2、log（参数——x）：返回x的自然底数；

3、log10（参数——x）：返回x的以10为底的对数；

4、pow（参数——x，参数——y）：返回x的y次方；

5、sprt（参数——x）：放回x的平方根，前提是参数x大于0。

class Test06{
    public static void main(String[] args){
        System.out.println("1——e的1次方的值为："+Math.exp(1));
        System.out.println("2——e的以e为底的对数值为："+Math.log(Math.E));
        System.out.println("3——10的以10为底的对数值为："+Math.log10(10));
        System.out.println("4——2的3次方的值为："+Math.pow(2,3));
        System.out.println("5——4的平方根为值为："+Math.sqrt(4));
    }
}

/* 
运行结果：
1——e的1次方的值为：2.718281828459045
2——e的以e为底的对数值为：1.0
3——10的以10为底的对数值为：1.0
4——2的3次方的值为：8.0
5——4的平方根为值为：2.0
*/

三、 取整函数

1、ceil（参数——x）：返回一个比参数x大的最小整数，该整数作为一个双精度值返回；

2、floor（参数——x）：返回一个比参数x小的最大整数，该整数作为一个双精度值返回；

3、rint（参数——x）：如果参数x的小数部分大于5，则返回值为大于该数的最小整数，该整数作为一个双精度值返回；如果参数x小于等于5，则返回值为小于该数的最大整数，该整数作为一个双精度值返回。

class Test06{
    public static void main(String[] args){
        System.out.println("1——"+Math.ceil(2.6));
        System.out.println("2——"+Math.floor(2.6));
        System.out.println("3——"+Math.rint(2.5));
    }
}

/* 
运行结果：
1——3.0
2——2.0
3——2.0
*/

 四、取绝对值函数

1、abs（参数——x）：如果一个数小于0，则返回值为该数的相反数；否则，返回值则是它本身。

class Test06{
    public static void main(String[] args){
        System.out.println(Math.abs(-2));
    }
}

?
/*
运行结果：
2
*/

五、random函数

random（）函数是一个取随机数的函数，该函数默认取的随机数为[0,1）；并且是double类型，一般该函数调用时都需要强制类型的转化；例：取0~100的整数———(int)(Math.random()*100),即可。

函数的重载

重载方法可以使用同样的名字来定义不同方法，要求：函数的数据类型可以不同，参数列表也可以不同，但是函数名必须相同。例：

class Test04{
    public static void main(String[] args){
        /*
        1——因为在计算机中，会把整数默认为int，当方法max参数传入的是：1  2时，
            此方法则调用的函数是：函数的数据类型为int
                                参数的数据类型为int
         */
        System.out.println("1——1、2之间的最大值为:max=" + max(1,2));
        /*
        2——因为在计算机中，会把小数默认为double，当方法max参数传入的是：1.0  2.0时，
            此方法则调用的函数是：函数的数据类型为double
                                参数的数据类型为double 
         */
        System.out.println("2——1.0、2.0之间的最大值为:max=" + max(1.0,2.0));
        /*
        3——由1、2的结论得知，当方法max参数传入的是：1  2.0时，
            此方法则调用的函数是：函数的数据类型为double
                                参数的数据类型为:num1——int    num2——double 
            为什么会是这样？——因为在数据类型转化的过程中，占内存小的数据类型转化为大的，系统会自动转化；
                                                      占内存大的数据类型转化为小的，会有数据有损，因此就会出现强制数据类型的转化
         */
        System.out.println("3——1.0、2之间的最大值为:max=" + max(1.0,2));
        /*
        4——同3
         */ 
        System.out.println("4——1、2.0之间的最大值为:max=" + max(1,2.0));
        
    }
    /*
    函数的数据类型为int
    参数的数据类型为int
     */
    public static int max(int num1,int num2){
        if(num1>=num2){
            return num1;
        }else{
            return num2;
        }
    }
    /*
    函数的数据类型为double
    参数的数据类型为double 
    */
    public static double max(double num1,double num2){
        if(num1>=num2){
            return num1;
        }else{
            return num2;
        }
    }
    /*
    函数的数据类型为double
    参数的数据类型为:num1——int    num2——double 
     */
    public static double max(int num1,double num2){
        if(num1>=num2){
            return num1;
        }else{
            return num2;
        }
    }
}