JAVA第五章函数

第五章函数

5.1函数的概念

5.2函数运行原理

5.3函数重载

5.4函数的递归

5.5编程练习

5.1函数的概念：
函数的定义：
函数的定义就是指一段具有独立功能的代码，减少代码冗余，提高程序的利用率和效率；
那应该怎样定义一个函数呢？
1.需要的封闭空间，用于将这段独立性的代码进行封装，使用的是一对大括号{}；
2.需要对每一个封闭的空间进行命名，即函数名；
3.其所需要的一些原始数据；
4.所产生的一些结果数据；
函数的语法格式：
修饰符 函数类型 返回值类型 函数名 （数据类型 数据1,2、、）{
独立功能的代码片段；
return 函数的计算结果；
}
修饰符：指函数的访问权限，public，private，protected
函数类型：函数分类，本地函数native，静态函数static，同步函数synchronized
参数列表：外界向函数传入的数据（实际参数），由这些参数变量进行接收，（形参）；
函数体：具有独立功能的代码片段；
return：仅表示函数结束；若有返回值，则后面加返回值；没有返回值则可以不写，但其return是存在的（隐藏在最后一行）；
根据返回值类型不同分为：有参数有返回值，有参数无返回值，无参数有返回值，无参数无返回值；
举例如：
求三个数的最大值； 有参有返
将三个字符串反转，并拼接打印； 有参无返

·总结函数定义需要注意的细节：
· 1.函数的运行需要有哪些未知参数？
2.函数运行的结果是？
3.明确参数和结果；
4.明确内容和返回值；
5.函数的目的，尽量将独立功能的且重复使用的代码块提取出来
5.2函数运行原理
函数是基于栈运行的；
栈：是一种后进先出的容器，这里的栈是指JVM中的栈内存空间；
每一个函数，叫做栈帧；栈帧中的内容有函数的定义，参数列表，函数的执行内容代码，每个函数要运行，就相等于这个栈帧进到栈内存中，叫做入栈；一个函数即将结束，栈帧从栈顶移出，简称出栈；
栈内存中有多个栈帧，先运行最上面的，底下的暂停运行，直至栈帧为栈顶元素；
例如：主函数先进，开始逐行运行，执行到第N行，调用另外一个函数a，则N行暂停，将另一个函数a的栈帧入栈，直至a的内容执行完毕，a出栈，主函数接着从第N行开始往下执行；
内存图仅供参考，有错请纠正：
import java.util.Scanner;
public class Demo68{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
//提示用户输入一个数字；
System.out.print(“Enter a number:”);
int number = input.nextInt();
System.out.println(isPalindrome(number));
}//判断是不是回文字符串；
public static boolean isPalindrome(int number){
int revNum = reverse(number);
return number == revNum;
}//字符串的反转输出；
public static int reverse(int number){
int result = 0;
while(number != 0){
result = result * 10 +number %10;
number /= 10;
}
return result;
}
}
5.3函数重载：
同一个函数类中可以出现多个同名函数，这就叫函数重载；
函数重载关系区分：
1.必须是同名；
2.与返回值类型无关（返回值类型只和函数的计算功能有关）；
3.与权限，形式参数的名称无关；
4.只和形式参数的数据类型有关（数量，排列组合）；
判断如下是不是public static void show(int a,float b,char c)重载；
int show(int x,float y,char z):不算；
void show(float b,int a,char c):算，顺序不一样；
void show(int a,int b,int c):算：顺序不一样；
void show():算，参数不一样；
寻找重载函数的流程如下：
1.看是否有明确的参数定义匹配； int int 找 int int；
2.看是否有可兼容的参数定义匹配，int int找double double或int double 或double int；
3.若可兼容的参数定义匹配较多，会报引用确定报错，引用不明确；
5.4函数的递归
函数的递归是指函数的自身调用；
但凡迭代能解决的问题，递归都能解决，递归能解决的问题，迭代就不一定了；
一般而言，从内存的角度来说，函数过多的自我调用会导致内存占用过多；
通常来说，同样的问题用递归写比用迭代写代码量少很多；
写递归时，一定要先确定其递归结束条件，即递归边界；
一般是迭代的，数学归纳法的问题使用递归；
使用递归实现1+2+。。。+100；

斐波那契数列递归实现；

5.5编程练习：
import java.util.Scanner;
public class Demo68{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
//提示用户输入一个数字；
System.out.print(“Enter a number:”);
int number = input.nextInt();
System.out.println();
}//判断是不是回文字符串；
public static boolean isPalindrome(int number){
int revNum = reverse(number);
return number == revNum;
}//字符串的反转输出；
public static int reverse(int number){
int result = 0;
while(number != 0){
result = result * 10 +number %10;
number /= 10;
}
return result;
}
}

1.21代码练习：

public class Demo67{
public static void main(String[] args){
System.out.println(sumDigits(14563));
}
public static int sumDigits(long n){
int sum = 0;
while(n != 0){
sum += n % 10;
n = n / 10;
}
return sum;
}
}

import java.util.Scanner;
public class Demo70{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
String password = input.nextLine();
if(condition1(password)&&condition2(password)&&condition3(password)){
System.out.println(“valid”);
}else{
System.out.println(“invalid”);
}
}
public static boolean condition1(String password){
return password.length()>=8;
}
public static boolean condition2(String password){
for(int i= 0;i<password.length();i++){
if(!(Character.isLetterOrDigit(password.charAt(i)))){
return false;
}
}
return true;
}
public static boolean condition3(String password){
int count = 0;
for(int i= 0;i<password.length();i++){
if((Character.isDigit(password.charAt(i)))){
count++;
}
}
return count >=2;
}
}

public class Demo73{
public static void main(String[] args){
System.out.println(sqrt(4));
}//写一个函数计算一个数的平方根；
public static double sqrt(long n){
double lastGuess = 1;
double nextGuess = 0;
while(true){
nextGuess = (lastGuess +n / lastGuess)/2;
if(Math.abs(lastGuess - nextGuess)>0.0001){
lastGuess = nextGuess;
}else{
break;
}
}
return nextGuess;
}
}

public class Demo74{
public static void main(String[] args){
int number = 2;
int count = 0;
while(count<100){
if(isSuShu(number)&&isHuiWen(number)){
System.out.print(number + “\t”);
count++;
if(count % 10 == 0){
System.out.println();
}
}
number++;
}
}
public static boolean isHuiWen(int number){
int revNum = reverse(number);
return revNum == number;
}
public static int reverse(int number){
String sum = “”;
while(number != 0){
sum = sum +number % 10;
number = number / 10;
}
return Integer.parseInt(sum);
}
public static boolean isSuShu(int number){
for(int i = 2;i<=number /2;i++){
if(number % i == 0){
return false;
}
}
return true;
}
}

public class Demo76{
public static void main(String[] args){
for(int p = 2;p<=31;p++){
int number = (int) Math.pow(2,p)-1;
if(isSuShu(number)){
System.out.println("p= “+p+”,SuShu= "+number);
}
}
}
public static boolean isSuShu(int number){
for(int i = 2;i<= number/2;i++){
if(number % i == 0){
return false;
}
}
return true;
}
}