认识Java中的方法

最新推荐文章于 2024-06-20 20:20:21 发布

炭烤玛卡巴卡

最新推荐文章于 2024-06-20 20:20:21 发布

阅读量938

点赞数 17

文章标签： java 开发语言学习

本文链接：https://blog.csdn.net/m0_71513446/article/details/139804983

版权

方法

什么是方法

方法是程序中最小的执行单元

使用场景：重复的代码、具有独立功能的代码可以抽取到方法中

好处:

提高代码的复用性。
提高代码的可维护性。

方法的格式

方法定义

把一些代码打包在一起，该过程称为方法定义。

定义格式

public static 返回值类型 方法名(参数){
	方法体;
	return 返回值;
}

最简单的方法定义和调用

1718713797471

1718713846531

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);
    }
}

带参数的方法定义和调用方法

1718715089630

1718715126410

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);
    }
}

带返回值方法的定义和调用方法

使用场景：

在调用处要根据方法的结果，去编写另外一段代码。

格式：

1718715811478

调用

1718715891666

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;
    }
}

方法的内存

方法传递基本数据类型的内存原理

基本数据类型和引用数据类型

1718763878747

传递基本数据类型是，传递的是真实的数据，形参的改变，不影响实际参数的值。

方法传递引用数据类型的内存原理

传递引用数据类型是，传递的是地址值，形参的改变，影响实际参数的值。

1718764238651

炭烤玛卡巴卡

关注

17
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
认识Java中的方法

方法是程序中最小的执行单元使用场景：重复的代码、具有独立功能的代码可以抽取到方法中提高代码的复用性。提高代码的可维护性。把一些代码打包在一起，该过程称为方法定义。public static 返回值类型方法名(参数){方法体;return 返回值;// 掌握最简单的方法定义和调用的格式// 调用方法playGame();// 定义一个方法// 掌握带参数的方法定义和调用的格式// 调用方法// 定义一个方法在调用处要根据方法的结果，去编写另外一段代码。
复制链接

扫一扫