Java基础语法——方法

小咪咪 2024-03-27 09:31 70阅读 0赞

**目录**

方法概述

方法定义及格式

方法重载

•方法重载概述

•方法重载特点

方法中基本数据类型和引用数据类型的传递

### 方法概述 ###

——假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个\{\}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可。

### 方法定义及格式 ###

•简单的说：方法就是完成特定功能的代码块

–在很多语言里面都有函数的定义

–函数在Java中被称为方法

•格式：

–修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) \{

函数体;

return 返回值;

**方法格式解释**

–**修饰符 目前记住 public static**

–**返回值类型 用于限定返回值的数据类型(return)**

–方法名 一个名字，为了方便我们调用方法

–参数类型 用于限定调用方法时传入的数据的类型

–参数名 用于接收调用方法时传入的数据的变量

–方法体 完成功能的代码

–return 结束方法，把返回值带给调用者

**方法案例**

•写一个方法首先有两点需要明确

–返回值类型 明确功能结果的数据类型

–参数列表 明确有几个参数，以及参数的类型

•按照格式和两个明确来完成如下功能

–求两个数据之和的案例

package com.demo01;
    
    import java.util.Scanner;
    
    public class MethodDemo {
    	public static void main(String[] args) {
    		Scanner Sc = new Scanner(System.in);
    		System.out.println("请输入第一个数据：");
    		int i = Sc.nextInt();
    		System.out.println("请输入第二个数据：");
    		int j = Sc.nextInt();
    		System.out.println("两个数据之和为：");
    		int d = sum(i,j);
    		System.out.println(d);
    	}
    	
    	/*
    	 * 两个明确
    	 * 		返回值类型：int
    	 * 		参数列表：int a,int b
    	 */
    	public static int sum(int a,int b) {
    		int c = a + b;
    		
    		return c;
    	}
    }

![ec9cbb28ee4c40b2bd3a1c8c45dfadd4.png][]

•有明确返回值的方法调用：

–单独调用，没有意义

–输出调用，有意义，但是不够好，因为我不一定非要把结果输出

**–赋值调用，推荐方式 int d = sum(1,2)**

**有明确返回值的方法练习:**

1.  键盘录入两个数据，返回两个数中的较大值
2.  键盘录入两个数据，比较两个数是否相等
3.  键盘录入三个数据，返回三个数中的最大值

**练习1：键盘录入两个数据，返回两个数中的较大值**

package com.demo01;
    
    import java.util.Scanner;
    
    public class MethodDemo {
    	public static void main(String[] args) {
    		Scanner Sc = new Scanner(System.in);
    		System.out.println("请输入第一个数据：");
    		int i = Sc.nextInt();
    		System.out.println("请输入第二个数据：");
    		int j = Sc.nextInt();
    		System.out.println("输出两个数据最大值为：");
    		int d = max(i,j);
    		System.out.println(d);
    	}
    	
    	/*
    	 * 两个明确
    	 * 		返回值类型：int
    	 * 		参数列表：int a,int b
    	 */
    	public static int max(int a,int b) {
    		if(a>b) {
    			int c = a;
    			return c;
    		}
    		else {
    			int c = b;
    			return c;
    		}
    		
    	}
    }

![f55a343a514943fdb6031db66d10efa9.png][]

**练习2： 键盘录入两个数据，比较两个数是否相等**

package com.demo01;
    
    import java.util.Scanner;
    
    public class MethodDemo {
    	public static void main(String[] args) {
    		Scanner Sc = new Scanner(System.in);
    		System.out.println("请输入第一个数据：");
    		int i = Sc.nextInt();
    		System.out.println("请输入第二个数据：");
    		int j = Sc.nextInt();
    		System.out.println("输出为：");
    		boolean d = bijiao(i,j);
    		System.out.println(d);
    	}
    	
    	/*
    	 * 两个明确
    	 * 		返回值类型：int
    	 * 		参数列表：int a,int b
    	 */
    	public static boolean bijiao(int a,int b) {
    		if(a==b) {
    			return true;
    		}
    		else {
    			return false;
    		}
    		
    	}
    }

![11d1b835fec5449ebee1423c07059fcd.png][]

**练习3： 键盘录入三个数据，返回三个数中的最大值**

package com.demo01;
    
    import java.util.Scanner;
    
    public class MethodDemo {
    	public static void main(String[] args) {
    		Scanner Sc = new Scanner(System.in);
    		System.out.println("请输入第一个数据：");
    		int i = Sc.nextInt();
    		System.out.println("请输入第二个数据：");
    		int j = Sc.nextInt();
    		System.out.println("请输入第三个数据：");
    		int k = Sc.nextInt();
    		System.out.println("输出最大值为：");
    		int d = getMax(i,j,k);
    		System.out.println(d);
    	}
    	
    	/*
    	 * 两个明确
    	 * 		返回值类型：int
    	 * 		参数列表：int a,int b
    	 */
    	public static int getMax(int a,int b,int c) {
    		if(a > b) {
    			if(a > c) {
    				return a;
    			}else {
    				return c;
    			}
    		}else {
    			if(b > c) {
    				return b;
    			}else {
    				return c;
    			}
    		}
    	}
    }

![fd8c623cfb9c4311a11c8e2f138ab7dc.png][]

**没有明确返回值的方法定义和调用**

写一个方法，在控制台输出10次HelloWorld案例。

没有明确返回值的函数调用：

–其实就是void类型方法的调用

–只能单独调用

**没有明确返回值的方法练习**

1.  写一个方法，传递一个整数(大于1)，在控制台打印1到该数据的值。
2.  写一个方法，把所有的水仙花数打印在控制台

**练习1：写一个方法，传递一个整数(大于1)，在控制台打印1到该数据的值。**

package com.demo02;
    
    import java.util.Scanner;
    
    
    public class MethodTest {
    	public static void main(String[] args) {
    		System.out.println("请输入一个整数：");
    		Scanner Sc = new Scanner(System.in);
    		int i = Sc.nextInt();
    
    		printNumber(i);
    	}
    	
    
    	public static void printNumber(int n) {
    		for(int x=1; x<=n; x++) {
    			System.out.println(x);
    		}
    	}
    }

![393327fb706748ab96142c82d197605a.png][]

**练习2：写一个方法，把所有的水仙花数打印在控制台**

package com.demo02;
    public class MethodTest2 {
    	public static void main(String[] args) {
    			printFlower();
    	}
    	
    
    	public static void printFlower() {
    		for(int x=100; x<=999; x++) {
    			int ge = x%10;
    			int shi = x/10%10;
    			int bai = x/10/10%10;
    			
    			if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
    				System.out.println(x);
    			}
    		}
    	}
    }

