Java基础 第一节 第十六课

方法

• 方法的定义和调用 ( 回顾 )
• 定义方法的格式详情
• 定义方法的两个明确
• 调用方法的流程图解
• 练习
• 定义方法的注意事项
• 调用方法的三种形式
• 方法重载
• 练习

方法的定义和调用 ( 回顾 )

前面的课程中, 使用过嵌套循环输出矩阵, 控制台打印出矩阵就可以了, 因此将方法定义为 void, 没有返回值. 在主方法 main 中直接被掉用.

public class Method_Demo1 {
    public static void main(String[] args) {
        print();
    }
    private static void print() {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 8; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

print 方法 main 方法调用后输出结果, 而 mian 方法并不需要 print 方法执行结果, 所以被称为定义为 void.

定义方法的格式详情

修饰符 返回值类型 方法名(参数列表){
   // 代码省略...
   return 结果;
}

• 修饰符: public static 固定写法
• 返回值类型: 表示方法运行的结果的数据类型, 方法执行后将结果返回到调用者
• 参数列表: 方法在运算过程中的未知数据, 调用者调用方法时传递
• return:将方法执行后的结果带给调用者, 方法执行到 return, 整体方法运行结束

注: return 结果, 这里的 “结果” 在开发中, 我们正确的叫法称为方法的返回值.

定义方法的两个明确

要求: 定义方法实现两个整数的求和计算.

• 明确返回值类型: 方法计算的是整数的求和, 结果也必然是个整数, 返回值类型定义为 int 类型.
• 明确参数列表: 计算哪两个整数的和, 并不清楚, 但是可以确定是整数, 参数列可以定义两个 int 类型的变量, 由调用者调用方法时传递.

public class Test32 {
    public static void main(String[] args) {
        // 调用方法 getSum, 传递两个整数, 这里传递的实际参数又称为实参
        // 并接受方法计算后的结果, 返回值
        int sum = getSum(5,6); // 5和6在这里是实参
        System.out.println(sum); // 输出结果为: 11
    }

    /**
     * 定义计算两个整数和的方法
     * @param a 第一个整数
     * @param b 第二个整数
     * @return 返回值类型, 计算结果是 int
     * 参数: 不确定数据求和, 定义 int 参数, 参数有称为形式参数
     */
    public static int getSum(int a, int b){
        // a和b在这里是形参
        return a + b;
    }
}

程序执行, 主方法 main 调用 getSum 方法, 传递了实际数据 5 和 6, 两个变量 a 和 b 接受到的就是实际参数, 并将计算的结果返回, 主方法 main 中的变量 sum 接收的就是方法的返回值.

实参 ( argument ):
全称为 “实际参数” 是在调用时传递给函数的参数. 实参可以是常量, 变量, 表达式, 函数等, 无论实参是何种类型的量, 在进行函数调用时, 它们都必须具有确定的值, 以便把这些值传送给形参. 因此应预先用赋值, 输入等办法使实参获得确定值.

形参 ( parameter ):
全称为 “形式参数” 由于它不是实际存在变量, 所以又称虚拟变量. 是在定义函数名和函数体的时候使用的参数, 目的是用来接收调用该函数时传入的参数. 在调用函数时, 实参将赋值给形参. 因而, 必须注意实参的个数, 类型应与形参一一对应, 并且实参必须要有确定的值.

调用方法的流程图解

练习

练习一

比较两个整数是否相同
分析: 定义方法实现功能, 需要有两个明确, 即返回值和参数列表.

• 明确返回值: 比较整数, 比较的结果只有两种可能, 相同或不同. 因此结果是布尔类型, 比较的结果相同为 true.
• 明确参数列表: 比较的两个整数不确定, 所以默认认定义两个 int 类型的参数.

public class Test33 {
    public static void main(String[] args) {
        // 调用方法compare, 传递两个整数
        // 并接收方法计算后的结果, 布尔值
        boolean bool = compare(3, 8);
        System.out.println(bool);
        
    }
    /**
     * 定义比较两个整数是否相同的方法
     * @param a 第一个整数
     * @param b 第二个整数
     * @return 返回比较的结果, 返回值类型为布尔类型
     * 参数: 不确定与比较的两个整数
     */
    public static boolean compare(int a, int b){
        if (a == b) {
            return true;
        } else {
            return false;
        }
    }
}

练习二

计算 1+2+3…+100 的和

• 分析: 定义方法实现功能, 需要两个明确, 即返回值和参数
• 明确参数: 需要中已知到计算的数据, 没有未知的数据, 不定义参数

public class Test34 {
    public static void main(String[] args) {
        //调用方法getSum
        //并接收方法计算后的结果，整数
        int sum = getSum();
        System.out.println(sum); // 输出结果为: 5050
    }

     /**
     * 定义计算1~100的求和方法
     * 参数：没有不确定数据
     * @return 返回值类型，计算结果整数int
     */
    public static int getSum() {
        //定义变量保存求和
        int sum = 0;
        //从1开始循环，到100结束
        for (int i = 1; i <= 100; i++) {
            sum = sum + i;
        }
        return sum;
    }
}

练习三

分析: 定义方法实功能, 需要有个明确, 即返回值和参数.

• 明确返回值: 方法中打印出 HelloWorld 即可, 没有计算结果, 返回值类型 void
• 明确参数: 打印几次不清楚. 参数定义一个整型参数

public class Test35 {
    public static void main(String[] args) {
        // 调用方法printHelloWorld, 传递整数
        printHelloWorld(9);
    }

    /**
     * 定义打印HelloWorld方法
     * @param number 打印的次数
     * 返回值: 计算没有结果 void
     */
    public static void printHelloWorld(int number) {
        for (int i = 0; i < number; i++) {
            System.out.println("HelloWorld");
        }
    }
}

定义方法的注意事项

• 定义位置, 类中方法外面.
• 返回值类型, 必须要和 return 语句返回的类型相同, 否则编译失败

// 返回值类型要求是int
public static int getSum() {
     return 5;  // 正确, int类型
     return 1.2;  // 错误, 类型不匹配
     return true;  // 错误, 类型不匹配
}

• 不能在 return 后写代码, return 意味着方法结束, 所有后面的代码永远不会只想, 属于无效代码.

public static int getSum(int a,int b) {
    return a + b;
    System.out.println("Hello");  // 错误, return已经结束, 这里不会执行, 无效代码
}

调用方法的三种形式

直接调用

直接调用: 直接写方法名调用.

public static void main(String[] args) {
        print();
    }
    public static void print(){
        System.out.println("方法被调用");
    }

赋值调用

赋值调用: 调用方法, 在方法前定义变量, 接收方法返回值.

public static void main(String[] args) {
        int sum = getSum(5,6);
        System.out.println(sum);
    }
    public static int getSum(int a, int b){
        return a + b;
    }

不能用输出语句调用 void 类型的方法. 因为方法执行后没有结果, 也打印不出任何内容.

public static void main(String[] args) {
        System.out.println(printHello());  // 错误, 不能输出语句调用void类型方法
    }
    public static void printHello() {
        System.out.println("Hello");
    }

执行结果:

方法重载

• 方法重载: 指在同一个类中, 允许存在一个以上的同名方法, 只要它们的参数列表不同即可, 与修饰符和返回值类型无关.
• 参数列表: 个数不同, 数据类型, 顺序不同.
• 重载方法调用: JVM 通过方法的参数列表, 调用不同的方法.

练习

练习一

比较两个数据是否相等. 参数类型分别为两个 byte 类型, 两个 short 类型, 两个 int 类型, 两个 long 类型, 并在 main 方法中进行测试.

public class Test39 {
    public static void main(String[] args) {
        // 定义不同数据类型的变量
        byte a = 10;
        byte b = 20;
        short c = 10;
        short d = 20;
        int e = 10;
        int f = 10;
        long g = 10;
        long h = 20;
        // 调用
        System.out.println(compare(a, b));
        System.out.println(compare(c, d));
        System.out.println(compare(e, f));
        System.out.println(compare(g, h));
    }

    // 两个byte类型的
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    // 两个short类型的
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    // 两个int类型的
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    // 两个long类型的
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }
}

执行结果:

练习二

判断哪些方法是重载关系.

public static void open(){} // 属于重载
public static void open(int a){} // 属于重载
static void open(int a,int b){} // 不属于重载，与 8 冲突
public static void open(double a,int b){} // 属于重载
public static void open(int a,double b){} // 不属于重载，与 6 冲突
public void open(int i,double d){} // 不属于重载，与 5 冲突
public static void OPEN(){} // 运行无错，不过不属于重载，名称不同
public static void open(int i,int j){} // 不属于重载，与 3 冲突

练习三

模拟输出语句中的 println 方法效果, 传递什么类型的数据就输出什么类型的数据, 只允许定义一个方法名 println.

public class Test40 {
    public static void main(String[] args) {
        byte a = 1;
        short b = 2;
        int c = 3;
        long d = 4L;
        float e = 5.0F;
        double f = 6.0;
        char g = 'A';
        boolean h = true;
        String str = "Last";
        myPrint(a);
        myPrint(b);
        myPrint(c);
        myPrint(d);
        myPrint(e);
        myPrint(f);
        myPrint(g);
        myPrint(h);
        myPrint(str);
    }

    // byte
    public static void myPrint(byte a) {
        System.out.println("byte数据:" + a);
    }
    // short
    public static void myPrint(short a) {
        System.out.println("short数据:" + a);
    }
    // int
    public static void myPrint(int a) {
        System.out.println("int数据:" + a);
    }
    // long
    public static void myPrint(long a) {
        System.out.println("long数据:" + a);
    }
    // float
    public static void myPrint(float a) {
        System.out.println("float数据:" + a);
    }
    // double
    public static void myPrint(double a) {
        System.out.println("double数据:" + a);
    }
    // char
    public static void myPrint(char a) {
        System.out.println("char数据:" + a);
    }
    // boolean
    public static void myPrint(boolean a) {
        System.out.println("boolean数据:" + a);
    }
    // String
    public static void myPrint(String a) {
        System.out.println("String数据:" + a);
    }
}