Java_方法

• Java方法是语句的集合，它们在一起执行一个功能
  • 方法是解决一类问题的步骤的有序集合
  • 方法包含于类或对象中
  • 方法在程序中被创建，在其他地方被引用

一、方法之概念、定义、调用、重载

Java的方法是一段用来完成特定功能的代码片段。一般情况下，定义一个方法包含以下语法：

• 方法包含一个方法头和一个方法体：
  • 修饰符；定义该方法的访问类型。
  • 返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行后没有返回值，这种情况下，returnValueType是关键字void。
  • 方法名：是方法的实际名称，方法名和参数表共同构成方法签名。
  • 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
    • 形参：在方法被调用时用于接收外界输入的数据。
    • 实参：调用方法时实际传给方法的数据。
  • 方法体：方法体包含具体的语句，定义该方法的功能。
• 结构：
  修饰符 返回值类型 方法名(参数类型 参数名){
  // 方法体
  return 返回值；
  }

重载

• 重载就是在一个类中，有相同的函数名称，但形参不同的函数。
• 重载规则：
  • 方法名必须相同
  • 参数列表必须不同（个数不同、或类型不同、或参数排列顺序不同等）
  • 方法的返回类型可以相同也可以不相同
  • 仅仅返回类型不同不足以成为方法的重载

	public static void main(String[]  args){
		// 调用
		int max = max(10, 12);	// 实际参数：实际调用传递给方法的参数
		System.out.println(max);
	}
	
	// 定义方法
	public static int max(int num1, int num2){	// 形式参数：用来定义作用的
		int result = num1 > num2? num1 : (num1 == num2? 0 : num2)
		return result;
	}
	// 重载
	public static double max(double num1, double num2){
		int result = num1 > num2? num1 : (num1 == num2? 0 : num2)
		return result;
	}

二、方法之可变参数

可变参数也叫不定项参数。
从jdk1.5开始，Java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加省略号（…）
一个方法中只能指定一个可变参数，且必须是方法的最后一个参数，普通参数必须声明在可变参数之前

	public static void main(String args[]){
		//调用可变参数
		printMax(12, 5, 32.5, 17, 44, 20);
		printMax(new double[]{12, 5, 17, 20, 44.1});
	}

	public static void printMax(double... numbers){
		if(numbers.length == 0){
			System.out.println("numbers is null!");
			return;
		}
		double result = numbers[0];
		// 排序
		for(int i=1; i<numbers.length; i++){
			if(numbers[i] > result){
				result = numbers[i];
			}
		}
		System.out.println(result);
	}

三、方法之递归

方法自调用即为递归
递归策略只需要少量的程序就可以描述出接替过程中所需要的多次重复计算，大大减少了代码量。递归的能力在于用有限的语句来定义对象的无限集合。

public class Demo05{
	public static void main(String[] args){
		Demo05 test = new Demo05();
		test.test();
	}

	public void test(){
		test();
	}
}

执行以上代码会出现 栈溢出 异常。由于程序不停调用test()，递归操作没有终止陷入死循环。

为了避免出现以上异常，我们在使用递归时应给方法加上一个边界条件
即 递归=边界条件+递归表达式

正确示例：以阶乘为例

public class Demo05{
	public static void main(String[] args){
		System.out.println(f(10));
	}

	public static int f(int n){
		if(n == 1){
			return 1;
		}else{
			return n*f(n-1);
		}
	}
// 递归结构包含两个部分：
//		递归头：什么时候不调用自身方法。没有递归头将陷入死循环
//		递归体：什么时候调用自身方法
}

使用递归时应该注意，对于嵌套层数比较深的算法，递归容易造成内存崩溃

四、方法之面向对象应用

public class Demo02{

	public static void main(String[] args){
		// 静态方法调用 
		Student.say();
		// 非静态方法 调用
		Student student = new Student();	// 实例化这个类 new
		student.say2();
	}
	
}

学生类：Student

public class Student{

	// 静态方法
	public static void say(){
		System.out.println("学生说话了");
	}

	// 非静态方法
	public void say2(){
		System.out.println("学生又说话了");
	}

}

类中两个方法都是非静态方法时可以直接调用

public class Demo02{
	public void a(){
		b();
	}
	public void b(){
	}
}

类中两个方法都是静态方法时也可以直接调用

public class Demo02{
	public static void a(){
		b();
	}
	public static void b(){
	}
}

类中两个方法一个是静态方法另一个是非静态时，此时a()不能直接调用b()

public class Demo02{

	// 和类一起加载的
	public static void a(){
		b();	// 此处会出现异常
	}
	// 类实例化后才存在的
	public void b(){
		a();	// 在b()中是可以调用a()的
	}
	
}

值传递

public class Demo03{
	public static void main(String[] args){
		int a = 1;
		System.out.println(a);	// 1
		Demo03.change(a);
		System.out.println(a);	// 1
	}
	public static void change(int a){
		a = 10;					// 10
	}
}

打印输出发现a的值并没有发生变化，因为change方法的返回值是空，所以回到主函数后a的值仍然是1。
引用传递

// 引用传递：对象，本质还是值传递
public class Demo04{
	public static void main(String[] args){
		Person person = new Person();
		System.out.println(person.name);	// null

		Demo04.change(person);
		System.out.println(person.name);	// 冻冻
	}
	public static void change(Person person){
		person.name = "冻冻";
	}
}
// 定义一个Person类，有一个属性name
class Person{
	String name;	// null
}

上一篇：Java_流程控制