05 函数

函数

什么是函数

概念：具有特定功能的一段代码 可以重复使用
函数是一个c语言中的概念  java中没有函数概念 java中叫做方法

函数的定义

函数的声明：定义了函数具有什么样的功能（包括需要什么数据 能够 为使用者提供什么数据）
语法：
public static 返回值类型  函数名（数据类型 变量1，数据类型 变量2 。。。）


函数的实现：通过具体的代码 对声明的功能进行实现
语法：
｛
函数实现的具体代码；
｝

定义函数的语法：
public static 返回值类型 函数名（形参列表）｛
	函数的具体实现
｝

函数的三要素：函数名    函数的形参列表  函数的返回值类型（面试题）

函数定义的位置

只有位置2 和  位置4
//位置1
public class Demo{
	//位置2
	public static void main(String[] args) {
		//位置3
	}

	//位置4
}
//位置5
和主函数并列

函数的调用

注意：函数调用一次 就只执行一次
语法：
1. 函数名（）；
2.一个参数函数的调用：  函数名（实际参数）；
3.多个参数函数的调用：  函数名（实际参数1，实际参数2，实际参数3..）

函数的参数

形式参数：写在函数的形参列表中 说明函数需要什么类型的数据 需要几个数据
实际参数：函数调用者在使用函数的时候 为形式参数所赋的实际的数值
注意：
1.在定义函数的时候 形参列表的书写形式是  数据类型 变量1，数据类型 变量2...
2.在调用函数的时候 实际参数和形式参数的 个数 顺序 数据类型必须一一对应
案例：
public class Demo{
	//
	public static void main(String[] args) {
		System.out.println("瘦小离家胖了回");
		printLine(10,"-");
		System.out.println("乡音不改肉成堆");
		printLine(20,"*");
		System.out.println("儿童相见不相识");
		printLine(30,"$");
		System.out.println("笑问胖子你是谁");
		printLine(40,"!");
		
	}
	//定义一个函数 printLine() 
	public static void printLine(int n,String s){
		for(int i = 1;i<= n;i++) {
			System.out.print(s);
		} 
		System.out.println();
	}
	
}
练习：  定义一个函数 函数的功能是 计算两个 int类型数据的和 并打印输出

函数名： add
形参列表： int a , int b 
函数的实现：int sum = a+b   输出sum
代码：
public class Demo{
	//
	public static void main(String[] args) {
		/*int c = 30;
		int d = 40;*/

		add(30,40);
		
	}

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

函数的返回值

娶媳妇 
定义一个丈母娘函数
函数名：zmn  
函数的参数：钱类型 彩礼   汽车类型  宝马x6   房子  三室一厅
返回值：女孩类型 只有一个

返回值：是函数返回给函数调用者的数据  

返回值类型：8种基本数据类型  String引用数据类型  以后所有的引用数据类型
		void ：当函数没有返回值的时候定义为void 
案例：
public static 女孩类型 zmn(钱类型 彩礼, 汽车类型  宝马x6, 房子  三室一厅){
	return 媳妇；
}

return 语句：用于在函数中将数据返回给函数的调用者
语法：
return 返回值；

案例： 定义一个函数  功能是  计算两个整数的和 将和返回给函数的调用者

函数名：add
形参列表： 2个参数  int      int a.int b
返回值类型：int

public class Demo{
	//
	public static void main(String[] args) {
		int result = add(34,45);
		
		System.out.println(result);
		
	}

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

}

==================================================================
案例：一个函数中最后只能有一个返回值 不能返回多个返回值
public class Demo{
	//
	public static void main(String[] args) {
		int result = add(34,45);
		
		System.out.println(result);
		
	}

	public static  int add(int a,int b){
		int sum = a + b;
		int ji = a*b;
		return sum;
		return ji;//错误的！！！！！
	} 

}
=================================================================
案例：当函数中存在 分支结构时 必须保证每个分支都有return语句 
public class Demo{
	//
	public static void main(String[] args) {
		int result = add(34,45);
		
		System.out.println(result);
		
	}

	public static  int add(int a,int b){
		if (a>b) {
			return a+b;
		} else{
			return a*b;
		}
		
	} 

}

案例： 当函数中存在循环结构时 如果循环的条件和形参有关系时 那么可能不会进入循环结构 需要在循环结构外 书写return语句
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		m(-4);
		
	}
	public static int m(int n){
		for(int i = 1;i<=n;i++) {
			return i;
		} 
		return -1;	
	}
}
===============================================================
案例：当return语句用在无返回值的函数中经常用于直接结束函数 其后的代码为不可达代码 会编译报错
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		
	}
	public static void m1(int a){
		int sum = 0;
		sum = a*a;
		return;//结束函数
		System.out.println(sum);	
	}
}

