第四章 ： 函数

函数

函数存在的意义：函数主要是解决那些重复且具有独立功能的代码段，就是将函数模块化。

将这些具有独立功能的代码可以进行再次封装。封装出来的东西就称之为函数，它具有很明显的优势，降低了代码冗余复用函数，降低了主函数的代码量，将主函数进行适当的拆分，以便内存优化。

public class HHH {

	public static void main(String[] args) {
		sum (1,10);
		sum (15,20);
		sum (25,35);

	}
	public static void sum (int begin,int end) {
		int sum = 0;
		for (int i = begin;i <= end;i++) {
			sum += i;
		}
		System.out.println(begin + "到" + end +"之间的和为 ： " + sum);
	}

}

1.函数格式

函数格式:
访问权限 函数类型 返回值类型 函数名(参数列表){

public       static        void            main
      函数体
      return 返回值;
}

访问权限：指的就是函数的使用范围（内部和外部）

public（公共的）、protected（受保护的）、默认不写、private（私有的）。

函数类型：指的就是函数类型分类。说的就是函数的具体使用场景和场合。

static （静态函数） 、默认不写（成员函数）、abstract（抽象函数）、native（本地函数）、synchronized（同步函数）。

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

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

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

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

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

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

2、函数的分类

有返回值有参数、无返回值有参数、有返回值无参数、无返回值无参数。

注意*：有返回值的函数参与赋值、运算、输出。无返回值的函数仅仅调用。

3、函数传参

实际参数（实参）：就是在调用函数的时候，给函数传递的数据（常量、变量）称之为实参。

形式参数（形参）：就是定义函数的时候，参数列表当中的数据，称之为形参。

实参将常量在常量池中的地址、对象在堆内存中的地址传递给了形参。

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

4、函数栈

函数的运行是基于栈内存的。

栈是一个先进后出的容器结构（子弹按123456顺序进栈，按654321顺序出栈）。可以将每一个函数理解为子弹（函数帧/栈帧），位于栈顶的主函数优先运行。主函数绝对是第一个进栈的。return结束当前函数->当前函数弹栈。

其表示图为：

5、函数的重载

函数的重载指的就是在同一个类中出现的重名函数。与权限、返回值类型、参数名均没有关系。只有和参数类型的排列组合有关系。

重载的好处就在于我们可以扩展函数的功能（函数重名，但是参数类型不一样，执行的内容也可以不一样）。

寻找适当函数的流程：①看是否有确切的参数定义int + int 查看是否有（int，int）

②看是否有可兼容的参数定义int + int 查看是否有（double，double）

③如果可兼容参数的定义有多个int + int（double，int）或（int，double）此时报错，引用不明确。

public class HHH {

	public static void main(String[] args) {
		System.out.println(add(3,4.5));
	}
	public static double add (double a,double b){
		System.out.println("double + double");
		return a+b;
	}
	
}

我们可以看出int double可以直接转double double。

public class int兼容 {

	public static void main(String[] args) {
		System.out.println(add(3,4));
	}
	public static double add (int a,double b){
		System.out.println("int + double");
		return a+b;
	}
	
}

int int 也可以转换成int double。

public class int兼容 {

	public static void main(String[] args) {
		System.out.println(add(3,4));
	}
	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;
	}
	
}

但不能同时int double 与double int 使用，这样就会报错，出现了兼容类型。

6、函数的递归调用

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

递归解决的问题有：

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

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

③递归就是函数在进栈，进栈的次数多了势必会占内存，这是无法避免的。

④在某些问题上，递归所写的代码要比迭代少；而有些问题上迭代是写不出来的，所以只能用递归。

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

⑥递归：先递后归

Ⅰ前进段：指的就是将问题从大化小。

Ⅱ结束段：问题无法继续化小，则处理当前的问题。

Ⅲ返回段：将小问题处理完毕后，向上返回（有些问题是不需要返回的）。

斐波那契数列

求前20项和   1 1 2 3 5 8 13 21 34 55 ......

用递归可以写如下代码：

public class HHH {

