java中方法介绍

1、在我们的日常生活中，方法可以理解为为了解决某一种问题而采取的一种方式手段。
2、java语言中方法，具有特定功能的代码段。
	就是用来完成解决某件事情或者实现某个功能的方式。
3、在代码中，对于一些经常使用，或者某些代码可以解决一类的问题，将这段代码用大括号括起来，起个名字，以后使用这	   个名字来代替这段代码，实现该代码所具有的功能。
4、好处：
	提高了代码的复用性
	提高了代码的封装性，大括号中的内容，其他调用者看不到也无法直接访问。
	简化代码的设计思维难度

package com.ujiuye.demos;
public class Demo_5 {
	public static void main(String[] args) {	
		int a = 10;
		int b = 20;
//		int sum = a + b;
//		System.out.println(sum);
		getSum(a, b);
		int c = 10;
		int d = 20;
//		int sum = a + b;
//		System.out.println(sum);
		getSum(c, d);
	}
	//方法
	public static void getSum(int a ,int b){
		int sum = a + b;
		System.out.println(sum);
	}
}

方法的定义

1、方法定义的格式
	修饰符 返回值类型 方法名称(参数列表){
		方法体语句；
		return语句；
	}
2、详细解释
	 （1）修饰符: 目前先全写为 public static
	 （2）返回值类型：方法具有一些功能，有可能会有一些数据的产出，将数据返回给调用者，调用者要知道生产出来的数据是什么类型。（return后返回的是什么类型的数据，返回值类型就写什么类型）
	 （3）方法名称：给这段代码起个名字，只要是一个合法的标识符即可。小驼峰命名法。eg：getName
	 （4）参数列表：这段代码要完成功能，可能会从外界接收一些数据。在参数列表中，需要定义一些变量，在调用方法的时候，会由外界传入具体的数值，赋值给定义的变量，就可以在方法体中去对外界的数据进行操作。
	 （5）方法体语句：真正要完成该方法功能的执行逻辑。
	 （6）return语句：最终生产出来的结果，要返回给调用者，使用return语句返回，如果没有生产任何的数据，就可以直接写个return；，用于表示方法的结束

package com.ujiuye.demos;

public class Demo_6 {
//	方法的定义格式
	public static void main(String[] args) {

	}

	// 没有参数列表，没有返回值的
	public static void/*方法没有返回值，没有生产出数据*/ getSum() {// 需不需要参数列表，取决于将来在调用方法的时候，是否要从外界接收数据
		int a = 10;//不是从外界拿到的数据
		int b = 20;
		System.out.println(a + b);
//		没有return或者return后面什么都没写
		return;// 没有生产出任何的数据
	}

//	有参数列表，有返回值的
	public static int getSum1(int a ,int b) {// 想要从外界传入数据，定义参数列表,参数列表，只有变量的声明，没有赋值
//		在参数列表中声明的变量，在方法体中可以直接的使用
//		System.out.println(a + b);
		int sum = a + b;
		return sum;
	}
}

方法的调用

1、格式：直接书写方法名称即可
	方法名称(实际参数);
2、形式参数和实际参数
	形式参数：方法小括号中只有变量的声明，没有变量的赋值
	实际参数：在调用方法的时候，在方法的小括号中传入具体的数据，而不再是变量的声明。
3、方法的调用三种形式：
	（1）直接调用：方法没有返回值，只是表示某些内容的执行，没有生产数据。
	（2）输出调用：方法有返回值，需要打印，如果这个方法只需要打印不需要后续对数据的处理，就是用输出调用即可。
	（3）赋值调用：方法的返回值，使用一个变量进行接收，后续可以对这个数据进行处理
4、方法不调用就不执行

package com.ujiuye.demos;

public class Demo_6 {
//	方法的定义格式
	public static void main(String[] args) {
//		直接调用
		getSum();
//		输出调用
		System.out.println(getSum1(100,200));//将方法生产出的数据，打印出来
//		赋值调用
		int sum = getSum1(90, 80);//方法生产出的数据，也可以找一个变量接收方法生产的数据
//		可以对sum做一些处理
		sum += 10;
		System.out.println(sum);
	}

	// 没有参数列表，没有返回值的
	public static void/*方法没有返回值，没有生产出数据*/ getSum() {// 需不需要参数列表，取决于将来在调用方法的时候，是否要从外界接收数据
		int a = 10;//不是从外界拿
        到的数据
		int b = 20;
		System.out.println(a + b);
//		没有return或者return后面什么都没写
//		return;// 没有生产出任何的数据
	}

//	有参数列表，有返回值的
	public static int getSum1(int a ,int b) {// 想要从外界传入数据，定义参数列表,参数列表，只有变量的声明，没有赋值
//		在参数列表中声明的变量，在方法体中可以直接的使用
//		System.out.println(a + b);
		int sum = a + b;
		return sum;
	}
}

方法的注意事项

1、方法的定义
	（1）方法不能嵌套定义
	（2）方法的先后是没有区别的
	（3）方法的定义都是平级的关系
	（4）方法是可以嵌套调用的，注意不要无节制的递归调用
