5.方法

方法概述

1.什么是方法

方法(method) 是将具有独立功能的代码块组织成为一个整体,使其具有特殊功能的代码集.

注意:

• 方法先创建在使用,成为定义
• 方法创建后,需要调用才能使用

2.方法的定义和调用

定义方法的格式;

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

示例

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

    public static void isEvenNumber() {
        // 定义便令
        int number = 10;
        // 判断是否为偶数
        if (number % 2 == 0) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
    }
}

方法的调用格式:

格式：方法名;

示例：isEvenNumber();

方法定义调用示例

package function;

public class FunctionDemo {
    public static void main(String[] args) {
        // 调用方法
        isEvenNumber();
    }

    public static void isEvenNumber() {
        // 定义变量
        int number = 10;
        // 判断是否为偶数
        if (number % 2 == 0) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
    }
}

调用过程

案例:获取两个数字中的较大者

package function;

public class getMax {

    public static void main(String[] args) {
        getmax();
    }

    // 定义一个方法,输出两个数字较大的数
    public static void getmax() {
        // 定义两个变量a,b
        int a = 10;
        int b = 20;
        // 使用分支判断比较两个数字的大小
        if (a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

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

带参数的定义

格式

public static void 方法名(参数){...}

单个参数示例

public static void 方法名 (数据类型 变量名) {...}
public static void isEvenNumber (int number) {...}

多个参数示例

public static void 方法名 (数据类型 变量名1, 数据类型 变量名2, ...) {...}
public static void getMax (int number1, int number2) {...}

注意:

• 定义时,数据类型和变量名度不能缺少
• 多个参函数之间用逗号隔开

带参数方法的调用

格式

方法名(参数);

格式(单个参数)

方法名(变量名/常量值);
isEvenNumber(5);

格式(多个参数)

方法名(变量名1/常量值1, 变量名2/常量名2);
getMax(5, 6);

注意:

• 方法调用,参数的数量和类型必须与方法定义中设置相匹配,否则报错

示例

package function;

/*
    带参数方法的定义和调用
    定义格式:
        public static void 方法名(参数) {...}
    调用格式:
        方法名(参数)
 */

public class MethodDemo {
    public static void main(String[] args) {
        // 常量值的调用
        isEvenNumber(10);
        // 变量的调用
        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

实参: 方法中调用的参数, 等同于使用变量和常量, 例如10

带参数方法示例

package function;

/*
    带参数方法的定义和调用
    定义格式:
        public static void 方法名(参数) {...}
    调用格式:
        方法名(参数)
 */

public class getMax1 {
    public static void main(String[] args) {
        // 常量值的调用
        getMax(10, 20);
        // getMax(10.0, 20.0);  // 类型不符会报错
        // 变量的调用
        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);
        }
    }
}

4.带返回值方法的定义

带返回值方法的定义

格式

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

范例1

public static boolean 方法名(数据类型 参数) {
	return true;
}

范例2

public static int getMax(int a, int b) {
	return 100;
}

带返回值方法的调用

格式1

方法名(参数);
isEvenNumber(5);

格式2(推荐)

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

示例

package function;
/*
    带返回值方法定义和调用
 */

public class MethodReturnDemo {
    public static void main(String[] args) {
        // 1.方法名(参数)
        isEvenNumber(10);

        // 2.数据类型 变量名 = 方法名(参数)
        boolean flag = isEvenNumber(10);
        System.out.println(flag);
    }
    // 需求: 定义一个方法,接受参数,判断是否为偶数,返回真假
    public static boolean isEvenNumber(int number) {
        if (number%2 == 0) {
            return true;
        } else {
            return false;
        }
    }
}

5.方法注意事项

注意事项

1. 方法不能嵌套定义
2. void表示无返回值,可以省略return, 也可以单独写return, 后面不加数据

package function;
/*
    注意事项:
        1. 方法不能嵌套定义
        2. void表示无返回值,可以省略return, 也可以单独写return, 后面不加数据
 */
public class MethodNotice {
    public static void main(String[] args) {

    }

    public static void methodOne() {

    }

    public static void methodTwo() {
        // return 100;  // void没有返回值,会报错
        return;
    }
}

方法通用格式

格式:

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

• public static: 修饰符

• 返回值类型: 方法操作后返回的数据类型

• 方法名: 调用方法是使用的标识

• 参数: 有数据类型和变量名组成,多个参数之间用逗号隔开

• 方法体: 完整功能的代码块

• return: 操作完毕,有数据返回,return返回值

定义方法,明确两点:

• 明确返回值类型:明确方法是否有返回值, 没有,写void;有,写返回数据类型
• 明确参数数据类型: 明确参数的类型和数量

调用方法时,明确两点:

• void类型方法, 直接调用
• 非void类型方法, 推荐使用变量接受调用

6.方法重载

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

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

特点:

• 重载仅对应方法的定义, 与方法的调用无关
• 重载仅针对同一类中方法的名称与参数进行识别,与返回值无关,换句话说,不能通过返回值来判断两个方法是否相互构成重载.

package function;

/*
    方法重载:
        与返回值无关
        在调用时,java虚拟机通过参数不同来区分方法
 */

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

        // 调用方法
        int result = sum(10, 20);
        System.out.println(result);

        double result2 = sum(10.0, 20.0);
        System.out.println(result2);

        int result3 = sum(10, 20, 30);
        System.out.println(result3);
    }

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

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

    // 需求3: 三个int类型数据和的方法
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }
}