![e0b69ddc6024475f8caf09ffd57c5d1f.png][]

### 方法重载 ###

#### •方法重载概述 ####

–在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

#### •方法重载特点 ####

–与返回值类型无关，只看方法名和参数列表

–在调用时，虚拟机通过参数列表的不同来区分同名方法

**方法重载练习：比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试**

package com.demo03;
    /*
    比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试
    
     */
    public class MethodTest {
    	public static void main(String[] args) {
    		System.out.println(compare(10, 20));
    		
    		System.out.println(compare((byte)10, (byte)20));
    		
    		System.out.println(compare((short)10, (short)20));
    		
    		System.out.println(compare(10L, 20L));
    	}
    	
    	//byte
    	public static boolean compare(byte a,byte b) {
    		System.out.println("*******************");
    		System.out.println("byte");
    		return a == b;
    	}
    	
    	//short
    	public static boolean compare(short a,short b) {
    		System.out.println("*******************");
    		System.out.println("short");
    		return a == b;
    	}
    	
    	//int
    	public static boolean compare(int a,int b) {
    		System.out.println("*******************");
    		System.out.println("int");
    		return a == b;
    	}
    	
    	//long
    	public static boolean compare(long a,long b) {
    		System.out.println("*******************");
    		System.out.println("long");
    		return a == b;
    	}
    }

![43276cc3fa954443a95bc2f404a57d5e.png][]

**方法重载练习：不同浮点型数据类型和整型数据类型求和**

package com.demo03;
    
    public class MethodDemo {
    	public static void main(String[] args) {
    		float c = sum(1.2f,2.3f);
    		System.out.println(c);
    		int d = sum(1,2,3);
    		System.out.println(d);
    		int f = sum(1,2);
    		System.out.println(f);
    	}
    	
    
    	
    	public static float sum(float a,float b) {
    		return a + b;
    	}
    	
    
    	public static int sum(int a,int b,int c) {
    		return a + b + c;
    	}
    	
    
    	public static int sum(int a,int b) {
    	
    		return a + b;
    	}
    }

![08c7e48db927447c9fe08b6d29670676.png][]

### 方法中基本数据类型和引用数据类型的传递 ###

看程序写结果，并总结基本类型和引用类型参数的传递问题(代码在备注部分)

什么是基本数据类型？像我们简单的int char short等数据类型。

什么是引用数据类型？引用数据类型是传递的地址

形参和实参的理解？形式参数：用于接收实际参数的变量。实际参数：实际参与运算的变量。

package com.demo04;
    
    
    public class ArgsDemo {
    	public static void main(String[] args) {
    		int a = 10;
    		int b = 20;
    		System.out.println("a:"+a+",b:"+b);//a:10,b:20
    		change(a,b);
    		System.out.println("a:"+a+",b:"+b);//??? a:10,b:20
    
    	}
    
    	public static void change(int a,int b) {//a=10,b=20
    		System.out.println("a:"+a+",b:"+b);//a:10,b:20
    		a = b;//a=20
    		b = a + b;//b=40
    		System.out.println("a:"+a+",b:"+b);//a:20,b:40
    	}
    
    }