总结

函数概念：能够实现特定功能的一段代码 可以通过名称反复使用
函数的定义：
	函数的声明：
	public static 返回值类型  函数名（形参列表）
	函数的实现：
	｛｝
	函数定义的语法：
	public static 返回值类型  函数名（形参列表）｛
		函数实现；
	｝
函数的参数：
	实际参数:函数调用者 在调用函数的时候传入函数的实际数据
	形式参数：声明了 函数需要什么类型的数据 只是一个形式而已
	参数之间是用 ，隔开
函数的返回值：
	类型：8中基本数据类型 和 无数种引用数据类型
	返回返回值的语句： return 语句   
    	语法：return 返回值；
    	注意：
    		1.函数的返回值只有一个 不可以同时返回多个返回值
    		2.当有返回值函数中存在分支结构时 必须保证每个分支都有return语句
    		3.当有返回值函数中存在循环结构时 循环条件如果和形参有关系时 可能存在进入不到循环结构中的情况 所以要在循环外添加return语句
    		4.当return语句在返回值类型为void的函数中 return语句的作用是直接结束函数 其后的语句为不可达代码

函数的作用：
	1.减少冗余代码 增强了代码的结构化
	2.利于代码的重复利用
	3.便于维护 
	4.使程序具有模块化 

函数的嵌套调用

函数的嵌套调用就是：函数之间的相互调用
案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		System.out.println("主函数开始执行");//1
		
		m1();
		System.out.println("主函数 执行结束");//6
		
	}
	// m1
	
	public static void m1(){
		System.out.println("m1被调用了");//2
		m2();
		System.out.println("m1函数调用结束了");//5
		
		
	}
	// m2
	public static void m2(){
		System.out.println("m2被调用了");//3
		System.out.println("m2函数 结束了");//4
		
		
	}
	
}

案例： 利用函数的嵌套调用  计算 4的阶乘

4！ = 4*3！  jc4(){jc3()}
3！ = 3*2！  jc3（）｛jc2（）｝
2！ = 2*1*  jc2(){jc1()}
1！ = 1
    
形参： 1个  int a
返回值类型：int  
代码：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int result = jc4(4);
		System.out.println("结果是："+result);
			
	}
	
	// jc4() 
	public static int jc4(int n ){
		return n*jc3(n-1);
	}
	//jc3()
	public static int jc3(int n ){
		return n*jc2(n-1);
	}
	//jc2()
	public static int jc2(int n ){
		return n*jc1(n-1);
	}
	//jc1()
	public static int jc1(int n){
		return 1;
	}
	
}

递归

概念：在一个函数中调用自身的操作叫做递归 
递归注意的事项：
	1.递归一定得有一个临界点进行回归 否则会发生无限递进
	2.即使递归有临界点进行回归 那么也不能递进层数太多 否则会发生栈溢出异常
说明：
1.当计算40阶乘的时候可能没有发生栈溢出异常 但是结果为0 是系统截取高位的效果
2.当计算999999的阶乘时 会直接报栈溢出异常  
3.发生栈溢出异常的决定因素是电脑的内存为栈内存分配的大小
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int result = jc(999999);
		System.out.println("结果是："+result);
			
	}
	
	// jc4() 
	public static int jc(int n ){
		if (n==1) {
			return 1;
		}else{
			return n*jc(n-1);
		} 	
	}
}


练习： 键盘输入一个数n  要求电脑 输出斐波那契数列的第n项是多少
1 2 3 4 5 6 7   8  9
1 1 2 3 5 8 13  21 34 。。。。。
用递归实现

临界点：
if(n==1||n==2){
	return 1；
}else{
	return 前一个 和 前前一个
}

案例：
import java.util.*;
public class Demo{
	public static void main(String[] args) {
		int result  = panDuan(-8);
		System.out.println("结果是："+result);
			
	}
	
	public static int fei(int n){
		if (n==1||n==2) {
			return 1;
		} 
		else{
			return fei(n-1)+fei(n-2);
		}
		
	}
	public static int panDuan(int n){
		if (n<=0) {
			System.out.println("数据非法");
			return -1;
		} else {
			return fei(n);
		}
		
		
	}
}