JavaSE6.26课堂笔记方法的总结

6.26JavaSE课堂笔记

1、方法

1.1什么是方法，方法有什么用

什么是方法？我们先来看看代码中没有方法，程序会有什么缺点

//计算10与20的和
int a = 10;
int b = 20;
int c = a + b;
System.out.println(a + "+" + b + "=" + c);

//计算100与200的和
int x = 100;
int y = 200;
int z = x + y;
System.out.println(x + "+" + y + "=" + z);

//计算1000与2000的和
int i = 100;
int j = 200;
int k = i + j;
System.out.println(i + "+" + j + "=" + k);

观察以上3段代码，3段代码都是计算两个数的和，求和代码，每一次求和都需要将代码重写一遍，代码没有得到重复利用，

表面上3段代码看似实现了3个功能，但实际上只有一个“求和”的功能，只是每一次求和的参数不同。那我们能不能只写一

段代码，传入不同的参数，实现求和的功能。这时，我们就需要掌握Java语法中的方法机制，我们来改进一下以上代码

public static void main(String args[]){
     
    //调用方法计算10,20的和
    sumInt(10,20);
    //调用方法计算100,200的和
    sumInt(100,200);
    //调用方法计算1000,2000的和
    sumInt(1000,2000);
}

//求和的方法
public static void sumInt(int a,int b){
     
    int c = a + b;
	System.out.println(a + "+" + b + "=" + c);
}

运行结果如下：

10+20=30
100+200=300
1000+2000=3000

方法其实就是一段普通的代码片段，并且这段代码可以完成某个特定的功能，而且可以被重复的调用/使用。只要是可以独立出来的功
能，我们都可以定义为单独的一个方法来完成，如果以后需要使用此功能时直接调用这个方法就行了，不要把所有的代码都扔到 main

方法当中，这样会导致程序的“复用性”很差。

1.2方法的定义与调用

1）方法怎么定义，语法机制是什么？

[修饰符列表] 返回值类型 方法名(形式参数列表){
方法体;
}

注意：
[] 符号叫做中括号，以上中括号[]里面的内容表示不是必须的，是可选的。
方法体由Java语句构成。
方法定义之后需要去调用，不调用是不会执行的。

2）关于修饰符列表

​ 修饰符列表不是必须的，是可选的，public static意为公开的，静态的，

3）关于返回值类型

第一：返回值类型可以是任何类型，只要是java中合法的数据类型就行，数据
类型包括基本数据类型和引用数据类型，也就是说返回值类型可以是：byte short
int long float double boolean char String…

第二：什么是返回值？
返回值一般指的是一个方法执行结束之后的结果。结果通常是一个数据，所以被称为“值”，而且还叫“返回值”。
方法就是为了完成某个特定的功能，方法结束之后大部分情况下都是有一个结果的，而体现结果的一般都是数据
数据得有类型。这就是返回值类型。

第三：当一个方法执行结束不返回任何值的时候，返回值类型也不能空白，必须写上void关键字。所以void表示该
方法执行结束后不返回任何结果。

第四：如果返回值类型“不是void”，那么你在方法体执行结束的时候必须使用"return 值;"这样的语句来完成“值”的返回，如果没有“return 值;”
这样的语句那么编译器会报错。

第五：只要有“return”关键字的语句执行，当前方法必然结束。return只要执行，当前所在的方法结束，记住：不是整个程序结束。

第六：如果返回值类型是void，那么在方法体当中不能有“return 值;”这样的语句。但是可以有“return;”语句。这个语句“return;”的作用就是用来
终止当前方法的。

4）方法名
方法名要见名知意。（驼峰命名方式）
方法名在标识符命名规范当中，要求首字母小写，后面每个单词首字母大写。
只要是合法的标识符就行。

5）形式参数列表
简称：形参
注意：形式参数列表中的每一个参数都是“局部变量”，方法结束之后内存释放。
形参的个数是：0~N个。
public static void sumInt(){}
public static void sumInt(int x){}
public static void sumInt(int x, int y){}
public static void sum(int a, int b, double d, String s){}
形参有多个的话使用“逗号,”隔开。逗号是英文的。
形参的数据类型起决定性作用，形参对应的变量名是随意的。

6）方法体：
由Java语句构成。java语句以“;”结尾。
方法体当中编写的是业务逻辑代码，完成某个特定功能。
在方法体中的代码遵循自上而下的顺序依次逐行执行。
在方法体中处理业务逻辑代码的时候需要数据，数据来源就是这些形参。

7）方法定义之后怎么调用呢？
方法必须调用才能执行。
怎么调用，语法是什么？

​ 静态方法：类名.方法名(实际参数列表);

​ 实例方法：引用.方法名(实际参数列表);需要先创建对象。

