【JavaSE 04】方法

程序媛Alina

已于 2023-10-15 03:45:10 修改

阅读量75

点赞数 1

文章标签： java

于 2023-10-15 03:44:09 首次发布

本文链接：https://blog.csdn.net/qq_29011229/article/details/133834963

版权

1. 方法概述

方法（method）就是一段具有独立功能的代码块，不调用就不执行

好处: 方法的出现，可以提高代码的复用性

能提高运行效率吗? 答：不能

方法使用前提须知：

方法必须先创建才可以使用，该过程称为方法定义
方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法调用（方法不调用就不执行）

2. 方法的定义和调用

 ⚫ 方法定义
     public static void 方法名 ( ) { 
 //方法体 
 }
 
 ⚫ 方法调用
     方法名 ( ) ;

注意：

方法必须先定义后调用，否则程序将报错。
方法与方法之间是平级关系，不能嵌套

方法调用过程：

方法没有被调用的时候，都在方法区中的字节码文件(.class)中存储

方法被调用的时候，需要进入到栈内存中运行（类似于压入的子弹，先进后出）

3. 形参和实参

形参：全称形式参数，是指方法定义中的参数

实参：全称实际参数，方法调用中的参数

有参方法的好处: 让程序更加灵活也更符合开发场景

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

我们经常会根据一个方法产出的结果，来去组织另外一段代码逻辑为了拿到这个方法产生的结果，就需要定义带有返回值的方法。

需要使用方法产出的结果进行后续运算时候需要定义方法为由返回值的方法前端需要一个返回值进行结果的包装。

◆ 方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写如果要编写return，后面不能跟具体的数据。

◆ return语句下面，不能编写代码，因为永远执行不到，属于无效的代码

5. 方法的通用格式

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

◆ 返回值类型：方法操作完毕之后返回的结果数据，所对应的数据类型如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return

◆ 方法名：调用方法时候使用的标识

◆ 参数：由数据类型和变量名组成，多个参数之间用逗号隔开（理解：方法运行之前所需要的材料）

◆ 方法体：完成功能的代码块

◆ return：如果方法操作完毕，有数据返回，用于把数据返回给调用者

◆ 定义方法时，要做到两个明确

明确参数：主要是明确参数的类型和数量

明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，

如果没有，写void；

如果有，写对应的数据类型

◆ 调用方法时

void类型的方法，直接调用即可

非void类型的方法，推荐用变量接收调用

6. 方法重载

同一个类中，方法名相同，参数不同的方法构成重载关系

参数不同的定义：个数不同、类型不同、顺序不同（与返回值类型无关and参数名无关)

注意：识别方法之间是否是重载关系，只看方法名和参数，跟返回值无关。

方法重载的好处：不用记忆过多繁琐的方法名字

7. 方法参数传递

（1）基本数据类型参数传递

基本数据类型作用域范围为对应的方法方法存在的时候可以在内部被访问出栈访问不到

对于基本数据类型的参数，形式参数的改变，不影响实际参数的值

（2）引用数据类型参数传递

引用数据类型引用的是堆内存中的地址修改堆内存中的地址 arr[1] = 200; 其他变量再去访问拿到的是修改后的值 arr[1]

对于引用类型的参数，形式参数的改变，影响实际参数的值

 public class demo9 {
     public static void main(String[] args) {
         int[] arr = {10, 20, 30};
         System.out.println("调用change方法前：" + arr[1]);
         change(arr);
       ///  arr = null;
         System.out.println("调用change方法后：" + arr[1]);
     }
 
     public static void change(int[] arr) {
         arr[1] = 200;
 
     }
 }

8. 例题

⚫定义方法完成打印十遍HelloWorld

  public class demo4 {
     public static void main(String[] args) {
         int num = 10;
         print(num);
     }
     public static void print(int num) {
         for (int i = 0; i < num ; i++) {
             System.out.println("HelloWorld");
         }
     }
 }

⚫定义一个方法，该方法可以求数组的平均值，具体的数组是方法调用时传入

 public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66};
        System.out.println(method(arr));
 }
     public static double method(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
          sum+=arr[i];
       }
        double average = sum* 1.0 / arr.length;
          return average;
    }
 }

⚫定义一个方法，该方法可以求任意一个三位数的各个位数的立方和。

  public class demo1 {
     public static void main(String[] args) {
         System.out.println("请输入一个三位数：");
         Scanner sc = new Scanner(System.in);
         int a = sc.nextInt();
         System.out.println(method(a));
     }
     public static int method(int a) {
          int ge = a % 10;
          int shi = a /10 % 10;
          int bai = a / 100;
          int sum = ge*ge*ge+shi*shi*shi+bai*bai*bai;
          return sum;
     }
 }

⚫定义一个方法，该方法可以求1~n的和。n的值是方法调用时键盘录入。

 public class demo {
     public static void main(String[] args) {
         System.out.println("请定义整数n的值：");
         Scanner sc= new Scanner(System.in);
         int n = sc.nextInt();
         System.out.println(methodAdd(n));
     }
 
     public static int methodAdd (int n) {
         int sum = 0;
         for (int i = 1; i <= n; i++) {
             sum += i;
         }
         return sum;
     }
 }

⚫定义一个方法,能够完成对比较三个数的最大值,并将最大值打印,三个数要求使用键盘录入

