首先函数就是为了解决很多重复的代码段，为了避免重复，他们的作用就显得很大，而且他们互相独立，互相之间可以调用，这样代码就显得比较清晰。

例如Math.random()方法来产生一个随机数，还有最大值，最小值，绝对值函数这些都是Math类中的常见函数

还有其他的指数函数还有三角形函数等等，但是除过这些类中包含的函数外，我们自己也可以自定义函数，自己去调用函数，使原本复杂抽象的题模块化和简单化，进而得到解决。

1.函数定义

1.1函数的具体存在意义

其实上面也说到，将代码模块化划分为一个个函数体，互相独立的功能，降低了代码冗余用调用函数可以起到事半功倍的效果，

为什么可以内存优化：在讲到函数进出栈的顺序与了解函数使命的时候就很清楚了。

1.2 函数的格式

其实可以对照主函数的 public static void main（System.in）来对照来看。

访问权限  函数类型 返回值类型 函数名称（参数列表）{函数体return 返回值；}

函数名：程序员自己定义但是定义注意字母大写问题
参数列表：这里面一般都是些定义的参数
return：就跳出当前函数，如果有返回值的话，函数结束前将返回值返回给调用者
返回值类型：这里一定要写返回值的数据类型（注意兼容问题int->double）

2.函数的分类和传参问题

2.1函数分类

一般函数分为四大类：有返回值有参数，有返回值无参数，无返回值有参数，无返回值无参数。

一般有返回值的函数都是把返回值参与运算，赋值，输出等。

一般没有返回值的就是仅仅调用函数体。

2.2函数的传参问题

在这里有很多初学者就对这里参数和定义变量搞混，一定搞清实参和形参的区别。

实参：它是你调用函数的时候给函数输入的或者说传递的常量或者变量。
形参：就是函数的参数列表里的东西。

这里就牵扯实参传递形参的形式：它还是将一个常量在常量池中的地址传递给形参。

形参在函数体内变化，所以就有了局部变量一说，在函数体里面定义的变量都是局部变量，所以局部变量的作用域只仅仅限于函数体内，这就等于函数被封装了，外界只能看到只有return出的一个结果，如果你调用它，它只会给你返回值，不会看到内部是怎样的结构。

3.函数栈

首先栈比如说是一个容器，把函数体当做石头，一个一个往进放，如果return了一个函数体，然后这个函数就会被弾栈，往往主函数会第一个进入栈内，后面进的函数位于栈顶它是往往首先运行，return完了之后，再进行主函数运行，如果再来一个函数，那么同样的方法，这样就解决掉了之前说的函数的内存优化问题。

此图为栈内存储图。

这样就解释的通进栈顺序ABCDEF出栈顺序为FEDCBA，如果把每个看做函数就可以看到函数的运行方式与结束时刻，内存变化的问题。

4.函数的重载与递归

4.1函数的重载

定义：在相同的声明域中的函数名相同的，而参数表不同的，即通过函数的参数表而唯一标识并且来区分函数的一种特殊的函数。

顾名思义重载就是重复执行，但肯定有限制条件，什么样的函数可以重载呢？

同一类中的同名函数。

功能相似

这样做减少了函数名的数量,避免了名字空间的占用,对于程序的可读性有很大的好处。函数重载要求编译器能够唯一地确定调用一个函数时应执行哪个函数代码。

但是这里有几个问题

（1）不能改变运算符的优先级；

（2）不能改变运算符的结合型；

这样就会出现兼容类型的错误，如果可兼容的参数定义有多个int+int 返回值类型（double+int）或者（int+double）此时就会出错（引用不明却，它不知道你到底是那个类型转那个类型，但是如果是double定义就不会出现了）

（3）默认参数不能和重载的运算符一起使用；

4.2函数的递归

递归其实通俗来说就是函数套函数，这样的步骤虽然有的重载也能适用但是代码量太大。现在来具体说一下函数是怎么递归的。

在一个函数的内部调用一个函数就叫做函数的调用，这就分了呗调函数和主调函数。
被调函数作为主调函数再次调用函数就实现了函数的嵌套。
函数嵌套遵循逐级调用，逐级返回，先调后返，后调先返的原则。

