【java0基础】关于方法

【java0基础】关于方法

什么是方法?

• 方法 是将独立功能的 代码块  组织成一个整体,使其具有特殊的功能代码集
• 方法必须先创建才能使用,该过程称为 方法定义
• 方法创建后不能直接运行,需要手动使用后才执行,该过程称为 方法调用

方法定义

public static void 方法名(){
//方法体
}

方法调用

public class Methond{
    public static void main(String[] args) {
        //调用方法
        isEvenNumber();
    }
    public static void isEvenNumber(){
        //定义变量
        int m =10;
        m=9;
        if (m%2==0){
            System.out.println(true);
        }else{
            System.out.println(false);
        }
    }
}

• 方法需要先定义后调用
• 方法调用过程,从上往下执行

带参方法定义

public static void 方法名(参数){---}//参数可以一个 也可以多个

public static void 方法名(数据类型 变量名){---}
public static void 方法名(数据类型 变量名1,数据类型,变量名2){----}

• 方法定义时,参数中 数据类型 与 变量名 都不能缺少,缺少任意一个将报错
• 方法的定义时,多个参数之间使用(,)分隔

调用

• 调用方法,和无参数数的类似 格式: 方法名(参数)
• 调用时, 参数数量与类型 必须与方法定义中的设置匹配,否则报错

public class Method {
    public static void main(String[] args) {
        //常量调用
        isEvenNumber(9);
        
        //变量调用
        int number =10;
        isEvenNumber(number);
    }
    public static void isEvenNumber(int number){
        if (number%2==0){
            System.out.println(true);
        }else{
            System.out.println(false);
        }
    }
}

行参和实参

参数是定义方法时规定该方法运行所需要使用的变量,调用方法时也需要使用一个变量.

• 行参 :方法定义中的参数 int number
• 实参 :方法调用中的参数 number 实际传入的常量值(变量名)

public class MethodTest {
    public static void main(String[] args) {
        getMax(5, 10);

        int a = 10;
        int b = 20;
        getMax(a,b);
    }
    public static void getMax(int a, int b) {
        if (a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

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

• 定义格式  : public static 数据类型 方法名(参数){

  return 数据 ;
  }

• 方法定义时return后面的返回值与方法定义上的数据类型要匹配,否则报错

• 带返回值方法调用

数据类型 变量名 = 方法名(参数)
示例:boolean flag = isEvenNumber(5)

• 方法的返回值通常使用变量接受,否则该返回值将无意义

public class MethodTest1 {
    public static void main(String[] args) {
       boolean a = getNumber( 10);
        System.out.println(a);
    }
    //需求，定义一个方法，该方法接受一个参数，判断该数据是否是偶数，并返回真假值
    public static boolean getNumber(int number){
        if(number%2==0){
          return true;
        }else{
            return  false;
        }
    }
}

方法的注意事项

• 方法中不能嵌套定义,也就是不能在方法里面再加方法
• void 无返回值,可以省略return,也可以单独的书写return,后面不加数据

方法通用格式

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

• 定义方法时,明确返回值类型,数据类型有返回值,没有返回值类型用void
• void类型方法,直接调用即可,非void类型方法,推荐用变量接受调用

方法重载

概述

同一个类中定义多个方法之间的关系,满足下列条件的多个方法相互构成重载

• 多个方法在一个类中
• 多个方法具有相同的方法名
• 多个方法的参数不同,类型不同或者数量不同

重载特点

• 重载仅对应方法的定义, 与方法的调用无关 (调用时,Java虚拟机会通过参数的不同,来区分同名的方法),调用方式参照标准格式
• 重载仅针对同一个类中方法的名称和参数进行识别,与返回值无关,也就是不能通过返回值来判断两个方法是否构成重载

public class MethodTest1 {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(10.0,20.0));
        System.out.println(sum(1,2,3));

    }
    //需求，求两个int类型数据和方法
    public static int sum(int a,int b){
        return a+b;
    }
    public static double sum(double a,double b){
        return a+b;
    }
    public static int sum(int a,int b,int c){
        return a+b+c;
    }
}

方法的参数传递

基本数据类型

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

public class MethodTest1 {
    public static void main(String[] args) {
        int a = 100;
        System.out.println("调用前：" + a);
        sum(a);
        System.out.println("调用后：" + a);
    }

    //需求，求两个int类型数据和方法
    public static void  sum(int a) {
        a = 200;
    }
}
//输出：100，100

引用数据类型

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

方法参数传递

数组的遍历

//需求：设计一个方法用于数组遍历，求遍历结果在一行上。例如【11，22，33，44】
public class MethodTest1 {
    public static void main(String[] args) {
        //定义一个数字，用静态初始化完成数组初始化
        int [] arr ={11,22,33,44};
       printArray(arr);
    }
    /**
    public static void printArray(int[] arr){
        for(int x =0;x<arr.length;x++){
            System.out.print(arr[x]);
        }
    }
     */
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            if(x==arr.length-1){
                System.out.print(arr[x]);
            }else {
                System.out.print(arr[x] + ", ");
            }
        }
        System.out.print("]");
    }

数组最大值

