Java 方法

发表于 | 更新于 | 评论数： | 阅读次数：

写在开头

 一名优秀的计算机科学家，可能不一定是一名优秀的物理学家，但一定是一名优秀的数学家，我理解的计算机科学实质上是把数学语言转换成计算机语言的过程。
 而我的数学并不好…
 最难受的是英语也看不懂…
 进入正题，搜索功能已经完善好了，可以直接从左侧搜索~  这一篇写java方法。

方法

方法的定义

 在前面几个文章中我们经常使用到 System.out.println()，它是什么呢？

  • println() 是一个方法。
  • System 是系统类。
  • out 是标准输出对象。

 这句话的用法是调用系统类 System 中的标准输出对象 out 中的方法 println()。

 那么什么是方法呢？

Java方法是语句的集合，它们在一起执行一个功能。

  • 方法是解决一类问题的步骤的有序组合
  • 方法包含于类或对象中
  • 方法在程序中被创建，在其他地方被引用

方法的优点

// 可以这么理解把使用频率比较高的功能打包在一起，可以随时调用，主程序就简单明了 还好维护。

  1. 使程序变得更简短而清晰。
  2. 有利于程序维护。
  3. 可以提高程序开发的效率。
  4. 提高了代码的重用性。

方法定义的解释及注意事项

定义格式：

修饰符 返回值类型 方法名(参数列表){
功能逻辑;
}

对应下来就是：

1
2
3
4
5
public static void main(String[] args){
   
   逻辑;

}

解释

  1. 修饰符: public static —- public修饰符,static 修饰符

  2. 返回值类型: 指方法应该是有什么样的结果,返回值类型可以是任意的数据类型,如果没有 返回值,那么写成void(例如main方法,就没有返回值)

  3. 参数列表: 表示我要做一个功能,需要提供给我哪些数据,写在方法名后的小括号中

    参数可以没有,不写;  
可以有一个参数:  数据类型  变量名
多个参数(没有个数限制) : 数据类型  变量名 , 数据类型  变量名

    注意: 方法的参数列表中的变量,只能在方法的大括号中使用

  4. 方法的返回: 关键字return,表示返回,将这个方法的结果,返回到方法的调用者处

    如果方法有返回值,return 必须写, return后面的数据必须与返回值类型一致;
如果方法没有返回值,return 可以省略,可以写(return ;  没意义)
方法如果没有返回值,那么在定义上,返回值类型处必须写成void

  5. {} : 表示这个方法的范围,功能都需要写在这一对大括号中

方法的命名规则:

//行业内一般的命名规则，以后进公司如果不这样做，会被打的。

  1. 方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如：addPerson。
  2. 下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test_ ，例如 test

在代码里解释下：

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
public class Function1
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}

	/*定义一个方法:需求: 求长方形的周长
	
	 修饰符 返回值类型 方法名(参数列表){
		功能逻辑;
     }

	 1. 修饰符,暂时先记忆成 public static
	 2. 返回值类型: int
	 3. 方法名: getArea
	 4. 参数列表: 两个参数 int weight,int height 
	 5. 返回值: int 类型的zhouchang
	 6. 大括号: 通过给提供的长和宽的参数,进行计算	
	*/
	public static int getArea(int weight,int height){
		int zhouchang = (weight + height)*2;
		return zhouchang;
	}
}

方法的调用

调用方法：Java类文件中,JVM虚拟机,将class文件放入内存中,类文件要运行,执行功能,JVM,只主动的调用main方法(main方法做为程序的唯一执行入口)

举例: Scanner 键盘输入,使用了两个方法 nextInt() ; next();

说明:

  1. main方法,由JVM主动调用的,因此运行类的时候,运行main方法,main方法从上到下的顺序执行
  2. 除了main方法外,其余的方法,不会主动的进行运行
  3. 方法的调用,需要在main中进行调用也可以在其他方法中调用(后面讲解)
  4. 定义时,参数”数据类型 变量名”的形式(形式参数)
    调用时,所传递的参数必须与定义时参数类型一致,参数顺序一致
    调用时,给的值都是实际值(实际参数)
  5. 同一个类中,方法可以直接通过方法名调用