在当函数的递归调用就是调用一个函数时直接或者间接的调用了函数本身

这就是递归函数的大致意思

递归就是比如愣头青不到黄河不死心的人，但是有时候它就是管用。

前进：所向披靡具体的意思是把问题分治之。

结束：就是这条路走到头了，意思就是该问题必须得处理然后处理问题。

返回:但是撞的头破血流终究还是得回，意思就是往它的上一级返回。

著名的斐波那契数列则是使用的递归调用的方法；

例：计算 1+1+2+3+5+7+12+19+..........+n的值

分析：

这个题的规律就是每一项等于前两项的和，写的时候从后往前写，当用到函数的时候，继续往前，逐级调用。

当n=4时，往下递的时候f（4）=f（3）+f（2）    f（3）=f(2)+f（1）

此时函数的最底层就必须定义f（1）=1   f（2）=1

当推到底层的时候就等于函数return了一个f(1)=1    f（2）=1

开始往上归得到f（4）的值

import java.util.Scanner;
class feibo{public static void main(String[] args){Scanner in=new Scanner(System.in);System.out.print("请输入斐波那契数列的个数：");int n=in.nextInt();for(int i=1;i<=n;i++){System.out.println(f(i));//使用for循环遍历每一个值最后输出当i=n的时候结束循环}public static int f(int n){if(n==1||n==2){return 1;}return f(n-1)+f(n-2);
}

2.汉诺塔

分析：拿4个块举个例子

先看流程：要用递归必须得把A中的全部块放到C中，先递再归。

那么A必须首先得把前三个挪到B上然后第四个再挪到C，以此类推。

四个A-C    前三个A-B

前两个A-C 前一个 A-B 第二个A-C 前一个 B-C

第三个A-B

前两个C-B      前一个 C-A 第二个C-B 前一个 A-B

第四个A-C

前三个B-C

前两个B-A 前一个 B-C 第二个B-A 前一个C-A

第三个B-C

前两个A-C     前一个 A-B 第二个A-C 前一个 B-C

总结规律就是：每一次块数减一时候   三个顺序就成为（A C B）

再减一就成为（B A C）

这里的ABC只代表路径   它是动态变化的过程   一直这样递到块数为1的时候就是A-C   然后再往上归。

class Hanno{public static void main(String[] args){//盘子的个数 出发 中间 目的hanno(64,"X","Y","Z");}                                     public static void hanno(int n,String begin,String mid,String end){if(n==1){System.out.println(begin+" -> "+end);}else{hanno(n-1,begin,end,mid);System.out.println(begin+" -> "+end);hanno(n-1,mid,begin,end);}}
}

4.3 常用函数

在文章的开头也讲到了一些java中自己封装的函数只需要程序员来调用就可以，那么常见的函数都有哪些呢，从java.lang的软件包中主要提及java.lang.Math类和java.lang.String类来解决大多数实际的问题。

这两大类中常见的函数及功能是怎样的呢？

Math类：默认返回值都是double型

名称                                              功能

Math.E                                           近似e的double值

Math.PI                                        比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值

Math.abs(double a)                         返回double值的绝对值

Math.ceil(double a)      返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数

Math.max(double a,double b)         返回两个 double 值中较大的一个

Math.min(double a,double b)            返回两个 double 值中较小的一个

Math.hypot(double x,double y)          返回 sqrt(x2 +y2)，(也就是说算两点间距离公式）

Math.pow(double a,double b)          返回a的b次幂的值

Math.sprt(double a)                        返回正确舍入double值的正平方根

Math.random()                               返回带正号的double值，该值区间为[0 1.0)

Math.rint(double a)                         返回最接近参数a并且等于某一整数的double值

Math.round(a)                                返回最接近参数就等于是向下取整

String类：

注：【对字符串的修改永远都不是对其自身进行的修改字符串本身是不可变的，对字符串的修改往往都是新建个字符串将修改后内容赋值并返回新的字符串】

名称                                          功能

查询

char charAt(int index)                  返回指定索引值的char值

int indexOf(int ch)                       返回指定子字符串在此字符串中第一次出现处的索引

int lastIndexOf(int ch)                  返回指定子字符串在此字符串中最右边出现的索引

int length()                                  返回字符串的长度

substring(int beginIndex, int endIndex) 返回值一个新字符串，它是此字符串的一个新字符串。

判断

boolean contains(String s)            当且仅当此字符串包含指定的 char 值序列时，返回 true

boolean startsWith(String prefix)   测试此字符串从指定索引开始的子字符串是否以指定前缀开始

boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写

boolean isEmpty()                         当且仅当 length（） 为 0 时返回 true。

int compareTo(String anotherString)按字典顺序比较两个字符串。

boolean endsWith(String s)            测试此字符串是否以指定的后缀结束。

boolean equals(String anotherString)将此字符串与指定的对象比较

修改

String replace(char oldChar, char newChar) 使用指定的字母替换序列替换此字符串所有匹配字母目标序列的子字符串。

String toUpperCase()                   将此 String 中的所有字符都转换为大写。

String toLowerCase()                    将此 String 中的所有字符都转换为小写。

String trim()                                  返回字符串的副本，忽略前导空白和尾部空白

下面是利用函数在字符串的应用

1.求s2在s1中出现的次数
s1="12376128736123123612312312536123123” s2="12"

分析：

1.先定义count计数器找到一次与之匹配加一

2.用for循环遍历从0到s1长度减去s2长度加一再往后就到头了

3.s1.substring(i,i+s2.length())这函数表示 i从0开始找与s2长度相同的的字符串依次遍历

4.sub.equals(s2))表示已经找到与之相等的那么count计数器加一

5.直到遍历结束