//需求：设计一个方法用于获取数组中元素的最大值，调用方法并输出结果

/**
 * 思路：
 * 1。定义一个数组，用静态初始化完成数组元素初始化
 * 2。定义一个方法，用来读取数组中最大值
 * 3。调用获取最大值方法
 * 4。输出在结果
 */
public class MethodTest1 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {11, 22, 33, 44};
        int m = getMax(arr);
        System.out.println(m);
    }
        //定义方法。两个明确 返回值类型 ，int
        //参数，int[] arr
        public static int getMax(int[] arr){
            int max =arr[0];
            for (int x=0;x<arr.length;x++){
                if (arr[x]>max){
                    max = arr[x];
                }
            }
            return max;
        }
}

练习

/**
 * 元素满足个位和十位都不是7，并且只是偶数
 * */
public class Test06 {
    public static void main(String[] args) {
        //定义一个数组，静态初始化完成数组元素初始化
        int[] arr ={68,27,95,88,171,996,51,210};

        //定义一个求和变量，初始值为0
        int sum = 0;

        //遍历数组，获取数组中每个元素
        for(int x=0;x<arr.length;x++){
            if (arr[x]%10!=7 &&arr[x]/10%10!=7&&arr[x]%2==0) {
                sum+=arr[x];
            }

        }
        System.out.println("sum:"+sum);
    }
}

//定义一个方法，用于比较两个数组内容是否相同
public class Test07 {
    public static void main(String[] args) {
        //定义两个数组，分别使用静态初始化完成数组元素初始化
        int[] arr1 = {11, 22, 33, 44, 55};
        int[] arr2 = {11, 22, 3, 44, 55};

        //方法调用
        boolean bl = compare(arr1,arr2);
        System.out.println(bl);
    }

    /**
     * 两个明确：
     * 返回值类型：boolean
     * 参数：int[] arr ，int[] arr2
    * */
    public static  boolean compare(int[] arr1, int[] arr2) {
        if (arr1.length != arr2.length) {
            return false;
        }
        for (int x = 0; x < arr1.length; x++) {
            if (arr1[x] != arr2[x]) {
                return false;
            }
        }

        //最后循环遍历结束，返回true；
        return true;
    }
}

import java.util.Scanner;

/*
 * 需求有一个数组arr={19,28,37,46,50};键盘录入一个数据，查找数据在数组中的索引，并在控制台上输出找到的索引值
 * 思路：1。定义数组，用静态初始化完成数组元素初始化
 *      2。键盘录入要查询数据，用一个变量接受
 *      3.定义一个索引变了，初始值为-1
 *      4.遍历数组，获取数组中每个元素
 *      5.那键盘录入数据和数组中每个元素比较，值相同，就把该值对于的索引值赋值给索引变量，结束循环
 *      6.输出索引变量
 */
public class test08 {
    public static void main(String[] args) {
        //定义数组，用静态初始化完成数组元素初始化
        int[] arr ={19,28,37,46,50};

        //键盘录入要查询数据，用一个变量接受
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入要查找的数据：");
        int number = sc.nextInt();
    /**
        //定义一个索引变了，初始值为-1
        int index =-1;

        //遍历数组，获取数组中每个元素
        for (int x=0;x<arr.length;x++){
        // 键盘录入数据和数组中每个元素比较，值相同，就把该值对于的索引值赋值给索引变量，结束循环
            if (arr[x]==number){
                index=x;
                break;
            }
        }

     */
        //调用方法：
        int index = getIndex(arr,number);
        //输出数据
        System.out.println("index:"+index);
    }
    //定义一个方法

    /**
     * 两个明确：
     *  返回值类型：int
     *  参数：int[] arr,int number;
     */
    public static  int getIndex(int[] arr,int number){
        //定义一个索引变了，初始值为-1
        int index =-1;

        //遍历数组，获取数组中每个元素
        for (int x=0;x<arr.length;x++){
            // 键盘录入数据和数组中每个元素比较，值相同，就把该值对于的索引值赋值给索引变量，结束循环
            if (arr[x]==number){
                index=x;
                break;
            }
        }
        return  index;
    }

    }

public class Test09 {
    public static void main(String[] args) {

        int[]  arr ={19,28,37,46,50};

        /**循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引

        for (int start=0,end=arr.length-1;start<=end;start++,end--){
            //变量交换
            int temp =arr[start];
            arr[start]=arr[end];
            arr[end]=temp;
        }*/
        //反转的方法
        reverse(arr);
        //遍历数组
        printArray(arr);
    }
    //定义方法：返回值类型：void 参数：int[] arr
    public static void reverse(int[] arr){
           // 循环遍历数组，这一次初始化语句定义两个索引变量，判断条件是开始索引小于等于结束索引
            for (int start = 0, end = arr.length - 1; start <= end; start++, end--) {
                //变量交换
                int temp = arr[start];
                arr[start] = arr[end];
                arr[end] = temp;
            }
        }
    public static void printArray(int[] arr){
        System.out.print("[");
        for (int x=0; x<arr.length;x++) {
            if (x == arr.length - 1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x] + ",");
            }
        }
        System.out.println("]");
    }
}