	public static void main(String[] args) {
		for (int i = 1;i <= 20;i++) {
			System.out.println(feibo(i));	
		}
	}
	public static int feibo (int n) {
		if (n == 2 || n == 1) {
			return 1;
		}
		return feibo(n - 2) + feibo(n - 1);
	}

}

我们可以发现 第一项与第二项结果都是1，因此我们用一个return1就可以了。

递归的基本框架如下：

斐波那契数列的迭代方法：

public class HHH {

	public static void main(String[] args) {
		diedai(20);
	}
	public static void diedai (int n) {
		int a = 1;
		int b = 1;
		System.out.println(a);
		System.out.println(b);
		int c;
		for (int count = 2;count <= n;count++) {
			c = a + b;
			System.out.println(c);
			a = b;
			b = c;
			
		}
		
	}	
}

7、常用函数

7.1 Math类

Math.E (e的值)    Math.PI（Π的值）   Math.abs(a) (求绝对值)

                System.out.println(Math.E);//e的值
		System.out.println(Math.PI);//Π的值
		System.out.println(Math.abs(-2));//求绝对值

Math.ceil(a)   (向上取整)

Math.floor(a)   (向下取整)

Math.hypot(x,y)   (两点之间的距离)

                System.out.println(Math.ceil(1.8));//输出2
		System.out.println(Math.ceil(-1.8));//输出-1.0
		System.out.println(Math.floor(1.8));//输出1.0
		System.out.println(Math.hypot(3,4));//输出5.0
		

Math.max(a,b)  (最大值)

Math.min (a,b)  (最小值)

Math.pow(a,b)  (a的b次幂)

		System.out.println(Math.max(1,8));//输出8
		System.out.println(Math.min(1,8));//输出1
		System.out.println(Math.pow(2,3));//输出2的3次方 8.0

Math.sqrt(a)  (对a开方)

Math.random (取一个随机数[0,1))

Math.rint(a)  (四舍五入（小数）)

Math.round(a)  （四舍五入（整数））

                System.out.println(Math.sqrt(4));//输出2.0
		System.out.println(Math.random());//输出随机输出一个[0,1)的值
		System.out.println(Math.rint(1.5));//输出2.0
		System.out.println(Math.round(1.2));//输出1

7.2 String 类

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

7.2.1 查询相关

char   charAt (int index)   (获取指定角标处的字符   ，如String s = "abcd"    charAt（0）   那么输出的就是a   因为他是从0，1，2，3来对abcd赋值的。)

int    indexOf(int ch)   （在字符串中从左到右查找指定元素第一次出现的位置   ）

int lastIndexOf (int ch)  （在字符串中从左到右查找指定元素最后一次出现的位置   ）

int length()（长度）

substring (int beginIndex,int endIndex)   （截取前三个值）

                 String s="abcd";
	        /*
	        "abcd"
	         0123
	        */
	        //获取指定角标处的字符
	        System.out.println(s.charAt(0));//a

                //在字符串中从左到右查找指定元素第一次出现的位置   
	        System.out.println("abcccccd".indexOf('c'));//2
	        System.out.println("abcccccd".indexOf("cd"));//6

                //截取前三个值
		String s = "ababababaaa";
		System.out.println(s.substring(0,3));//[0,3)aba

7.2.2 判断相关

boolean contains(String s)   （判断指定子串是否包含在s中）

boolean endsWith(String s)   （ 判断指定子串是否在s的结尾）

boolean startsWith(String prefix)  （ 判断指定子串是否在s的开头） 

int compareTo(String anotherString) 

     （正数 前者在后者ASCII之后
        System.out.println("abc".compareTo("abd"));）

boolean equals(String anotherString)   

         比较两个字符串是否相等(比的是内容)
        System.out.println("abc".equals("abc"));

boolean equalsIgnoreCase(String anotherString)  

        IgnoreCase忽略大小写
        System.out.println("ABC".equalsIgnoreCase("abc"));

boolean isEmpty()  （判断是否是空串）

7.2.3 修改相关

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

String replace(char oldChar, char newChar)  

         s="abababab";
        System.out.println(s.replace('a','c'));

         就会将a转换成c，但s这个数字本身是不会发生变化的

String toUpperCase()     （将字母转大写）

String toLowerCase()      （将字母转小写）