2、参数列表
	（1）形式参数：定义方法时使用，方法小括号中只有变量的声明，没有变量的赋值，如果要定义多个形式参数，使用逗号分隔。
	（2）实际参数：在方法调用的时候使用，不能加上数据类型的参数，本质上是对形式参数的赋值，各个参数之间也使用逗号分隔，实际参数的顺序和形式参数的顺序要保持一致。
3、return语句
	（1）语句表示方法产出的内容，或者是方法的结束
	（2）如果方法没有具体的返回内容，可以写return；或者就不写return；语句，返回值类型必须为void
	（3）如果方法有具体的返回内容，那么return后面就需要加上返回的那个数据。返回值类型必须和return后的语句的数据类型保持一致

package com.ujiuye.demos;
public class Demo_7 {
//	方法的注意事项
	public static void main(String[] args) {
//		方法不能嵌套定义
//		public static void print() {
//			System.out.println("java");
//		}
		test_1();// 调用的顺序有关 1
//		test_2();
//		调用test_3
		test_3(100, "java", 12.12);// 调用方法的时候，如果该方法有形式参数，必须传入对应的实际参数
//		本质上是对形参完成赋值的过程  int a  = 100， String str = "java"  double d = 12.12
	}

	public static String test_3(int a, String str, double d) {// 多个形式参数，使用逗号分隔
//		System.out.println(a + str);
		String s = a + str + d;
		return s;
//		return;
	}

//	定义打印语句的方法
	public static void test_1() {// 方法定义的先后是没有区别的
		test_2();// 方法可以嵌套调用 2
		System.out.println("test_1"); // 4
	}

	public static void test_2() {// 方法定义的先后是没有区别的
		test_1();
		System.out.println("test_2"); // 3
	}
}

定义一个方法，可以打印指定行数和列数的星星矩阵
行数和列数是通过键盘录入的。键盘录入两个整数，作为行数和列数，调用方法打印对应的矩阵

package com.ujiuye.demos;

import java.util.Scanner;

public class Demo_8 {
//	定义一个方法，可以打印指定行数和列数的星星矩阵
//	行数和列数是通过键盘录入的。键盘录入两个整数，作为行数和列数，调用方法打印对应的矩阵
	public static void main(String[] args) {
//		键盘录入两个整数
		Scanner scanner = new Scanner(System.in);
		System.out.println("请输入行数");
		int hang = scanner.nextInt();
		System.out.println("请输入列数");
		int lie = scanner.nextInt();
//		调用方法
		xingXing(hang,lie);

	}

	public static void xingXing(int hang ,int lie) {
		
		for (int i = 1; i <= hang; i++) {
			for (int j = 1; j <= lie; j++) {
				System.out.print("*");
			}
			System.out.println();
		}
	}
}

方法的重载

1、重载：overload
2、方法的重载：
	在同一个类中，方法名相同，参数列表不同，与返回值类型无关。
3、说明：
	（1）在同一个类中，不同的类中，是不可能有方法的重载
	（2）方法名相同：方法名称必须完全一模一样
	（3）参数列表不同：体现在三个不同。1、参数类型不同2、参数的个数3、参数的顺序不同
					跟参数的名称没有关系
	（4）与返回值类型无关。方法时候重载，返回值是没有关系的。
		如果方法的名称和参数列表都一样了，即使返回值类型不同，也不算重载。属于方法的重复定义。
4、方法重载的好处
	没有重载，相同逻辑的代码，需要定义很多个名称，在记忆名称的时候，比较麻烦，有了重载，只需要记忆一个方法的名称
5、常见的方法的重载：
	println方法就是方法的重载

package com.ujiuye.demos;
public class Demo_9 {
	public static void main(String[] args) {
		int sum = getSum(12,13);
		System.out.println(sum);
		double sum2 = getSum(12.23, 13);//根据传入实参的类型，可以确定到底执行哪一个getSum方法
		System.out.println(sum2);
	}
//	共同的特征就是全都是求和的操作，方法体的执行逻辑一样
//	参数类型不同，可以发生重载
	public static int getSum(int a,int b) {
		return a + b;
	}
	
//	与返回值类型无关
	/*public static double getSum(int a,int b) {
		return a + b;
	}*/
	
	/*public static int getSum(int a,int b) {
		return a + b + 10;
	}*/
	
	public static double getSum(double d1,int d2) {
		return d1 + d2;
	}
	
//	public static double getSum(double d3,int d4) {
//		return d3 + d4;
//	}方法的重载跟参数的名称是没有关系的
	
//	参数的顺序，参数的顺序不同，也是方法的重载
	public static double getSum(int d1,double d2) {
		return d1 + d2;
	}
//	参数的个数不同时，会发生方法重载
	public static int getSum(int a,int b,int c) {
		return a + b + c;
	}
	
	public static double getSum(double d1 ,double d2) {
		return d1 + d2;
	}
}

三、数组