方法
文章目录
什么是方法
方法是程序中最小的执行单元
使用场景：重复的代码、具有独立功能的代码可以抽取到方法中
好处:
- 提高代码的复用性。
- 提高代码的可维护性。
方法的格式
方法定义
把一些代码打包在一起，该过程称为方法定义。
定义格式
public static 返回值类型 方法名(参数){
方法体;
return 返回值;
}
最简单的方法定义和调用
package com.example.demo;
public class Test {
public static void main(String[] args) {
// 掌握最简单的方法定义和调用的格式
// 调用方法
playGame();
}
// 定义一个方法
public static void playGame(){
System.out.println("A");
System.out.println("B");
System.out.println("C");
System.out.println("D");
System.out.println("E");
System.out.println("F");
System.out.println("G");
}
}
练习——人肉计算机
需求：在方法里面定义两个变量并求和打印
package com.example.demo;
public class Test {
public static void main(String[] args) {
// 掌握最简单的方法定义和调用的格式
// 调用方法
getSum();
}
// 定义一个方法
public static void getSum(){
int num1 = 10;
int num2 = 20;
int result = num1 + num2;
System.out.println(result);
}
}
带参数的方法定义和调用方法
package com.example.demo;
public class Test {
public static void main(String[] args) {
// 掌握带参数的方法定义和调用的格式
// 调用方法
getSum(10,20);
}
// 定义一个方法
public static void getSum(int num1,int num2){
int result = num1 + num2;
System.out.println(result);
}
}
形参和实参
形参：全称形式参数，是指方法定义中的参数
实参：全称实际参数，方法调用中的参数
练习——人肉计算机2
需求：定义一个方法，求圆的面积，将结果在方法中进行打印。
package com.example.demo;
public class Test {
public static void main(String[] args) {
// 掌握带参数的方法定义和调用的格式
// 调用方法
getArea(5);
}
// 定义一个方法
public static void getArea(int r){
double result = Math.PI*r*r;
System.out.println(result);
}
}
带返回值方法的定义和调用方法
使用场景：
在调用处要根据方法的结果，去编写另外一段代码。
格式：
调用
package com.example.demo;
public class Test {
public static void main(String[] args) {
// 掌握带参数的方法定义和调用的格式
// 调用方法
// 直接调用
getSum(5,100,200);
// 赋值调用
int sum =getSum(5,100,200);
System.out.println(sum);
// 输出调用
System.out.println(getSum(5,100,200));
}
// 定义一个方法
public static int getSum(int num1,int num2,int num3){
int result = num1 + num2 + num3;
return result;//返回给方法的调用出
}
}
练习——人肉计算机
需求：定义一个方法，求一家商场每个季度的营业额。根据方法结果再计算出全年营业额。
package com.example.demo;
public class Test {
public static void main(String[] args) {
// 掌握带参数的方法定义和调用的格式
// 调用方法
// 计算第一个季度营业额
int sum1 = getSum(10,20,30);
// 计算第二个季度营业额
int sum2 = getSum(10,20,30);
// 计算第三个季度营业额
int sum3 = getSum(10,20,30);
// 计算第四个季度的营业额
int sum4 = getSum(10,20,30);
// 计算全年营业额
int sum = sum1 + sum2 + sum3 + sum4;
System.out.println(sum);
}
// 定义一个方法
public static int getSum(int num1,int num2,int num3){
int result = num1 + num2 + num3;
return result;//返回给方法的调用出
}
}
注意事项
- 方法不调用就不执行。
- 方法与方法之间是平级关系，不能互相嵌套定义。
- 方法的编写顺序和执行顺序无关。
- 方法的返回值为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写。如果要编写return，后面不能跟具体的数据。
- return语句下面，不能编写代码，因为永远执行不到，属于无效的代码。
return关键字
- 方法没有返回值：可省略。如果书写，表示方法结束。
- 方法有返回值：必须要写。表示结束方法和返回结果。
方法调用
方法定义后并不是直接运行的，需要手动调用才能执行，该过程称为方法调用。调用时，实参要跟形参一一对应。
方法的重载
定义：
-
在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能。
-
每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载。
-
简单记：同一个类总，方法名相同，参数不同的方法。与返回值无关。
参数不同：个数不同、类型不同、顺序不同
java虚拟机通过参数的不同来区分同名的方法。
练习——方法重载
需求：使用方法重载的思想，设计比较两个整数是否相同的方法。
要求：兼容全整数类型（byte，short，int，long）
package com.example.demo;
public class Test {
public static void main(String[] args) {
getEqual(10,20);
}
// 定义一个方法
public static void getEqual(byte b1 , byte b2){
System.out.println("byte");
System.out.println(b1 == b2);
}
public static void getEqual(short b1 , short b2){
System.out.println("short");
System.out.println(b1 == b2);
}
public static void getEqual(int b1 , int b2){
System.out.println("int");
System.out.println(b1 == b2);
}
public static void getEqual(long b1 , long b2){
System.out.println("long");
System.out.println(b1 == b2);
}
}
练习——数组遍历
需求：设计一个方法用于遍历数组，要求遍历的结果是在一行上的。例如：[11,22,33,44,55]
package com.example.demo;
import org.springframework.aop.scope.ScopedProxyUtils;
public class Test {
public static void main(String[] args) {
// 定义一个数组
int [] array = {11,22,33,44,55};
// 调用遍历方法
getEvery(array);
}
// 定义一个方法
public static void getEvery(int [] array){
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if(i == array.length-1) {
System.out.print(array[i]);
}else {
System.out.print(array[i] + ",");
}
}
System.out.println("]");
}
}
练习——数组最大值
需求：设计一个方法求数组的最大值，并将最大值返回
package com.example.demo;
import org.springframework.aop.scope.ScopedProxyUtils;
public class Test {
public static void main(String[] args) {
// 定义一个数组
int [] array = {11,22,33,44,55};
// 调用遍历方法
System.out.println(getMax(array));
}
// 定义一个方法
public static int getMax(int [] array){
//定义一个临时最大值变量
int max = 0;
for (int i = 0; i < array.length; i++) {
if(array[i] > max) {
max = array[i] ;
}
}
return max;
}
}
练习——判断是否存在
需求：定义一个方法判断数组中的某一个数是否存在，将结果返回给调用处。
package com.example.demo;
import org.springframework.aop.scope.ScopedProxyUtils;
public class Test {
public static void main(String[] args) {
// 定义一个数组
int [] array = {11,22,33,44,55};
// 调用遍历方法
System.out.println(getMax(array,66));
}
// 定义一个方法
public static boolean getMax(int [] array,int number){
for (int i = 0; i < array.length; i++) {
if (number == array[i]){
return true;
}
}
return false;
}
}
return和break关键字的区别
return：跟循环没什么关系，跟方法有关系。表示结束方法和返回结果。
如果方法执行到return，那么整个方法全部结束，里面的循环也会随之结束。
break：跟方法没什么关系。表示结束循环或者switch。
练习——复制数组
需求:定义一个方法copyOfRange(int[] arr,int from,int to)
功能：将数组arr中从索引from（包含from）开始。到索引to结束（不包含to）的元素复制到新数组中，将新数组返回。
package com.example.demo;
import org.springframework.aop.scope.ScopedProxyUtils;
public class Test {
public static void main(String[] args) {
// 定义原始数组
int [] array = {11,22,33,44,55,66,77};
// 调用方法拷贝数据
int[] copyArr = copyOfRange(array, 2, 5);
// 遍历copyArr
for (int i = 0; i < copyArr.length; i++) {
System.out.println(copyArr[i] + " ");
}
}
// 定义一个方法
public static int [] copyOfRange(int [] array,int from,int to){
// 定义数组
int newArray[] = new int [to-from];
int index = 0;
for (int i = from; i < to; i++) {
newArray[index] = array[i];
index++;
}
return newArray;
}
}
方法的内存
方法传递基本数据类型的内存原理
基本数据类型和引用数据类型
传递基本数据类型是，传递的是真实的数据，形参的改变，不影响实际参数的值。
方法传递引用数据类型的内存原理
传递引用数据类型是，传递的是地址值，形参的改变，影响实际参数的值。