public class MethodTest03{
     

	//方法定义在这里可以。

	// main方法结束之后不需要给JVM返回任何执行结果。
	public static void main(String[] args){
     
		// 调用方法
		//错误: 不兼容的类型: String无法转换为int
		//MethodTest03.divide("abc", 200); // int a = "abc";

		//错误原因: 实际参数列表和形式参数列表长度不同
		//MethodTest03.divide();

		// (10, 2)叫做实际参数列表，简称实参。
		// 注意：实参和形参必须一一对应，类型要对应，个数要对应。
		MethodTest03.divide(10, 2);

		// 调用sum方法
		// 怎么去接收这个方法的返回结果？？？？
		// 使用变量来接收这个方法的返回值。
		// 注意：变量的定义需要指定变量的数据类型。
		// 变量的数据类型是什么呢？
		int jieGuo = MethodTest03.sum(100, 200);
		System.out.println(jieGuo); //300

		// jieGuo变量可以是double类型吗？
		// double是大容量。int是小容量。自动类型转换。
		double jieGuo2 = MethodTest03.sum(100, 200);
		System.out.println(jieGuo2); //300.0

		// 对于没有返回值的方法，变量能接收吗？
		// divide方法结束没有返回值。不能接收。
		// 错误: 不兼容的类型: void无法转换为int
		//int i = MethodTest03.divide(100, 50);

		// 当一个方法有返回值的时候，我可以选择不接收吗？
		// 你可以返回值，但是我可以选择不要你这个值。这是允许的。
		// 只不过这样没有意义，一般程序返回了执行结果，都是需要接收这个结果的。
		// 我们可以不接收，但是这个返回值该返回还是会返回的。只不过不用变量接收。
		// 以下代码虽然没有使用变量接收这个返回值，但是这个值还是返回了。
		// 返回之后内存马上释放，因为没有使用变量接收。
		MethodTest03.sum(100, 200);

		byte b1 = 10;
		//int a = b1;
		byte b2 = 20;
		int result = sum(b1, b2); // (b1,b2)是实参。自动类型转换。
		System.out.println(result);

	}

	// 计算两个int类型数据的和
	/*
	public static String sum(int a, int b){
		// 错误: 不兼容的类型: int无法转换为String
		return a + b;
	}
	*/

	public static int sum(int a, int b){
     
		return a + b;
	}

	// 方法定义到这里也可以。没有顺序要求。
	// 业务是什么？计算两个int类型数据的商
	// 方法执行结束之后返回执行结果。

	//错误: 缺少返回语句
	/*
	public static int divide(int x, int y){
		int z = x / y;
	}
	*/

	//错误: 不兼容的类型: String无法转换为int
	/*
	public static int divide(int x, int y){
		int z = x / y;
		return "abc";
	}
	*/

	//可以
	/*
	public static int divide(int x, int y){
		int z = x / y;
		return z;
	}
	*/

	//可以
	/*
	public static int divide(int x, int y){
		return x / y;
	}
	*/

	// 可以
	/*
	public static int divide(int a, int b){
		return a / b;
	}
	*/

	// 如果我不需要执行结束之后的返回值？
	// 这个结果我希望直接输出。
	//错误: 不兼容的类型: 意外的返回值
	/*
	public static void divide(int a, int b){
		return a / b;
	}
	*/

	//可以
	/*
	public static void divide(int a, int b){
		return; // 用来终止这个方法的
	}
	*/

	// 可以
	/*
	public static void divide(int a, int b){
	}
	*/

	// 可以
	public static void divide(int a, int b){
     
		System.out.println(a / b); // 5
	}
}

2、方法重载

观察一下代码，不使用方法重载，代码有什么缺点？

public static void main(String[] args){
     
        int x = sumInt(10, 20);
        System.out.println(x);

        long y = sumLong(10L, 20L);
        System.out.println(y);

        double z = sumDouble(10.0, 20.0);
        System.out.println(z);
    }

    // 定义一个计算int类型数据的求和方法
    public static int sumInt(int a, int b){
     
        return a + b;
    }

    // 定义一个计算long类型数据的求和方法
    public static long sumLong(long a, long b){
     
        return a + b;
    }

    // 定义一个计算double类型数据的求和方法
    public static double sumDouble(double a, double b){
     
        return a + b;
    }
}

分析：sumInt、sumLong、sumDouble不是功能“相同”，是功能“相似”。三个方法功能不同，但是相似，分别起了三个不同的名字，有什么缺点？

缺点包括两个：
第一个：代码不美观（不好看、不整齐）。【这是次要的】
第二个：程序员需要记忆更多的方法名称，程序员比较累。