String trim()      

       System.out.println("  abc abc abc   ".trim());

      输出的时候就会自动去掉前面的空格

s1 = 1231212316123123

s2 = 12

判断字符串s2在s1中出现了多少次？

其代码表示为：

public class HHH {

	public static void main(String[] args) {
		questions1 ();
	}
	public static void questions1() {
		int count = 0;
		String s1 = "1231212316123123";
		String s2 = "12";
		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 + "次");
		 
	}

}

定义i = 0 是因为字符串是从0开始计数的，然后让i小于这些值是因为它截取的时候不能走到终点，但会走到s2字符串的第一位。然后我们截取s1字符串，从0开始依次截取s2字符串，最后判断其是否相等即可。

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

public class question2 {

	public static void main(String[] args) {
	String s = "上海自来水来自海上";
	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("这个是否是回文？" + flag);
	}

}

它是将这个字符串第一个和最后一个依次向中间比较，直到左边的数字大于或者等于右边的了，就可以判断是否是回文

 问题3：模拟trim的功能，自定义实现     s="  安利给~   "

public class question3 {

	public static void main(String[] args) {
		String s = "     ashaj    ";
		int left = 0;
		int right = s.length() - 1;
		while (s.charAt(left) == ' ') {//左边向右走
			left++;
		}
		while (s.charAt(right) == ' ') {//右边向左走
			right--;
		}
		String res = s.substring(left,right+1);//走完所有的空格（rhght+1是右边取不到）
		System.out.println("[" + res + "]");
	}

}

问题4：求s1和s2中最大的相同子串(s1.length()>s2.length())
        s1="Python is a program language but is slow";
        s2="Java is a program language but is fast"
        " is a program language but is "

public class questions4 {

	public static void main(String[] args) {
		 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 length = s2.length();length >= 1;length--) {//遍历
	    	
	    	for (int i = 0,j = length - 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;
	    	}
	    }
	}

}

i = 0因为每次截取一段字符串时都是从0开始的
j = length - 1是截取的最后一位

j < s2.length() j也只能达到s2的长度即可
             

 

练习题

其代码表示如下：

import java.util.Scanner;

public class Day41 {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("请输入一个数字: ");
		int num = in.nextInt();
		int sum = sumDigits(num);
		System.out.println(sum);
	}
	public static int sumDigits (int n) {
		int sum = 0;
		while (n != 0) {
			sum = sum + n % 10;
			n = n / 10;
		}
		return sum;
	}

}

import java.util.Scanner;

public class Day42 {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("请输入一个数字 ： ");
		int num = in.nextInt();
		if (huiwen(num) ) {
			System.out.print("是回文");
		}else {
			System.out.print("不是回文");
		}
	}
	public static boolean huiwen (int num) {
		return reverse (num) == num;
	}
	public static int reverse (int num) {
		int sum = 0;
		while (num != 0) {
			sum = sum * 10 + num % 10;
			num /= 10;
		}
		return sum;
	}

}

import java.util.Scanner;

public class Day43 {

	public static void main(String[] args) {
		Scanner in  = new Scanner(System.in);
		System.out.print("请输入一个数字：");
		int line = in.nextInt();
		display (line);
	}
	public static void display (int line) {
		for (int i = 1;i <= line;i++) {
			for (int k=1;k<=line-i;k++ ) {
				System.out.print("  ");
			}
			for (int j=i;j>=1;j--) {
				System.out.print(j + " ");
			}
			System.out.println();
		}
	}

}

public class Day45 {

	public static void main(String[] args) {
		System.out.print(sqrt(16));

	}
	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;
		}
	}

}

其代码表示为：

public class Day46 {

	public static void main(String[] args) {
		int count = 0;
		int num = 2;
		while (true) {
			if (huisu(num)) {
				count ++;
				System.out.print(num + " ");
			}
			if (count % 10 == 0) {
				System.out.println();
			}
			if (count == 100) {
				break;
			}
			num ++;
		}
		
	}
	public static boolean huisu(int num) {
		return hui(num) && su (num);
	}
	public static boolean hui(int num){
        return reverse(num)==num;
    }
    public static int reverse(int num){
        int sum=0;
        while(num != 0){
            sum=sum*10+num%10;
            num/=10;
            
		}
        return sum;
	}
	public static boolean su (int num) {
		for (int i = 2;i < num;i++) {
			if (num % i == 0) {
				return false;
			}
		}
		return true;
	}

}

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