 class Lei{public static void main(String[] args){question();}public static void question(){  String s1="12376128736123123612312312536123123";String s2="12";int count=0;for(int i=0;i<s1.length()-s2.length()+1;i++){String sub=s1.substring(i,i+s2.length());if(sub.equals(s2)){count++;}}System.out.println("s2在s1中出现了"+count+"次");}
}

2.判断字符串s是否是回文
s="上海自来水来自海上"

分析：

1.判断是否为回文肯定是左边和右边相同那么就从两边同时遍历

2.定义左边初值为0 右边为length-1 长度也是下标

3.使用s.charAt(left)==s.charAt(right)截取下标值对应的字符看是否相等

4.如果相等那么左右两个下标往中间移动实现夹逼思想

5.当左边下标比右边下标大的时候循环跳出遍历结束

6.使用标签flag判断是否回文

class Lei{public static void main(String[] args){question2()}public static void question2(){String s="13088888031";int left=0;int right=s.length()-1;boolean flag=true;while(true){if(s.charAt(left)==s.charAt(right)){left++;right--;if(left>=right){break;}}else{flag=false;break;}}System.out.println("s是回文吗:"+flag);}
}

3. 求s1和s2中最大的相同子串(s1.length()>s2.length())

s1="Python is a program language but is slow";
s2="Java is a program language but is fast"

分析：

1.使用for循环遍历从大到小

2.再利用for循环两头开始遍历一个循环控制个数另一个循环控制在这些个数中的遍历

3.sub=s2.substring(i,j+1) 这就表示了把每一个出现的字符都给了sub

4.s1.contains(sub） s1中包含了s2的的sub那么就输出循环结束

class Lei{public static void main(String[] args){question()}public static void question(){String s1="Python is a program language but is slow";String s2="Java is a program language but is fast";boolean flag=true;for(int len=s2.length();len>=1;len--){for(int i=0,j=len-1;j<s2.length();i++,j++){String sub=s2.substring(i,j+1);if(s1.contains(sub)){flag=false;System.out.println("结果就是["+sub+"]");break;}}if(!flag){break;}}}
}

下面是本章的一些练习题

分析：实现功能的两个函数实现反转reverse(int num) 判断是否素数isSuShu(int num)

1.做很多函数的题应该从小到大来写

2.分为四个模块

第一个实现反转

当反转和num值相等时 return true 给Boolean类型的 isHuiWen(int num)回文函数

然后判断是否为素数 1.使用for循环从2到num/2遍历如果有num%i==0 那么就不是素数

isHuiWenAndSuShu(num)是把回文函数和素数函数同时实现return true

3.定义一个计数器count=0 和一个 num=2（回文的数字）

4.当写主函数时循环一次num++ 当遇到一个回文素数时 count++ 打印num

5.如果每10个换一行那么count%10==0 System.out.println(); 就可以实现

6.当count加到100时 break掉while循环结束

class Lei{public static void main(String[] args){int count=0;    //表示回文素数的个数int num=2;      //表示可能的回文素数的数字 while(true){//如果num是 回文素数if(isHuiWenAndSuShu(num)){count++;System.out.print(num+" ");if(count%10==0){System.out.println();}}if(count==100){break;}num++;}}public static boolean isHuiWenAndSuShu(int num){return isHuiWen(num)&&isSuShu(num);}public static boolean isHuiWen(int num){return reverse(num)==num;}public static int reverse(int num){int sum=0;while(true){sum=sum*10+num%10;num/=10;if(num==0){return sum;}}}public static boolean isSuShu(int num){for(int i=2;i<=num/2;i++){if(num%i==0){return false;}}return true;}
}

分析：

1.先看模块和例题一很像分为判断素数非回文反转

2.分为判断素数isSuShu(int num)   非回文isHuiWen(int num) 反转reverse(int num)

然后判断是否为素数 1.使用for循环从2到num/2遍历如果有num%i==0 那么就不是素数

当反转和num值相等时 return true 给Boolean类型的 isHuiWen(int num)回文函数

反转素数的意思是isSuShu(reverse(num))    函数套函数

非回文是返回 reverse(num)！==num

3.定义一个计数器count=0 和一个 num=2（非回文反转的素数）

4.当写主函数时循环一次num++     当遇到一个回文素数时 count++      打印num

5.如果每10个换一行那么count%10==0    System.out.println();    就可以实现

6.当count加到100时 break掉while循环结束

class Lei{public static void main(String[] args){int count=0;int num=2;while(true){if(isFanZhuanSuShu(num)){count++;System.out.print(num+" ");if(count%10==0){System.out.println();}}if(count==100){return; //结束当前函数}num++;}}public static boolean isFanZhuanSuShu(int num){return isSuShu(num)&&isSuShu(reverse(num))&&!isHuiWen(num);}//回文功能public static boolean isHuiWen(int num){return reverse(num)==num;}//素数功能public static boolean isSuShu(int num){for(int i=2;i<=num/2;i++){if(num%i==0){return false;}}return true;}//反转功能public static int reverse(int num){int sum=0;while(true){sum=sum*10+num%10;num/=10;if(num==0){return sum;}}}
}

下面就是函数在字符串里的应用

分析：

首先写主函数提示用户输入密码使用if语句判断是否合法

再看限制条件（同一一先定义局部变量都是字符串s   字符c）

首先定义合法的函数Valid()

再判断Valid()函数中拥有多少函数

长度LengthValid()             判断 s.length()>=8;并且返回

是否是字母字符 Letter(c)    判断c>='a'&&c<='z' || c>='A'&&c<='Z';并且返回

Digit(c)是否为数字字符      判断 c>='0'&&c<='9';并且返回

这里再定义一个判断是否既有数字也有字母   那就是如果没有数字和没有字母 return false即可

至少两个数字再定义NumberValid() 在此函数中调用函数Digit(c)如果返回true 那么计数器count++即可    此函数返回值判断是否count>=2

当然这里判断函数所返回的值都是Boolean类型

import java.util.Scanner;
class Lei{public static void main(String[] args){Scanner scanner=new Scanner(System.in);System.out.print("请输入密码:");//先提示用户输入密码(String password)String password=scanner.nextLine();if(isValid(password)){    //将密码传到boolean isValid(password) 判断是否合法System.out.println("密码合法!");}else{System.out.println("密码不合法!");}}public static boolean isValid(String s){    //包含下面所有的函数返回true的话就是合法return isLengthValid(s)&&isContentValid(s)&&isNumberValid(s);}public static boolean isLengthValid(String s){//判断长度是否大于8return s.length()>=8;}public static boolean isContentValid(String s){//仅能包含字母和数字就必须调用下面的两个函数  如果满足返回truechar c=' ';for(int i=0;i<s.length();i++){c=s.charAt(i);if(!isLetter(c)&&!isDigit(c)){return false;}}return true;}public static boolean isNumberValid(String s){//此函数是判断数字个数是否大于2int count=0;char c=' ';for(int i=0;i<s.length();i++){   //使用便利字符串来定位位置c=s.charAt(i);               //把每一个字符取出来为赋给cif(isDigit(c)){              //判断是否有数字count++;                             }}return count>=2;                 //计数大于2返回true}public static boolean isLetter(char c){  //判断该字符是否为字母字符return c>='a'&&c<='z' || c>='A'&&c<='Z';}public static boolean isDigit(char c){   //判断该字符是否为数字字符return c>='0'&&c<='9';}}

4. s.charAt(i)具体应用利用便利出字符串的角标来分离出每一个字符

class Lei{public static void main(String[] args){String s="abcasjdjhsadadbhasdvasbd";System.out.println(count(s,'a'));}public static int count(String s,char c){   //此函数定义字符串s和字符cint count=0;for(int i=0;i<s.length();i++){if(s.charAt(i)==c){  //如果截取到字符和c字符一样那么计数器加一即可count++;}}return count;    //返回搜索的个数}
}

5.用reverse（）函数实现字符串反转

思想就是：使用s.charAt(i)函数来定位字符那么i值是从字符串的右边开始截取字符并且拼接即可

class Lei{public static void main(String[] args){String s="123456";System.out.println(reverse(s));}public static String reverse(String s){String res="";//定义空串for(int i=s.length()-1;i>=0;i--){ //从后往前遍历res+=s.charAt(i);//拼接字符}return res;  //返回反转字符}
}

6.判断字符串的大小写及其数目

分析：

1.定义一个函数大写字母只需判断该字符是否在A到Z的区间内代码就是判断是否c>='A'&&c<='Z';并且返回

2.定义另一个函数输入字符串定义计数器count 并且遍历截取他的字符然后调用大写字母函数如果为true 那么计数器加一 count++ 返回count即可

class Lei{public static void main(String[] args){String s="Welcome To China";System.out.println(getUpperCase(s));//调用函数返回值count并且打印}public static int getUpperCase(String s){int count=0;for(int i=0;i<s.length();i++){    //遍历字符串if(isUpperCase(s.charAt(i))){ //判断是否有大写字母count++;                  //如果有那么加一次}}return count;}public static boolean isUpperCase(char c){return c>='A'&&c<='Z';            //判断是否为大写字母                }
}

7.显示共同前缀

分析1：

主函数定义两个字符串并且调用函数getCommonPrefix(String s1,String s2)

定义函数下来首先判断两个字符串长度哪个小，用小字符串来遍历

用for循环遍历在小字符串里从角标0开始比较相同角标字符是否相等如果不等那么去截取字符串角标（0，i）

分析2：

先定义两个字符串的指针从0开始

使用while循环利用两指针的关系可以遍历出他们的共同子串通过当 s1.charAt()==s2.charAt(）的方法来判断是否下次遍历每当为true时两个指针同时往后跑一格

如果指针a跑到他的最大长度时那么就返回s1即可（他是小串），同理可得s2

class Lei{public static void main(String[] args){String s1="Welcome";String s2="Welcome";System.out.println(getCommonPrefix(s1,s2));}public static String getCommonPrefix(String s1,String s2){/*  第一种方法String minStr="";    //定义小串为空String maxStr="";    //定义大串为空if(s1.length()<=s2.length()){   //把s1和s2判断那个为小串那个为大串minStr=s1;      maxStr=s2;}else{minStr=s2;maxStr=s1;          }for(int i=0;i<minStr.length();i++){        //遍历小串if(minStr.charAt(i)!=maxStr.charAt(i)){  //如果遍历小串角标i不等于大串角标i的时候  那就截取到i角标即可return minStr.substring(0,i);   //取出字符串}}return minStr;              //小串找完了那么就说明小串都是大串里包含的*///第二种方法int pa=0;   // 定义s1的指针  就和字符串的角标一个样子int pb=0;   // 定义s2的指针while(true){if(s1.charAt(pa)!=s2.charAt(pb)){   //如果同时移动角标的时候遇到不相等时，截取任意一个字符串（角标为0-pa或pb）return s1.substring(0,pa);}if(s1.charAt(pa)==s2.charAt(pb)){   //字符都相等时   同时往后移动角标pa++;pb++;}if(pa==s1.length()){       //如果角标移动到s1末端时  那么就说明s1被s2全部包含return s1;}if(pb==s2.length()){       //如果角标移动到s2末端时  那么就说明s2被s1全部包含return s2;}}}
}

8.进制的转换

分析：

首先16进制是有大写字母的先让大写字母变为数字然后再进行运算

定义Boolean大写字母函数 isLetter（）判断c>='A'&&c<='F'并且返回

遍历时我们取到字符串中字符的角标使用角标来找出那个字符然后判断是否为字母

如果是字母那么使用 num+=(c-'A'+10)*Math.pow(16,i) 计数

如果是数字那么就 num+=(c-'0')*Math.pow(16,i) 计数

class Demo04_12{public static void main(String[] args){String s="AB8C";System.out.println(hexToDeimal(s));}public static int hexToDeimal(String s){int num=0;char c=' ';for(int i=0;i<s.length();i++){c=s.charAt(s.length()-1-i);if(isLetter(c)){num+=(c-'A'+10)*Math.pow(16,i);}else{num+=(c-'0')*Math.pow(16,i);}}return num;}public static boolean isLetter(char c){return c>='A'&&c<='F';}
}

Lei ❤函数的初识相关推荐

函数的初识；函数的返回值；函数的传参
函数的初识: 避免重复代码,增强可读性. 函数是以功能为导向的. def 函数名(形参): 函数体函数名() 实参 def 关键字函数名(与变量命名规则一样) 1.由数字字母下划线组成 2.不能由 ...
Python函数01/函数的初识/函数的定义/函数调用/函数的返回值/函数的参数
Python函数01/函数的初识/函数的定义/函数调用/函数的返回值/函数的参数内容大纲 1.函数的初识 2.函数的定义 3.函数的调用 4.函数的返回值 5.函数的参数 1.函数初识 # def ...
C语言的底层逻辑剖析函数篇（其二），0基础搞定函数，初识函数递归，超详解
这里写目录标题 C语言的底层逻辑剖析函数篇(其二),0基础搞定函数,初识函数递归,超详解开篇语函数的调用(嵌套调用和链式访问) 1.嵌套调用 2.函数的链式访问函数的声明和定义函数声明和定义分 ...
mysql length函数_初识LLDB 调试 MySQL-爱可生
作者:洪斌 MySQL数据库最大的优势,想必就是可以直接通过代码调试来学习数据库内部逻辑.任何问题.任何疑惑在debug源码面前都无法掩盖,还可以提升对数据库内核的理解能力,是不是有一种可以掌控一切的 ...
Day 9 函数的初识1
def my_len(): l1 = [1,2,3,5,6] print(111) print(222) return print(333)print(my_len()) 一.函数的定义1.遇到ret ...
python函数一
函数一.函数的初识比如:我们测量一个字符串'asdfghj'的长度,但是不让用len()的方法 s = 'asdfghj' count = 0 for i in s:count += 1 prin ...
Python函数Day1
一.函数的初识函数的定义:函数最主要的目的是封装一个功能,一个函数就是一个功能定义函数的格式: def 函数名(): 函数体 def my_len():count = 0s1 = 'hahahah ...
js 匿名函数_javascript：函数的使用
大家好,我是专注于前端开发,前端入门,精神可爱的前端小学妹,本期为大家带来的Web前端学习知识是"javascript:函数的使用",喜欢Web前端的朋友,一起看看吧! 主要内容: ...
1.函数的结构，调用，传参，形参，实参，args,kwargs，名称空间，高阶函数
1.函数的初识初始函数获取任意一个字符串的元素的个数 s1='dsjdkjkfefenga' count=0 for i in s1:count+=1 print(count) 获取列表的元素的个 ...

Lei ❤函数的初识