第四章：函数_public static定义的函数-CSDN博客

本文链接：https://blog.csdn.net/messi____/article/details/104260115

函数的定义：

1.函数的存在意义

函数是主要解决重复的且具有独立功能的代码段，将这些具有独立功能的代码可以进行再次封装，封装出来的东西称为函数。降低了代码冗余复用函数，降低了主函数的代码量，将主函数进行适当的拆分，以便内存的优化。就是将函数模块化。

2.函数格式

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

函数体

return 返回值；

}

访问权限：指的就是函数的使用范围（ public protected 默认不写 private）

函数类型：指的就是函数类型分类，就是函数的具体使用场景和场合（static静态函数默认不写成员函数 abstract 抽象函数 native 本地函数 synchronized 同步函数）

函数名：就是这一段代码自定义的名称（标识符）

参数列表：参数列表有若干个参数类型，参数名…组成，主要用于接收外界传递给函数的一些数据。

函数体：就是那些具有独立功能的代码块。

return：仅仅表示结束当前函数，如果有返回值，则函数结束前将返回值返回给调用者。

返回值：指的就是这一具有独立功能的代码块的结算结果，需要传递给外界，配合return使用。

返回值类型：返回值的数据类型（可兼容性）。

目前为止，定义函数时，只需要考虑（返回值类型函数名参数列表函数体返回值）

注意事项：不要在函数的内部创建函数，函数必须在类里面，函数们是平级关系，在C/C++/Python中，函数的定义必须在函数调用之前。在Java中，之前之后都可以。

3.函数传参

实际参数-实参：在调用函数的时候，给函数传递的数据。（常量或者变量）

形式参数-形参：定义函数的时候，参数列表中的数据。

实参是将什么东西传递给了形参：目前为止，传的是常量在常量池的地址。在面向对象中，传的也有对象在堆内存的地址。

局部变量：但凡是在函数中创建的变量，称之为局部变量。局部变量的作用域仅仅在当前的函数当中。形式参数一定是局部变量。

4.函数栈

函数的运行是基于栈内存的，栈是一个先进后出的容器结构。（如弹夹，先压进去的子弹最后打出）可以将每一个函数理解为子弹（函数帧），位于栈顶的函数帧优先运行的主函数绝对是第一个进栈的。

return结束当前函数 -> 当前函数弹栈。

函数的重载

函数的重载指的就是同一个类中出现的同名函数.

函数的重载与权限没关系，与返回值类型没关系，与参数名没关系。只有和参数类型的排列组合有关系(注意一下参数类型的向下兼容问题)。重载的好处就在于我们可以扩展函数的功能(函数重名，但是参数类型不一样，执行内容也可以不一样)。

寻找适当函数的流程
1.看是否有确切的参数定义 int+int 查看是否有(int,int)
2.看是否有可兼容的参数定义 int+int 查看是否有(double,double)
3.如果可兼容的参数定义有多个int+int,(double,int)或(int,double) 此时报错引用不明确。

函数的递归调用

递归的体现就是函数自身调用函数自身。

递归主要解决什么问题：

1.一般而言，但凡能够被迭代（循环）解决的问题，递归都可以。递归解决的问题，迭代就不一定了。

2.递归其实是分治法的一种实现方式（一种实现思路）。

3.递归就是函数在进栈，进栈的次数多了，势必会占内存，无法避免的。在某些问题上，递归所写的代码要比迭代写的代码少。
在某些问题上，迭代是写不出来的，所以只能用递归。

4.分治法是一种算法思想，分治法主要解决的问题是将大问题，进行拆分，拆分成若干个小的问题进行求解，最终将每个小问题的解进行合并。其实，分治法就是一种暴力破解法（穷举），也是一种搜索最优答案的算法。

递归就是先递，后归。一共分为三个阶段，第一阶段为前进段，指的就是讲问题从大化小。第二阶段为结束段，问题无法再继续化小，则处理当前的问题。第三阶段为返回段，将小问题处理完毕之后，向上返回（有些问题是不需要返回的）。

常用函数

Math类:Math.E计算e的值，Math.PI计算Π的值，Math.abs(a)a的绝对值，Math.ceil(a)向上取整计算，Math.floor(a)取比自己小的最大整数，Math.hypot(x,y)返回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()取得0到1之间的随机小数，Math.rint(a)返回最接近a的整数，Math.round(a)四舍五入取值。

String类：String不是基本数据类型而是一个类，既然是类那么肯定有其相关的函数。

查询相关：char charAt(int index)；int indexOf(int ch) ；int lastIndexOf(int ch) ；int length() ；substring(int beginIndex, int endIndex) 。

判断相关：boolean contains(String s)；boolean endsWith(String s)；boolean startsWith(String prefix) ；int compareTo(String anotherString)；boolean equals(String anotherString)；boolean equalsIgnoreCase(String anotherString) ；boolean isEmpty() 。

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

String replace(char oldChar, char newChar) ；String toUpperCase() ；String toLowerCase() ；String trim() 。

练习题