方法调用的注意事项:

  1. 方法一定要定义在类的内部
  2. 1个方法中不能再定义另外一个方法,但是可以调用方法
  3. 方法执行结束有两种情况:
    1) 执行到return 语句 2) 整个方法的内容都执行完毕
    因此,方法中,return后面的语句不会被执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Function1
{
	public static void main(String[] args) 
	{
		// 2. 调用方法,在同一个类中,可以直接写方法名进行调用(方法的调用处)
		int lang = getArea(3,5);// 参数是实际参数
		System.out.println("周长为"+lang);
	}

	/* 1. 定义一个方法:需求: 求长方形的周长

	 修饰符 返回值类型 方法名(参数列表){
		功能逻辑;
     }	
	*/
	public static int getArea(int weight,int height){// 形式参数
		int zhouchang = (weight + height)*2;
		System.out.println(zhouchang);
		return zhouchang;
	}
}
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
// 方法在其他方法中的调用
// 方法的互相调用
public class Function2 
{
	public static void main(String[] args) 
	{
		getSum1();
	}

	public static void getSum(int x, int y){// 方法定义时的参数是形式参数
		System.out.println(x+y);
	
	}
	public static int getSub(int x,int y){
	    return x-y;
	}

	// 定义一个方法,在其他方法(不是main方法)中调用
	public static void getSum1(){
	    getSum(9,10); // 方法调用时参数是实际参数
		//方法getSub有返回值类型,是int类型,那么方法调用时,可以用int类型接值,也可以不接值
		int z = getSub(3,5);
		System.out.println(z);
	}
}

方法在内存中的运行方式 // 栈内存 ⭐⭐⭐

方法重载 ⭐⭐⭐

方法重载的概念

重载: 指在同一个类中,方法名相同,但是方法的参数列表不同,这种情况,称为方法的重载
举例:
Random类: 生成随机数,
nextInt(); 随机整数,整个int类型的范围
nextInt(5); 随机的整数,[0-5),实际上0-4
上述两个nextInt() 方法就是方法的重载

方法重载的形式

方法重载(Overload):

  1. 方法的重载,必须发生在同一个类中的相同的方法名
  2. 要求参数列表不同(以下三个满足任何一个就属于方法重载)
    1) 参数个数不同
2) 参数类型不同 
3) 不同参数间的排列顺序不同
  3. 方法重载,与方法的返回值类型无关
  4. 如果同一个类中,方法名相同,参数列表相同,报错,属于方法的重复定义

//其实还是比较容易理解的，就是一个方法中，如果我获取得参数不完全一样就是重载。

说明:JVM在进行方法的调用时,根据方法名以及参数列表来区分调用哪个方法

在代码中体现下：

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
//不同参数个数的方法重载代码
public class  FunctionOverload
{
	public static void main(String[] args) 
	{
		int z = getSum(6);
		System.out.println(z);
		int z1 = getSum(3,9);
		System.out.println(z1);
		
	}
    /*
方法的重载, 参数个数不同
    两个getSum方法,一个参数为int类型,
一个参数为int,int类型,实现了方法的重载
*/
	public static int getSum(int x){
		return x;
	}

	public static int getSum(int x,int y){

		return x+y;
 		// System.out.println(x+y);// 错误代码: 无法访问的语句(这句话,永远不会被执行到),因为方法中遇到return ,整个方法结束,return 后面的语句就不执行了(类似continue,break)
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//参数类型不同的方法重载(方法重载与方法的返回值类型无关)
// 方法一定要定义在类的内部
public class  FunctionOverload1
{
	public static void main(String[] args) 
	{
		int z = getSum(6);
		System.out.println(z);
		double z1 = getSum(3.0);
		System.out.println(z1);	
	}

/*
方法的重载, 参数类型不同
    两个getSum方法,1个参数为int类型,一个方法为double类型,实现了方法的重载
    方法重载与返回值类型无关
*/
	public static int getSum(int x){
		return x; 
	}
	public static double getSum(double x){
		return x*2;
	}
}
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
//不同类型参数间的排列顺序不同重载
// 方法一定要定义在类的内部
public class  FunctionOverload2
{
	public static void main(String[] args) 
	{
		double z = getSum(6,2.0);
		System.out.println(z);
		double z1 = getSum(3.0,5);
		System.out.println(z1);	
	}
/*
方法的重载, 不同类型参数间排列顺序不同
两个getSum方法,一个参数为int,double类型,
一个方法为double,int类型,实现了方法的重载
*/
	public static double getSum(int x, double y){
		return x+y;
	}

	/*
      // 参数名字,不是重载的条件
public static double getSum(int y, double x){  // 错误代码: 原因,方法重复定义

		return x*2;
	}*/
     public static double getSum( double y, int x){  // 错误代码: 原因,方法重复定义
		return (x+y)*2;
   }
}

晚安

 今天就到这里了，明天见，加油！

-------------本文结束感谢您的阅读-------------
0%