來嘍來嘍，你們的小白來嘍
這次我們來一起探討關於函數
一、函數的定義
想學習一個東西，咋們得先了解他的定義，以及他存在的意義，那麼函數存在的意義是啥子呢？
函數主要解決的是那些重複的且具有獨立功能的代碼段，函數將這些具有獨立功能的的代碼進行封裝，封裝出來的東西叫做函數.
函數它又有什麼優勢呢？降低了代碼冗餘複用函數即可，降低了主函數的代碼量，將主函數進行適當的拆分，以便內存優化，通俗一點說就是將函數模塊化。
函數的格式
訪問權限 函數類型 返回值類型 函數名（參數列表）{
函數體 ；
return 返回值 ；
}
訪問權限 ：指函數的使用範圍（內部/外部）例如有public、protected、 默認不寫、 private 他們的權限範圍從大到小。
函數類型：指的是函數類型的分類，也就是說函數具體使用的場景和場合。 具有 static 靜態函數 、默認不寫 成員函數、abstract 抽象函數、native 本地函數、synchronized 同步函數。
返回值：指的就是這一具有獨立功能的代碼塊的計算結果，需要傳遞給外界 配合return。 void其實也有return的，只是他默認不寫而已。返回值類型：就是返回值的數據類型（可兼容）。
函數名：程序員給這段代碼自定義的名稱（標識符）。
參數列表：參數列表由作幹個，參數類型，參數名組成 主要接受外界傳遞給函數的一些數據。
函數體：那些具有獨立功能的代碼塊。
return：僅僅表示結束當前函數，如果有函數值，則函數結束前將返回值返回給調用者。
咋們簡單的寫一串代碼，對其分析分析
class Test1{
public static void main(String[] args){
int a=10;
if(a>5){
return; //在此處結束當前函數
}
System.out.println("武漢加油");
//return;函數沒有返回值 所以return可以忽略不寫
}
其中，public:主函數是公開權限，它的的權限是訪問權限裏面最大的。
static:主函數是靜態函數；
void：該函數沒有返回值，它雖然沒有返回值，但是它裏面還是有return這個字符的，只不過不會寫出來；
String[]: 表示的是一個字符串數組，切記S大寫！！
args:就是這個數據類型的變量名稱
注意：當咋們在執行程序的時候，可以給主函數傳遞一些參數；發現沒有return時，並不代表函數值不存在，而是因爲函數沒有返回值；return本身表示結束當前函數；如果，函數有返回值是必須要寫return；
目前爲止，定義函數的時候，只需要考慮
返回值類型 函數名 參數列表 函數體 返回值
切記：千萬不要在函數的內部創建函數 函數必須在類裏面 函數們之間是平級關係
在C/C++/Python當中 函數的定義必須在函數調用之前
在Java當中 隨便 之前 之後
咋們舉一個函數的例子，題是這樣的
4.1（求一個整數各位數字之和） 編寫一個方法，計算一個整數各位數字之和 ，使用下面的方法
步驟：1.先輸入一個整數
2.然後進行函數調用
3.在調用的裏面寫關於這個題的算法，關於這個題的算法，咋們之前已經敘述過了，所以，就不在贅述了；
import java.util.*;
class Test2{
public static void main(String[] args){
Scanner in=new Scanner(System.in);
System.out.println("請輸入一個整數：");
int sum=in.nextInt();
System.out.println(sumDigits(sum));
}
public static int sumDigits(int sum){
int num=0;
while(true){{
num=num+sum%10;
sum/=10;
}
if(sum%10==0){
break;
}}return num;
}
}
二、函數的分類
函數可以分爲是否有返回值兩類
1.有返回值：有參數，無參數
2.無返回值：有參數，無參數
注意：有返回值的參數，參與運算，賦值，輸出；無返回值得參數，僅僅是調用
我們來舉一個實例
class Test3{
public static void main(String[] args){
show();//這裏就只是調用了
// 以下都是錯誤的對無返回值函數的操作
// System.out.println(show());不能輸出
// int d=show();不能賦值
// int e=show()+10;不能計算
}
public static void show(){
System.out.println("武漢加油");
}
}
三、函數傳參
實際參數（實參）：就是在調用函數的時候，給函數傳遞的數據（常量，變量）
形式參數（形參）：就是下定義函數的時候，參數列表當中的數據。
實參將什麼東西傳給了形參 ：目前爲止傳的是常量在常量池的地址。之後有對象在堆內存中地址。
局部變量：但凡是在函數中創建的變量，局部變量的作用域僅僅在當前的函數當中。形式參數一定是局部變量
class Test01{
public static void main(String[] args){
int a=4;
int b=4;
double c=pow(a,b); //a b 都是實參
System.out.println(c);
}
//計算a的冪次方
public static double pow(double a,int b){ //這裏的a b是 型形參
if(b==0){
return 1;
}
double sum=1;
//2^4
for(int i=1;i<=Math.abs(b);i++){
sum*=a;
}
return b>0?sum:1/sum;
}
}
函數參數傳遞：首先是將4的地址0x444給a b ；然後纔是將a b 的地址0x444傳遞給pow中的a b ；當pow運行結束 將結果的地址0x256返回回來給c ，然後將c輸出。
四、函數棧
函數運行時是基於棧內存運行的。棧是一種先進後出的容器結構。
我們可以將每個函數理解爲函數幀，位於棧頂的函數優先運行。由於主函數是第一個進棧，所以主函數後運行。
函數中的return相當於彈棧。
舉個例子，進棧是1.2.3.4.5，出棧的順序就是5.4.3.2.1
畫圖舉個例子，後是一起消失的，只不過沒弄到，抱歉了
五、函數的重載
函數的重載指的就是同一個類中出現的同名函數。
是否是函數的重載與權限沒關係，與返回值類型沒關係，與參數名沒關係；只有和參數類型的排列組合有關係(注意一下參數類型的向下兼容問題)。
重載的好處就在於我們可以擴展函數的功能(函數重名，但是參數類型不一樣，執行內容也可以不一樣)。
尋找適當函數的流程
1.看是否有確切的參數定義 int+int 查看是否有(int,int)
2.看是否有可兼容的參數定義 int+int 查看是否有(double,double)
3.如果可兼容的參數定義有多個int+int,(double,int)或(int,double) 此時報錯 引用不明確
class Test4{
public static void main(String[] args){
int a=3;
int b=4;
System.out.println(add(a,b));
double d=3.14;
double e=5.44;
System.out.println(add(d,e));
System.out.println(add(3,3.14));
System.out.println(add(3.13,9));
}
//對兩個小數進行加法運算
// public static double add(double c,double d){
// return c+d;
// }
public static String add(String a,String b){
System.out.println("String+String");
return a+b;
}
// public static double add(int a,double b){
// System.out.println("int+double");
// return a+b;
// }
// public static double add(double a,int b){
// System.out.println("double+int");
// return a+b;
// }
public static double add(double a,double b){
System.out.println("double+double");
return a+b;
}
//對兩個整數進行加法運算
// public static int add(int a,int b){
// System.out.println("int+int");
// return a+b;
// }
}
六、函數的遞歸，調用
在行業中有一句話，人用迭代，神用遞歸，可以看出，遞歸的好
遞歸的體現就是函數調用自身函數；
遞歸遞歸，就是先遞，後歸
- 前進段 指的就是講問題從大化小
- 結束段 當問題無法再繼續化小，則處理當前的問題
- 返回段 將小問題處理完畢之後，向上返回（有些問題是不需要返回的）
來來來，又是我們的舉例子時間
class Test02{
public static void main(String[] args){
how();
}
public static void how(){
System.out.println("how....");
how();
}
}
遞歸他主要解決的問題是：
一般而言，但凡能夠被迭代（循環）解決的問題，遞歸都可以解決。但是遞歸能解決的問題，迭代就不一定能解決。
遞歸其實是分治法的一種實現方式（一種實現思路）而分治法是一種算法思想，分治法主要解決的問題是將大問題，進行拆分，拆分成若干個小的問題進行求解，最終將每個小問題的解進行合併。其實，分治法就是一種暴力破解法（窮舉），也是一種搜索最優答案的算法。
示例：對於一個文件夾的遍歷，文件夾中有子文件夾和文本，他碰到文本就直接打印文本，碰到子文件夾就是打開子文件夾，繼續看裏面，要是有文本繼續打印，碰到子文件夾繼續打印
關於遞歸的示例：1+2+3+4+…+100
//計算1+2+3+4+5+...+98+99+100
/*
f(n) 是求1~n的累加
f(100)就是我們當前最大的問題
寫遞歸時，一定要先寫它的end!
↓ 遞
f(n)=f(n-1)+n
f(100)=f(99)+100 return 1+2+3+..+99 +100
f(99)=f(98)+99 return 1+2+...+98 +99
...
f(4)=f(3)+4 return 1+2+3+4
f(3)=f(2)+3 return 1+2+3
f(2)=f(1)+2 return 1+2
f(1)=1 return 1
→ end ↑ 歸
*/
class Test02{
public static void main(String[] args){
System.out.println(f(10));
}
public static int f(int n){
if(n==1){
return 1;
}
return f(n-1)+n;
}
}
就算是神用的遞歸，他也不可能是沒有缺點的，不可能十全十美，接下來我們說一說遞歸的優缺點：
遞歸就是函數在進棧，進棧的次數多了，勢必會佔內存，無法避免的。
在某些問題上，遞歸所寫的代碼要比迭代寫的代碼少。
在某些問題上，迭代是寫不出來的，所以只能用遞歸。
七、常用的函數
math類
Math.E 計算e的值
Math.PI 計算Π的值
Math.abs(a) 計算a的絕對值
(4)Math.ceil(a) 計算大於a的最小整數
Math.floor(a) 計算小於a的最大整數
Math.hypot(x,y) 求兩點之間的距離
Math.max(a,b) 求a b 最大值
Math.min(a,b) 求 a b 最小值
Math.pow(a,b) 求a的b次方
Math.sqrt(a) 求a的平方跟
Math.random() 取隨機數
Math.rint(a) 對a四捨五入
Math.round(a) 對a取整
代碼示例：
class Test01{
public static void main(String[] args){
//求e
System.out.println(Math.E);
System.out.println(Math.PI);
//大於指定數字的最小整數
System.out.println(Math.ceil(-2.1));
//小於指定數字的最大整數
System.out.println(Math.floor(2.3));
//求兩數最小數
System.out.println(Math.min(2.3));
//求兩數最大數
System.out.println(Math.max(2.3));
//求兩點之間的距離 x=deltX y=deltY
System.out.println(Math.hypot(3,4));
//四捨五入
System.out.println(Math.rint(3.5));
//求平方根
System.out.println(Math.sqrt(35));
//求冪次方
System.out.println(Math.pow(3,5));
}
}
String類
String不是基本數據類型而是一個類，既然是類那麼肯定有其相關的函數
查詢相關：
char charAt(int index) 獲取指定角標處的字符
int indexOf(int ch) 返回在此字符串中第一次出現指定字符處的索引，從指定的索引開始搜索
int lastIndexOf(int ch) 返回指定字符在此字符串中最後一次出現處的索引，從指定的索引處開始進行反向搜索
int length() 字符串長度
substring(int beginIndex, int endIndex) 返回一個新字符串，它是此字符串的一個子字符串。該子字符串從指定的 beginIndex 處開始，直到索引 endIndex - 1 處的字符
判斷相關：boolean contains(String s) 判斷指定子串是否包含在s中
boolean endsWith(String s) 判斷指定子串是否在s的結尾
boolean startsWith(String prefix) 測試此字符串是否以指定的前綴開始。
int compareTo(String anotherString) 按照字典順序比較兩個字符串的大小
boolean equals(String anotherString) 比較兩個字符串是否相等(比的是內容)
boolean equalsIgnoreCase(String anotherString) 比較兩個字符串是否相等(比的是內容) IgnoreCase忽略大小寫
boolean isEmpty() 如果 lengh()爲 0，則返回 true；否則返回 false。
修改相關：String replace(char oldChar, char newChar) 回一個新的字符串，它是通過用 newChar 替換此字符串中出現的所有 oldChar 得到的
String toUpperCase() 將所有字符都轉換爲大寫
String toLowerCase() 將所有字符都轉換爲小寫
String trim() 去除兩邊空格
注意：對字符串的修改永遠都不是對其自身進行的修改 字符串本身是不可變的！！！對字符串的修改往往都是新建個字符串將修改後內容賦值並返回新的字符串
class Test02{
public static void main(String[] args){
String s="abcd";
/*
"abcd"
0123
*/
//獲取指定角標處的字符
System.out.println(s.charAt(0));
//判斷指定子串是否包含在s中
System.out.println(s.contains("ab"));
//判斷指定子串是否在s的結尾
System.out.println(s.endsWith("cd"));
//按照字典順序比較兩個字符串的大小
//返回值有負數 0 正數
//負數 前者在後者ASCII之前
//0 前者和後者相等
//正數 前者在後者ASCII之後
System.out.println("abc".compareTo("abd"));
/*
abc
abd c-d=-1
*/
System.out.println("abc".compareTo("abc"));
//比較兩個字符串是否相等(比的是內容)
System.out.println("abc".equals("abc"));
//IgnoreCase忽略大小寫
System.out.println("ABC".equalsIgnoreCase("abc"));
//在字符串中從左到右查找指定元素第一次出現的位置
System.out.println("abcccccd".indexOf('c'));
System.out.println("abcccccd".indexOf("cd"));
//如果 length() 爲 0，則返回 true；否則返回 false。
System.out.println("".isEmpty());
s="abababab";
//用'c' 替換此字符串中出現的所有 'a'
System.out.println(s.replace('a','c'));
//從指定的 0 處開始，直到索引 3處的 形成新的字符
System.out.println(s.substring(0,3));//[0,3)
//將所有字符都轉換爲大寫
System.out.println(s.toUpperCase());
//去除兩邊空格
System.out.println(" abc abc abc ".trim());
}
}
八、實戰演練
步驟 ：1.先輸入一個整數
2.先進入isPalindrome函數，將輸入的整數，按照公式輸出
3.進入Reverse函數，與先出輸入的整數進行比較
/*
步驟：
1.提示輸入數字
2.判斷該數字是否是一個迴文
*/
import java.util.Scanner;
class Demo04_02{
public static void main(String[] args){
//1.提示用戶輸入一個數字
Scanner scanner=new Scanner(System.in);
System.out.print("請輸入一個數字:");
int num=scanner.nextInt();
//2.判斷該數字是否是一個迴文
if(isPalindrome(num)){ // pause1
System.out.println("是迴文");
}else{
System.out.println("不是迴文");
}
//return ;
}
public static boolean isPalindrome(int num){
//1.先計算該數字的反序
//2.對比反序的數字和數字本身
//pasue 2
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;
}
}
}
}
思路：1.發現圖形，隨着行數的增加，它前面的空格會用來越少，所以，它的一個約束條件就是<=line-i
import java.util.Scanner;
class Demo04_03{
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
1 提示輸入行數
System.out.print("請輸入行數：");
displayPattern(scanner.nextInt());
}
public static void displayPattern(int line){
for(int i=1;i<=line;i++){ //行數
for(int k=1;k<=line-i;k++){ //空格數
if(line<10){
System.out.print(" ");
}else{
System.out.print(" ");
}
}
for(int j=i;j>=1;j--){ //每一行的列
if(line<10){
System.out.printf("%-2d",j);//格式化輸出
}else{
System.out.printf("%-3d",j);//格式化輸出
}
}
System.out.println();
}
}
}
4.4檢測密碼
1.密碼必須至少8位字符
2.密碼僅能包含字母和數字
3.密碼必須包含至少兩個數字
步驟：1.先提示用戶輸入密碼
2.將密碼傳入
3.進行判斷，首先，題目的第二個規則是包含字母和數字，不是同時包含，他的額外含義就是不能包含除字母和數字之外的其他
import java.util.Scanner;
class Demo04_04{
public static void main(String[] args){
//1.先提示用戶輸入密碼(String password)
Scanner scanner=new Scanner(System.in);
System.out.print("請輸入密碼:");
String password=scanner.nextLine();
//2.將密碼傳入 boolean isValid(password)
if(isValid(password)){
System.out.println("密碼合法!");
}else{
System.out.println("密碼不合法!");
}
}
//3.isValid()
//3.1 長度 isLengthValid()
//3.2 組成 isContentValid()
//3.2.1 isLetter(c) 判斷該字符是否爲字母字符
//3.2.2 isDigit(c) 判斷該字符是否爲數字字符
//3.3 特殊至少倆數字 isNumberValid() isDigit(c)
public static boolean isValid(String s){
return isLengthValid(s)&&isContentValid(s)&&isNumberValid(s);
}
public static boolean isLengthValid(String s){
return s.length()>=8;
}
public static boolean isContentValid(String s){
char 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){
int count=0;
char c=' ';
for(int i=0;i<s.length();i++){
c=s.charAt(i);
if(isDigit(c)){
count++;
}
}
return count>=2;
}
// a~z A~Z 只需要比較ASCII值
// 'a'<=c<='z' || 'A'<=c<='Z'
// '0'<=c<='9'
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';
}
}
步驟：
1.計算9的平方根近似值
2.套公式計算nextGuess
class Demo04_05{
public static void main(String[] args){
//1.計算9的平方根近似值
System.out.println(sqrt(9));
}
//2.套公式計算nextGuess
public static double sqrt(long n){
double lastGuess=1;
double nextGuess=(lastGuess+n/lastGuess)/2;
while(true){
if(Math.abs(nextGuess-lastGuess)<0.00001){
return nextGuess;
}
lastGuess=nextGuess;
nextGuess=(lastGuess+n/lastGuess)/2;
}
}
}
步驟：1.在主函數中判斷是否是迴文素數
2.在Reverse函數中對數字進行倒序待續
3.在isHuiWen函數中判斷是否是迴文
4.在isSuShu函數中判斷是否是素數
class Demo04_06{
public static void main(String[] args){
int count=0; //表示迴文素數的個數
int num=2; //表示可能的迴文素數的數字 從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.Reverse反轉數
3.返回是否是迴文isHuiWen
4.返回是否是素數isSuShu
5.返回反轉素數isFanZhuanSuShu
class Demo04_07{
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++;
}
}
//1.本身是素數
//2.反轉之後也是素數
//3.不能是迴文
//素數() 反轉() 迴文功能()
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;
}
}
}
}
4.8（指定字符的出現次數）適用下面的方法，編寫一個方法，找到一個字符串中指定字符的出現次數
咋們需要用到charAt進行轉換
class Demo04_08{
public static void main(String[] args){
String s="abcasjdjhsadadbhasdvasbd";
System.out.println(count(s,'a'));
}
public static int count(String s,char c){
int count=0;
for(int i=0;i<s.length();i++){
if(s.charAt(i)==c){
count++;
}
}
return count;
}
}
4.9倒排一個字符串，編寫一個程序，提示用戶輸入一個字符串，然後一反序顯示該字符串
步驟：1.輸入一串字符
2.用到For循環，咋們可以根據字符串的長度-1進行逆序輸出
class Demo04_09{
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;
}
}
4.10編寫一個程序，提示用戶輸入一個字符串，然後顯示該字符串中大寫字母的數目
還是需要charAt這個進行轉換
class Demo04_10{
public static void main(String[] args){
String s="Welcome To China";
System.out.println(getUpperCase(s));
}
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';
}
}
4.11編寫一個程序，提示用戶輸入兩個字符串，顯示兩個字符串最長的共同前綴
class Demo04_11{
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()){
minStr=s1;
maxStr=s2;
}else{
minStr=s2;
maxStr=s1;
}
for(int i=0;i<minStr.length();i++){
if(minStr.charAt(i)!=maxStr.charAt(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)){
return s1.substring(0,pa);
}
if(s1.charAt(pa)==s2.charAt(pb)){
pa++;
pb++;
}
if(pa==s1.length()){
return s1;
}
if(pb==s2.length()){
return s2;
}
}
}
}
4.12十六進制轉換十進制
一共兩種方法，一種是直接使用函數，第二個是進行轉換
class Demo04_12{
public static void main(String[] args){
String s="AB8C";
//A B 8 C
//0 1 2 3
//3 2 1 0
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);
/*
A=10 B=11 C=12 D=13 E=14 F=15
i=0 C C*16^0
i=1 8 8*16^1
i=2 B B*16^2
i=3 A A*16^3
*/
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';
}
}
嘿嘿嘿，看到這個狗狗就代表本篇已完成。