import java.util.*;
class test4_1{
    public static void main(String[] args) {   //1
        System.out.print("请输入一个整数：");   //2
        Scanner scnner=new Scanner(System.in); //3
        long n=scnner.nextLong();              //12
        System.out.println("输入整数的各位数之和为"+sumDigits(n)); //13
    }
    public static int sumDigits(long n){       //4
        int sum=0;                             //5
        while(n>0){                            //6
            int m=(int)(n%10);                 //7
            sum=sum+m;                         //8
            n=n/10;                            //9
            }                                  //10
        return sum;                            //11
        }
}

//回文数
import java.util.*;
class test4_2{
    public static int reverse(int number) {
        int sum=0;
        while(true){
            sum=sum*10+num%10;
            num/=10;
            if(num==0){
                return sum;
            }
        }
    }
    public static boolean isPalindrome(int number) {
       return reverse(num)==num;
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个整数: ");
        num = input.nextInt();
        int num=0;
        if(reverse(num)) {
            System.out.println("这是一个回文整数");
        }
        else {
            System.out.println("这不是一个回文整数");
        }
    }
}

import java.util.*;
 class test4_3{
    public static void displayPattern(int n) {
        int i = 0;//行数
        int k;
        for(;i <= n;i++) {
            for(k = 1;k < 2*(n+1-i);k++ ) {
                System.out.print(" ");
            }
            for(k = i;k > 0;k--) {
                System.out.print(k + " ");
            }
            System.out.print("\n");
        }
    }
    public static void main(String[] args) {
        System.out.print("请输入一个行数n：");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        displayPattern(n);
    }
}

//检测密码
import java.util.Scanner;
class test4_4{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入密码:");
        String pwd=scanner.nextLine();
        if(isValid(pwd)){
             System.out.print("合法");

        }else{
             System.out.print("不合法:");
        }
    }
    public static boolean isValid(String pwd){
        return isRight1(pwd)&&isRight2(pwd)&&isRight3(pwd);
    }
    public static boolean isRight1(String pwd){
        return pwd.length()>=8;   //密码至少8位字符
    }
    public static boolean isRight2(String pwd){
        for(int i=0;i<pwd.length();i++){
            char c=pwd.charAt(i);
            if(!isDigit(c)&&!isLetter(c)){
                 return false;
                }
            }
            return true;
    }
        public static boolean isDigit(char c){
            return c>='0'&&c<='9';
         
        }
        public static boolean isLetter(char c){
        
            return (c>='a'&&c<='z')||(c>='A'&&c<='Z');
                  
        }
    public static boolean isRight3(String pwd){
        int digitCount=0;
        for(int i=0;i<pwd.length();i++){
                char c=pwd.charAt(i);
                if(isDigit(c)){
                    digitCount++;
                   
                }  
        }   
        return digitCount>=2;    //至少包含两个数字
    }  
}

//平方根的近似求法
import java.util.*;
class test4_5{
	public static double sqrt(long n){
		double nextGuess=0.0;
		double lastGuess=1.0;
		while(true){
			nextGuess=(lastGuess+n/lastGuess)/2;  //公式
			if(Math.abs(nextGuess-lastGuess)<0.0001){
				break;
			}else{
				lastGuess=nextGuess;
			}
		}
		return nextGuess;
    }
    public static void main(String[] args) {
		System.out.print("请输入一个数字: ");
		System.out.println(sqrt(new Scanner(System.in).nextLong()));
	}
}

class test4_7{
    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;
            }
        }
    }
}

class test4_6{
    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;
    }
}

//计算字符出现的次数
import java.util.*;
class test4_8{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一串字符：");
        String str = scanner.nextLine();
        System.out.print("请输入要计算的字符：");
        String strLetter = scanner.nextLine();
        char ch = strLetter.charAt(0);
        System.out.print(ch + "在" + str + "中出现的次数为：" + count(str, ch) + "次");
}
 
    public static int count(String str, char ch) {
        int num = 0;
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) == ch) {
                num++;
            }
        }
        return num;
    }
}

//倒序输出字符串
import java.util.*;
class test4_9{
    public static String reverse(String strStr) {
        if(strStr == null || strStr.length() <= 1) 
        return strStr;
        String substring = strStr.substring(1);
        char charAt = strStr.charAt(0);
        return reverse(substring) + charAt;
    }
    public static void main(String[] args) throws Exception{
        for (int i = 0; i < 1; i++) {
            String string = reverse("ABCD");
            System.out.println(string);    //DCBA
        }
    }
}

//统计大写字母的个数
import java.util.Scanner;
class test4_10{
	public static void main(String[] args) {
        System.out.print("请输入一段字符串: ");
		Scanner scanner=new Scanner(System.in); 
		String str=scanner.nextLine();//原字符串
		char[] chs = str.toCharArray() ;//将字符串转换为字符数组
		int Count=0;
		String str2=str.toUpperCase();//大写字符串
		char[] arr2 = str2.toCharArray() ;
		for(int i=0;i<str2.length();i++) {
			if(arr2[i]==chs[i]&& arr2[i]<97+27&& arr2[i]>64) {
				Count++;
			}	 
		 }
		 System.out.println("大写字母字符有"+Count);	 
	}
}

class test4_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){
        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;
            }
        }
    }
}

class test4_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);
            /*
            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';
    }
}