java 函数

这次是2021年01月14日的学习成果，总结于此，以便于之后的学习查漏补缺

函数

函数概述

把提前写好的一段代码封装成一个独立的小程序，等到下次代码里需要用到这个小程序里的方法时，可以直接调用这个小程序。这种封装形式的表现形式，被称为方法或函数。函数的出现提高了代码的复用性和维护性。

方法的位置

1、必须位于类中
2、不可以在方法中再定义方法。即方法的定义不支持嵌套
3、一个类中可以有0个、1个、多个方法

方法的定义

修饰符 返回值 类型函数名(参数类型 形式参数1 , 参数类型 形式参数2 ,…"){

执行语句;

执行语句;

执行语句;

................

return返回值;

}

修饰符:修饰符用于决定方法的访问控制权限

返回值类型:运行这段程序的运算结果的类型。如果函数没有返回值则用void来表示该函数没有返回值

函数名:仅仅是一个标识符，命名时请注意规范

形式参数:形参是一个变量，用于存储调用函数传递进来的实际参数;形参的个数可以为0个、1个、多个

返回值:将计算结果返回给调用者。不是所有的函数都有返回值。请注意: return后面返回值的数据类型与方法定义中的返回值类型必须一致或兼容

public static void printName() {
		System.out.println("李逍遥");
	}
	public static void printSum() {
		int a = 5;
		int b = 6;
		int c = a + b;
		int sum = c;
		System.out.println(sum);
		Test01.printName();
		//函数内可互相调用
		//方法之间互相调用会报错，互相无限调用，内存直接拉满
	}
	public static void main(String[] args) {
		//同一个类 中调用可以省略Test.
		printName();
		printSum();
	}

实际参数与形式参数

//                       形式参数   形式参数
	public static void rec(int a,int b) {
		int area = a * b;
		System.out.println("此形状的面积为："+area);
	}

	public static void printInfo(String name,int age) {
		System.out.println("你的名字是："+name);
		System.out.println("你的年龄是："+age);
	}
	
	public static void main(String[] args) {
		//          实际参数
		Test02.rec(7,9);
		Test02.printInfo("ljj", 21);
	}

创建方法求数组的一系列问题

public static void main(String[] args) {
		int[] array1 = {6,4,9,7,8,2};
		int[] array2 = {5,8,9,4,2};
		
		Test03.getMax(array1);
		System.out.println("-------------");
		Test03.printArray(array2);
	}
	
	//创建方法求数组中元素的最大值
	public static void printArray(int[] array) {
		for(int i =0;i<array.length;i++) {
			System.out.println(array[i]);
		}
	}
	//创建方法求数组的遍历
	public static void getMax(int[] array) {
		int len = array.length;
		int max = array[0];
		for(int i=0;i<len;i++) {
			if(max < array[i]) {
				max = array[i];
			}
		}
		System.out.println(max);
	}

public static void main(String[] args) {
		double[] array2 = {3.3,4.5,9.8,7.6};
		Test04.getValue(array2, 2);
	}
	
	public static void getValue(double[] array,int index) {
		int len = array.length;
		if(index >=0 && index <len) {
			double value = array[index];
			System.out.println(value);
		}else {
			System.out.println("参数有误");
		}
	}

public static void main(String[] args) {
		int[] array = {5,4,7,9,8};
		Test07.printArray(array);
		Test07.reverseArray(array);
		Test07.printArray(array);
	}
	
	//创建方法逆置数组
	public static int[] reverseArray(int[] array) {
		for (int i = 0; i < array.length / 2; i++) {
			int temp = array[i];
			array[i] = array[array.length - 1 - i];
			array[array.length - 1 - i] = temp;
		}
		return array;
	}
	//创建方法遍历数组
	public static void printArray(int[] array) {
		System.out.print("{");
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i]);
			if (i != array.length - 1) {
				System.out.print(",");
			}
		}
		System.out.println("}");
	}

自己根据学的方法，随便写的一些东西（纯为了练手，不用细看）

public static void main(String[] args) {
		String result = Test06.buyFood(99);
		System.out.println(result);	
		String myage = Test06.checkID(21);
		System.out.println(myage);
	}
	// 输入你带的钱，得到你去饭店该做的事
	public static String buyFood(int money) {
		String result = "";
		if(money ==0) {
			result = "离开";
		}else if(money>0 && money <= 10) {
			result = "吃点小吃";
		}else {
			result = "好好吃一顿";
		}
		return result;
	}
	//输入你的年龄，获取你到了网吧得到的待遇
	public static String checkID(int age) {
		String words = "";
		if(age<18) {
			System.out.println("回家写作业去");	
		}else {
			System.out.println("欢迎光临");
		}
		return words;
	}

方法的调用

方法只有在调用后才被执行;方法不被调用则不会执行

常用方式: 对象名.方法名( )

假若该方法被static修饰，则通过: 类名.方法名( ) 即可

可变参数

public static void main(String[] args) {
		Test08.getSum1(1,3,5);
		Test08.getSum2("asd", 5,6,9,72);
	}
	
	//可变参数  (参数可变，本质其实就是数组)
	public static void getSum1(int...arr) {
		for(int a:arr) {
			System.out.println(a);
		}
	}
	
	public static void getSum2(String string ,int...arr) {
		
	}

可变参数(…)适用于参数个数不确定，类型确定的情况。
java 把可变参数当做数组处理，即可变参数其实是一个数组。可变参数的特点如下:

(1)、 可变参数只能出现在参数列表的最后;

(2)、…位于变量类型和变量名之间，前后有无空格都可以;

(3)、调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中一数组的形式访问可变参数。

方法的重载

public static void main(String[] args) {
		Test09.add(2, 3);
		Test09.add(3, 4, 5);

	}
	//函数的重载
	public static void add(int a ,int b) {
		
	}

	public static void add(int a ,int b,int c) {
		
	}

在同一个类中，可以有一个以上的方法使用相同的方法名称，但是这些方法的参数必须不同。即:参数个数不同，或者是参数类型不同，这些方法称为方法重载。

例如，要打印不同类型的数据: int、 float、 String， 定义不同名字的方法实现:printInt(int);

printFloat(float);

printString(String);

利用方法重载，只需要定义一个方法名: print()， 它可接收不同类型的参数，为这些不.同的参数类型提供通用处理:

print(int i);

print(float f);

print(String s);
判断两个方法之间是否重载，这和方法的返回类型无关，也和抛出的异常类型无关，只和方法的参数有关。

方法小结

1、方法必须先声明后使用;不可使用未声明的方法

2、方法不调用不执行。换句话说:方法只有被调用后才会执行

3、方法调用一次执行一次。同一个方法可以被调用多次。如果被调用方法有形参列表，那么必须在调用方法时传递实参列表。实参列表不需要写数据类型，实参的个数、类型与形参列表的顺序要一一对应。

4、方法与方法是平级关系，不能嵌套定义;即不可在方法中再定义方法

5、方法定义的时候参数之间用逗号隔开

6、如果方法有明确的返回值，一定要使用return 带回一个值

7、函数的结果应该返回给调用者，交由调用者处理

8、return 语句执行后或在大括号的末尾将终止本函数的执行，即函数执行完成