05方法的定义，调用重载

本文仅作为个人笔记

方法

方法的定义/调用

1. 什么是方法

方法(method)就是一段用来完成特定功能的代码片段，类似于其它语言的函数(function).

方法用于定义该类或该类的实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

2. 方法声明格式：

   [修饰符1 修饰符2 …]返回值类型 方法名(形势参数列表){

   ​ Java语句;…

   }

3. 方法的调用方式：

   对象名.方法名（实参列表）

4. 方法的详细说明

   • 形势参数：在方法声明时用于接受外界传入的数据。
   • 实参：调用方法时实际传给方法的数据。
   • 返回值：方法在执行完毕后还给调用它的环境的数据。
   • 返回值类型：事先约定的返回值的数据类型，如无返回值，必须显示指定为void。

5. 代码：

   	//方法的定义：
   	public static int add(int num1,int num2){
   		int sum = 0;
   		sum += num1;
   		sum += num2;
   		return sum;
   		
   	}
   	public static void main(String[] args){
   		//10+20
   		//方法的调用：(用法)
   		int num = add(10,20);
   		System.out.println(num);
   		
   		//30+90
   		int sum = add(30,90);
   		System.out.println(sum);
   		
   		//50+48
   		System.out.println(add(50,48));
   	}
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21

6. 总结：

   1.方法是：对特定的功能进行提取，形成一个代码片段，这个代码片段就是我们所说的方法
   2.方法和方法是并列的关系，所以我们定义的方法不能写道main方法中
   3.方法的定义–》格式：
   修饰符 方法返回值类型 方法名(形参列表){
   方法体；
   return 方法返回值；
   }
   4.方法的作用：提高代码的复用性

   5.总结方法定义的格式：

   1. 修饰符：暂时使用public static—>面向对象一章介绍

   2. 方法返回值类型：方法的返回值对应的数据类型

      数据类型：可以是基本数据类型（byte，short，int，long，float，double，char，boolean）也可以是引用数据类型

   3. 方法名：见名知意，首字母小写，其余遵循驼峰命名，eg：addNum,一般尽量使用英文来命名

   4. 形参列表：方法定义的时候需要的形势参数：int num1，int num2 -->相当于告诉方法的调用者：需要传入几个参数，需要传入参数的类型

      实际参数：方法调用的时候传入的具体的参数：12，20—>根据形势参数的需要传入

   5. 方法体：具体的业务逻辑代码

   6. return 方法返回值：

      方法如果有返回值的话：return+方法返回值，将返回值返回到方法的调用处

      方法如果没有返回值的话：return可以省略不写了，并且方法的返回值类型为void

   7. 方法的定义需要注意什么？

      1. 形参列表要怎么写：定义几个参数，分别是什么类型的
      2. 方法到底是否需要返回值，如果需要的话，返回值的类型是什么

   8. 方法的调用需要注意什么？

      1. 实际参数要怎么传入：传入几个参数，传入什么类型的
      2. 方法是否有返回值需要接受

   	public static void add(int num1,int num2){
   		int sum = 0;
   		sum += num1;
   		sum += num2;
   		System.out.println(sum);
   		return ;
   		
   	}
   	public static void main(String[] args){
   		//10+20
   		//方法的调用：(用法)
   		add(10,20);
   		
   		//30+90
   		add(30,90);
   		
   		
   		//50+48
   		//System.out.println(add(50,48));//不允许使用“空类型”
   	}
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20

练习

import java.util.Scanner;
public class TestMethod03{
	public static void main(String[] args){
		//功能：猜数字
		Scanner sc= new Scanner(System.in);
		System.out.println("请你猜一个数字：");
		int youGuessNum = sc.nextInt();
		
		//调用猜数字方法
		guessNum(youGuessNum);
	}
	//定义猜数方法
	public static void guessNum(int youNum){
		//设置一个数字
		int Num = 5;
		//将两个数字比对
		String str  = youNum == Num?"猜对了":"猜错了";
		System.out.println(str);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

面试题 ：下面代码中两个数是否交换成功：

public class TestMethod04{
	public static void main(){
		int a = 10;
		int b = 20;
		System.out.println("输出交换前的两个数："+a+"---"+b);
		changeNum(a,b);
		System.out.println("输出交换后的两个数："+a+"---"+b);
	}
	
	public static void changeNum(int num1 , int num2){
		int t;
		t = num1;
		num1 = num2;
		num2 = t;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

答案：没有交换成功

栈的特点：就像羽毛球桶一样先进后出(可以想象一下最先放进入的羽毛球在最底下拿羽毛球会从最上面拿)

上面代码先会

先在栈中开辟一个内存空间里面有变量a和b先把变量a放在底部然后又放了变量b

然后又在栈中开辟一个空间里面有变量t num1 num2 num1放在底部 num2放在中间 t放在最上面

在第一个栈中执行交换数字的方法它会在第二个栈中完成num1和num2数字的交换但是对第一个栈没有影响而且当方法执行完毕后会销毁所开辟的空间

所以a和b没有交换

方法的重载

1. 什么是方法的重载：

   方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。调用时，会根据不同的参数自动匹配对应的方法。

   注意本质：重载的方法，实际是完全不同的方法，只是名称相同而已！

2. 构成方法重载的条件：

   1. 不同的含义：形参类型、形参个数、形参顺序不同

   2. 只有返回值不同不构成方法的重载

      如：int a(String str) 与 void a(String str){}不构成方法重载

   3. 只有形参的名称不同，不构成方法的重载

      如：int a(String str){} 与 int a(String s){}不构成方法重载

3. 代码：

   public class TestMethod05{
   	public static void main(String[] args){
   		//10+20:
   		int sum = add(10,20);
   		System.out.println(sum);
   		
   		//20+40+80：
   		System.out.println(add(20,40,80));
   		
   		//30+60+90+120
   		System.out.println(add(30,60,90,120));
   		
   		//9.8+4.7
   		System.out.println(add(9.8,4.7));
   	}
   	
   	//定于一个方法1：两个数相加：两个int类型数据相加
   	public static int add(int num1 , int num2){
   		return num1+num2;
   	}
   	//定义一个方法：三个数相加：
   	public static int add(int num1,int num2,int num3){
   		return num1+num2+num3;
   	}
   	//定义一个方法1：四个数相加：
   	public static int add(int num1,int num2,int num3,int num4){
   		return num1+num2+num3+num4;
   	}
   	//定义一个方法：两个数相加：两个doule类型的数据相加
   	public static double add(double num1, double num2){
   		return num1+num2;
   	}
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33

   总结：

   1. 方法的重载：在一个类中，方法名相同，形参列表不同的多个方法，构成了方法的重载。

   2. 方法的重载只跟：方法名和形参列表有关，与修饰符，返回值类型无关。

   3. 注意：形参列表不同指的是什么？

      1. 个数不同

         add() add(int num1) add(int num1,int num3)

      2. 顺序不同

         add(int num1,double num2) add(double num1,int num2)

      3. 类行不同

         add(int num1) add(doule num1)

4. 请问下面的方法是否构成了方法的重载？

   1. add(int a) 和 add(int b) —> 不构成，相当于方法的重复定义
   2. public static int add(int a) 和 public static void add(int b) —> 不构成

扩充：

public class TestMethod06{
	public static void main(String[] args){
		add(5);
		//级别：byte,short,char-->int-->long-->float-->double
	}
	public static void add(double num1){
		System.out.println("-------2");
	}
	public static void add(float num1){
		System.out.println("-------3");
	}
	public static void add(long num1){
		System.out.println("-------4");
	}
	/*public static void add(int num1){
		System.out.println("-------1");
	}*/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18