使用方法重载机制。解决之前的两个缺点。
优点1：代码整齐美观。
优点2：“功能相似”的，可以让“方法名相同”，更易于以后的代码编写。

在java语言中，是怎么进行方法区分的呢？
首先java编译器会通过方法名进行区分。
但是在java语言中允许方法名相同的情况出现。
如果方法名相同的情况下，编译器会通过方法的参数类型进行方法的区分。

public static void main(String[] args){
     
        // 对于程序员来说，只需要记忆一个方法名即可。
        System.out.println(sum(10, 20));
        System.out.println(sum(10L, 20L));
        System.out.println(sum(10.0, 20.0));
    }
    // 定义一个计算int类型数据的求和方法
    public static int sum(int a, int b){
     
        System.out.println("int求和");
        return a + b;
    }

    // 定义一个计算long类型数据的求和方法
    public static long sum(long a, long b){
     
        System.out.println("long求和");
        return a + b;
    }

    // 定义一个计算double类型数据的求和方法
    public static double sum(double a, double b){
     
        System.out.println("double求和");
        return a + b;
    }

在编写代码时，我们什么时候考虑使用方法重载呢？

​ 在同一个类中，如果两段代码或多段代码的功能相识时，我们可以考虑将方法名定义一致，这样代码美观，便于代码编写。

​ 注意：方法重载overload不能随便使用，如果两个功能压根不相干，
​ 不相似，根本没关系，此时两个方法使用重载机制的话，会导致
​ 编码更麻烦。无法进行方法功能的区分。

什么时候代码会发生方法重载？
条件1：在同一个类当中
条件2：方法名相同
条件3：参数列表不同
参数的个数不同算不同
参数的类型不同算不同
参数的顺序不同算不同

只要同时满足以上3个条件，那么我们可以认定方法和方法之间发生了重载机制。

注意：方法重载和方法的“返回值类型”无关。
方法重载和方法的“修饰符列表”无关。

public class OverloadTest03{
     
	public static void main(String[] args){
     
		m1();
		m1(100);

		m2(10, 3.14);
		m2(3.14, 10);

		m3(100);
		m3(3.14);

	}

	public static void m1(){
     
		System.out.println("m1无参数的执行！");
	}
	
	// 这个方法的参数个数和上面的方法的参数个数不同。
	public static void m1(int a){
     
		System.out.println("m1有一个int参数执行！");
	}

	public static void m2(int x, double y){
     
		System.out.println("m2(int x, double y)");
	}

	// 参数的顺序不同，也算不同。
	public static void m2(double y, int x){
     
		System.out.println("m2(double y, int x)");	
	}

	public static void m3(int x){
     
		System.out.println("m3(int x)");
	}

	// 参数的类型不同。
	public static void m3(double d){
     
		System.out.println("m3(double d)");
	}

	//分析：以下两个方法有没有发生重载？
	// 编译器报错了，不是重载，这是重复了：呵呵。
	/*
	public static void m4(int a, int b){
	
	}
	public static void m4(int x, int y){
	
	}
	*/

	// 这两个方法有没有发生重载呢？
	// 这不是重载，这是方法重复了。
	/*
	public static int m5(){
		return 1;
	}
	public static double m5(){
		return 1.0;
	}
	*/

	//这两个方法重载了吗？
	// 这个方法没有修饰符列表
	// 这不是重载，是重复了。
	/*
	void m6(){
	
	}
	// 这个有修饰符列表
	public static void m6(){
	
	}
	*/

}

class MyClass{
     
	// 不在同一个类当中，不能叫做方法重载。
	public static void m1(int x, int y){
     
	
	}

3、方法递归

​ 递归其实就是方法在执行的过程中调用了另一个方法，而另一个方法则是自己本身。

​ 观察以下代码

public class RecursionTest01 {
     
public static void main(String[] args) {
     
	m();
}
public static void m(){
     
	System.out.println("m begin");
	m();
	System.out.println("m over");
	}
}

我们可以看到以上代码的执行过程中，一直输出“m begin”，“m over”一次也没有输出，直到最终发生了错误：java.lang.StackOverflowError，

这个错误是栈内存溢出错误，错误发生后，JVM 退出了，程序结束了。

以上代码m()方法在执行过程中，在m()中 又调用了m()方法，方法自身调用自身，这就是方法递归。

使用递归计算1~n的和

public static void main(String[] args) {
     

        //使用方法递归计算 1~N 的和
        int result = sum(10);
        System.out.println(result);

    }

    public static int sum(int n) {
     
        if (n == 1) {
     
            return 1;
        }
        return n + sum(n - 1);
    }

4、总结

今天主要讲解了什么是方法，方法的定义，方法的调用，什么是方法重载，什么是方法的递归。