解法1：

 public class demo {
     public static void main(String[] args) {
         int[] arr= new int[3];
         for (int i = 0; i <3 ; i++) {
             System.out.println("请输入第"+(i+1)+"个数：");
             Scanner sc= new Scanner(System.in);
             arr[i] = sc.nextInt();
         }
         System.out.println(max(arr));
     }
     public static int max(int[] arr) {
             int better = arr[0] > arr[1] ? arr[0] : arr[1];
             int best = better > arr[2] ? better : arr[2];
             return best;
     }
 }

解法2：

public class demo {
    public static void main(String[] args) {
        int[] arr = new int[3];
        Scanner sc=new Scanner(System.in);
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第"+(i+1)+"个整数：");
            arr[i]= sc.nextInt();
        }
        System.out.println("最大值为："+Max(arr));
    }
    public static int Max(int[]arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>max){
                max=arr[i];
            }
        }
        return max;
    }
}

⚫设计一个方法用于获取数组中元素的最大值和最小值，将最大值和最小值返回。

int[ ]arr={11,34,223,22,66,123};

public class demo7 {
    public static void main(String[] args) {
      int[]arr={11,34,223,22,66,123};

      int[] arr1= show(arr);
        System.out.println("最小值为："+ arr1[0]);
        System.out.println("最大值为："+ arr1[1]);
    }

    public static int[] show (int[] arr) {
//假设数组第一个值为最大值
        int max = arr[0];
        int min = arr[0];

//求最大值
        for (int i = 0; i < arr.length; i++) {
            if(max<arr[i]){
                max=arr[i];
            }
        }
//求最小值
        for (int i = 0; i < arr.length; i++) {
            if(min>arr[i]){
               min=arr[i];
            }
        }
        int[]newArr = new int[2];
        newArr[0]=min;
        newArr[1]=max;
// return把方法内的值输出去。        
        return newArr;
        }
    }

⚫设计一个方法用于账户密码的校验。假设用户名为123，密码为123456。

package com.itheima.practice;
import java.util.Scanner;

public class demo {
    public static void main(String[] args) {
    
   while(true){
        System.out.println("请输入用户名：");
        Scanner sc1 = new Scanner(System.in);
        int username = sc1.nextInt();
        System.out.println("请输入密码：");
        Scanner sc2 = new Scanner(System.in);
        int password = sc2.nextInt();
     //方法调用
        boolean flag = isFlag(username,password);
        if(flag){
            System.out.println("欢迎使用！");
            break;
        }else{
            System.out.println("账号或密码错误，请重新输入！");
        }
      }
    }
    //账户密码校验方法
    public static boolean isFlag(int username,int password) {
        boolean flag = false;
        if(username== 123 && password==123456){
            flag=true;
            return flag;
        }
         return flag;
    }
}

⚫定义一个方法，该方法可以判断两个数组是否完全一致（长度一致，内容一致，顺序一致，称之为完全一致。）

例如：{1,2,3} 和{1,2,3} 是完全一致的。{1,2,3} 和{3,2,1} 不是完全一致的

public class Demo {
  public static void main(String[] args) {
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {3, 2, 1};
        System.out.println(isSame(arr1, arr2));
    }

    public static boolean isSame(int[] arr1, int[] arr2) {
        //默认flag为false，只有满足条件才true，不满足条件的其他所有情况都是false
        boolean flag = false;
        //如果两个数组长度相等再进入下一个操作，否则返回false
        if (arr1.length == arr2.length) {
            for (int i = 0; i < arr1.length; i++) {
                //如果遍历到数组的最后一个元素也都相等就返回true
                if (arr1[i] == arr2[i] ) {
                    flag = true;
                    break;
                }
            }
        }
        return flag;
    }
}

⚫定义一个方法可以随机产生15-30之内的数，将这些数放在长度为10的数组里

public class demo8 {
    public static void main(String[] args) {
        int[]arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i]= getRandom();
            System.out.print(arr[i]+" ");
        }
    }

    public static int getRandom() {
        Random r = new Random();
        int num = r.nextInt(16)+15;
        return num;
    }
}

⚫随机产生10个不同的数(15-30),放在长度为10的数组里。

解法一：

import java.util.Random;

public class Demo1 {
    public static void main(String[] args) {
        Random r = new Random();
        int[] arr = new int[10];

        //循环存储
        for (int i = 0; i < arr.length; i++) {
            //生成随机数
            int num = r.nextInt(16) + 15;
            //调用一个比较的方法
            boolean flag = method(arr, num);

            //true 不重复直接赋值
            if (flag){
                arr[i] = num;
            }
            //false 代表重复
            else {
                i--;
            }
        }

        //遍历集合
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    //判断元素是否已经存在与数组之中
    private static boolean method(int[] arr, int num) {
        //假设不存在
        boolean flag = true;

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num){
                flag = false;
            }
        }

        return flag;
    }
}

解法二：

public class Demo2 {
    public static void main(String[] args) {
        Random r = new Random();
        int[] arr = new int[10];

        for (int i = 0; i < arr.length; i++) {
            //生成随机数
            int num = r.nextInt(16) + 15;
            arr[i] = num;

            //只需要跟前面的元素进行比较
            for (int j = 0; j < i; j++) {
                if (arr[j] == num){
                    i--;
                }
            }
        }

        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}