汉诺塔：递归

/*
 前两个 x->y
 	前一个 x->z
 	前两个 x->y
 	前一个z->y
 第三个x->z
 前两个y->z
 	前一个y->x
 	前二个y->z
 	前一个x->z
 
 */
public class Hannuo {
	public static void main (String[] args) {
		hannuo (3,"X","Y","Z"); 
	}
public static void hannuo (int n,String begin,String mid,String end) {
	if (n == 1) {
		System.out.println(begin + " -> " + end);
	}else {
		hannuo (n - 1,begin ,end ,mid);
			System.out.println(begin + " -> " +end);
			hannuo (n-1,mid,begin,end);
		
	}
}	
}

其代码表示如下：

import java.util.Scanner;

public class Day44 {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		//1.提示用户输入密码   （answer为密码）
		System.out.print("请输入您的密码");
		String answer = in.nextLine();
		//2.用户看到的结果  判断密码是否通过
		if (success(answer)) {
			System.out.println("验证通过");
		}else {
			System.out.println("验证失败");
		}
	}
	//3.密码组合起来是否成功
	public static boolean success (String s) {
		return zifu(s) && letternum (s) && num (s);
	}
	//4.至少八字符
	public static boolean zifu (String s) {
		return s.length() >= 8;
	}
	//5.仅字母和数字
	public static boolean letternum (String s) {
		char c = ' ';
		//对字符进行遍历
		for (int i = 0;i < s.length();i++) {
			c = s.charAt(i);//将查找出来的字符赋值给c
			if (!number(c) && !letter(c)) {
				return false;
			}
		}
		return true;
	}
	//6.至少两个数字
	public static boolean num (String s) {
		char c = ' ';
		int count = 0;
		for (int i = 0;i < s.length();i++) {
			c = s.charAt(i);
			if (number(c)) {
				count++;
			}
		}
		return count >= 2;
	}
	//7.是否是字母
	//'a'<= c <= z ||'A' <= c <='Z'
	public static boolean letter(char c) {
		return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z'; 
	}
	//8.是否是数字
	//'0'<= c <= '9'
	public static boolean number (char c) {
		return c >= '0' && c <= '9';
	}

}

其代码为：

public class Day48 {

	public static void main(String[] args) {
		String s = "abaaggkgkga";
		System.out.print(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;
	    }
	}

import java.util.Scanner;

public class Day49 {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("请输入一个字符串");
		String s = in.nextLine();
		System.out.print(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;
	}

}

import java.util.Scanner;

public class Day410 {

	public static void main(String[] args) {
		Scanner in = new Scanner(System .in);
		System.out.print("请输入一个字符串");
		String s = in.nextLine();
		System.out.print(upper(s));
	}
	public static int upper (String s) {
		int count = 0;
		for (int i = 0;i < s.length();i++) {
			if (s.charAt(i) >= 'A' && s.charAt(i) <= 'Z') {
				count++;
			}
		}
		return count;
	}
	

}

4.11

import java.util.Scanner;

public class Day411 {

	public static void main(String[] args) {
		//提示用户输入两个字符串
		Scanner in = new Scanner(System.in);
		System.out.print("Enter the first string :");
		String s1 = in.nextLine();
		System.out.print("Enter the secong string :");
		String s2 = in.nextLine();
		System.out.println(com(s1,s2));

	}
	public static String com (String s1,String s2) {
		//将长的字符串赋值给maxstring 短的赋值给minstring
		String maxString = "";
		String minString = "";
		if (s1.length() <= s2.length()) {
			minString = s1;
			maxString = s2;
		}else {
			minString = s2;
			maxString = s1;
		}
		//遍历字符串，直到找到不相同的为止退出循环
		for (int i = 0;i < minString.length();i++) {
			if (s1.charAt(i) != s2.charAt(i)) {
				return minString .substring(0,i);
			}
		}
		//如果两个字串相等时
		return minString;
	}

}

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