练习

需求: 按方法重载思路,设计比较两个数是否相等,兼容全整数类型(byte,short,int,long)

package function;

/*
    需求: 按方法重载思路,设计比较两个数是否相等,兼容全整数类型(byte,short,int,long)
    思路:
        1.定义compare方法,比较int类型
        2.参数变更为long类型,比较
        3.参数变更为shot类型,比较
 */

public class MethodReloadPractice {
    public static void main(String[] args) {
        // 调用方法
        System.out.println(compare(10, 20));
        System.out.println(compare((byte) 10, (byte) 20.0));
        System.out.println(compare((short) 10, (short) 20));
        System.out.println(compare(10L, 20L));
    }

    // 需求1: 两个int
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    // 需求2: 两个byte
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    // 需求3: 两个short
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    // 需求4: 两个long
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }
}

7.方法的参数传递

方法参数传递(基本类型)

对于基本类型的参数,形式参数的传递, 不影响实际参数的值

package function;

public class MethodParamTransform {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前:" + number);
        change(number);
        System.out.println("调用change方法后:" + number);
    }

    public static void change(int number) {
        number = 200;
    }
}

// 调用change方法前:100
// 调用change方法后:100

方法参数传递(引用类型)

对于引用类型的参数,形式参数的传递, 影响实际参数的值

package function;

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

    public static void change(int[] arr) {
        arr[1] = 200;
    }
}

// 调用change方法前:20
// 调用change方法后:200

8.参数传递案例

• system.out.println("内容"); 输出内容并且换行
• system.out.print("内容"); 输出内容不换行

需求: 遍历一个数组,要求遍历的结果是在一行上的.例如[11, 22, 33, 44, 55]

package function;

public class MethodParamTransform2 {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33, 44 ,55};
        printArr(arr);
    }

    // 定义一个方法,用于遍历数组
    /*
    两个明确:
    - 明确返回值类型:void
    - 明确参数: int[] arr
     */
    public static void printArr(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("]");
    }

}

debugg概述

debug: 是供程序员使用的程序调试工具, 他可以用于查看程序的执行流程, 也可以用于追踪程序执行过程来调试程序.

操作流程

Debug调试,称为断点调试, 断点是一个标记

• 如何加断点

选择要设置断点的代码行,在行号的区域后单击鼠标左键.

• 如何运行加断点的程序

代码区右键debug执行

• 看哪里

看Debugger窗口

看console窗口

• 点哪里

点Step(F7),或者按F7可以下一步

• 如何删除断点

选择删除的断点,可以删除

debug示例

package debug;

public class DebugTest {
    public static void main(String[] args) {
        // 定义求和变量
        int sum = 0;  // debug断点
        // 循环求偶数和
        for(int i=1;i<=10; i++) {
            if(i%2 == 0){
                sum += i;
            }
        }

        // 输出结果
        System.out.println("1-10之间的偶数之和是: " + sum);

    }
}

数组反转实例

需求: 已知一个数组, arr = {19, 28, 37, 46, 50}; 用程序实现把数组元素进行交换.

package exercise;

public class ArrayReverse {
    public static void main(String[] args) {
        // 定义一个数组
        int[] arr = {18, 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;
        }

        // 打印数组
        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.print(arr[x]);
            } else {
                System.out.print(arr[x] + ", ");
            }
        }
        System.out.println("]");
    }
}