![ca5a0196add5415984db093e795319e4.png][]

如果参数是引用数据类型——形式参数的改变直接影响实际参数，引用数据类型传递过去的是一个地址。

package com.demo04;
    
    /*
     * 如果参数是引用数据类型
     * 		形式参数的改变，直接会影响实际参数
     */
    public class ArgsDemo2 {
    	public static void main(String[] args) {
    		int[] arr = { 1, 2, 3, 4, 5 };
    		for (int x = 0; x < arr.length; x++) {
    			System.out.println(arr[x]);
    		}
    		System.out.println("-------------------------");
    		change(arr);
    		for (int x = 0; x < arr.length; x++) {
    			System.out.println(arr[x]);
    		}
    	}
    
    	public static void change(int[] arr) {
    		for (int x = 0; x < arr.length; x++) {
    			if (arr[x] % 2 == 0) {
    				arr[x] *= 2;
    			}
    		}
    	}
    
    }

![15158c674a7449c68b52554446777e0b.png][]

**方法的练习：**

1.  把遍历数组改进为方法实现，并调用方法
2.  把获取数组最值改进为方法实现，并调用方法
3.  写一个方法，用于对数组进行求和，并调用方法。

练习1：把遍历数组改进为方法实现，并调用方法

package com.demo05;
    /*
     * 把遍历数组改进为方法实现，并调用方法
     */
    public class MethodTest {
    	public static void main(String[] args) {
    
    		int[] arr = {11,22,33,44,55};
    		
    
    		printArray(arr);
    	}
    	
    
    	
    	public static void printArray(int[] arr) {
    		System.out.print("[");
    		for(int x=0; x<arr.length; x++) {
    			if(x==arr.length-1) {
    				System.out.println(arr[x]+"]");
    			}else {
    				System.out.print(arr[x]+", ");
    			}
    		}
    	}
    }

![825fac391bf34cf29608afb4c9d1d9a1.png][]

练习2： 把获取数组最值改进为方法实现，并调用方法

package com.demo05;
    /*
     * 把遍历数组改进为方法实现，并调用方法
     */
    public class MethodTest {
    	public static void main(String[] args) {
    
    		int[] arr = {11,22,33,44,55};
    		
    
    		printArray(arr);
    	}
    	
    
    	
    	public static void printArray(int[] arr) {
    		int max = arr[0];
    		for(int x=1; x<arr.length; x++) {
    			if(max<arr[x]) {
    				max = arr[x];
    			}
    			
    		}
    		System.out.println(max);
    	}
    }

**练习3：写一个方法，用于对数组进行求和，并调用方法。**

package com.demo05;
    /*
     * 把遍历数组改进为方法实现，并调用方法
     */
    public class MethodTest {
    	public static void main(String[] args) {
    
    		int[] arr = {1,2,3,4,5};
    		
    
    		printArray(arr);
    	}
    	
    
    	
    	public static void printArray(int[] arr) {
    		int sum = 0;
    		for(int x=0; x<arr.length; x++) {
    			sum += arr[x];
    			
    		}
    		System.out.println(sum);
    	}
    }

![a5c1221c8e194ff68daf3a3c45621c25.png][]

[ec9cbb28ee4c40b2bd3a1c8c45dfadd4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/a9d22bc5bc3b4231864d3075c0ccc2e7.png
[f55a343a514943fdb6031db66d10efa9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/5f150a01775649cea6ba183c37a2ba76.png
[11d1b835fec5449ebee1423c07059fcd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/9eca6fe148ee451496a868fc1bb5a36d.png
[fd8c623cfb9c4311a11c8e2f138ab7dc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/5caee36fafe546f6947e7e257ffa7f57.png
[393327fb706748ab96142c82d197605a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/a6a75c21b70e4be2b5d068834d992396.png
[e0b69ddc6024475f8caf09ffd57c5d1f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/26159f0ef26140ba83c8c004230badc2.png
[43276cc3fa954443a95bc2f404a57d5e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/141260bdb3704f4cb5d4897dbd5762af.png
[08c7e48db927447c9fe08b6d29670676.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/cdb05d2f54cd4f1e88b210383644cae2.png
[ca5a0196add5415984db093e795319e4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/9e2b1f485188417ca910f3bf95395bee.png
[15158c674a7449c68b52554446777e0b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/be7229b3fe464e2eac1ba2540da95873.png
[825fac391bf34cf29608afb4c9d1d9a1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/7e3747cf992440abbc1ae2c1c6af7533.png
[a5c1221c8e194ff68daf3a3c45621c25.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/d6f184fa17bc4571b0344d5512d4e5da.png