方法

Java方法

何谓方法

package com.dai.method;

public class Demo01 {
    //main方法
    public static void main(String[] args) {
        /*//这里10,、20对应ab的实际参数:实际调用传递给他的参数
        int sum = add(10,20);//方法调用
        System.out.println("和是：" + sum);*/
        test();//调用test方法

    }
    //加法(这是一个方法的声明)
    //这里ab为形式参数，用来定义作用的
    public static int add(int a, int b){
        return a + b;
    }
    //test方法，打印1到1000之间所有5的倍数，每行打印3个
    public static void test(){
        for (int i = 0; i <=1000; i++){
            if (i % 5 == 0){
                //注意这里不能用println，否则每输出一个数据就换行了
                System.out.print(i+"\t");//这里\t表示制表符，相当于空格
            }
            if (i % (5*3) == 0){//每输出3个5的倍数后换行
                System.out.println();//每输出3个5的倍数后换行
                //System.out.print("\n");//也可以用这个换行
            }
        }
    }
}

方法的定义及调用

package com.dai.method;

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

        int max = max(10,10);
        System.out.println("最大值是：" + max);
    }

    //比大小
    public static int max(int num1, int num2) {

        int result = 0;

        if ( num1 == num2) {
            System.out.println("两个数相等");
            return 0;//结束方法
        }

        if (num1 > num2) {
            result = num1;
        } else {
            result = num2;
        }
        return result;
    }
}

方法重载

package com.dai.method;

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

        double max = max(10,50);
        System.out.println("最大值是：" + max);
    }

    //比大小（int类型的数据）
    public static int max(int num1, int num2) {

        int result = 0;

        if ( num1 == num2) {
            System.out.println("两个数相等");
            return 0;//结束方法
        }

        if (num1 > num2) {
            result = num1;
        } else {
            result = num2;
        }
        return result;
    }

    //比大小(方法重载)double类型的数据
    public static double max(double num1, double num2) {

        double result = 0;

        if ( num1 == num2) {
            System.out.println("两个数相等");
            return 0;//结束方法
        }

        if (num1 > num2) {
            result = num1;
        } else {
            result = num2;
        }
        return result;
    }

}

package com.dai.method;

public class Demo01 {
    //main方法
    public static void main(String[] args) {
        /*int sum = add(10,20);//方法调用
        //int sum = add(10,20,30);//调用重载的add方法
        System.out.println("和是：" + sum);*/
        test();//调用test方法

    }
    //加法(这是一个方法的声明)
    public static int add(int a, int b){
        return a + b;
    }

    //加法(方法重载)
    public static int add(int a, int b, int c){
        return a + b + c;
    }

    //test方法，打印1到1000之间所有5的倍数，每行打印3个
    public static void test(){
        for (int i = 0; i <=1000; i++){
            if (i % 5 == 0){
                //注意这里不能用println，否则每输出一个数据就换行了
                System.out.print(i+"\t");//这里\t表示制表符，相当于空格
            }
            if (i % (5*3) == 0){//每输出3个5的倍数后换行
                System.out.println();//每输出3个5的倍数后换行
                //System.out.print("\n");//也可以用这个换行
            }
        }
    }
}

命令行传参

这里需要退回到src，通过cd ../退回，后面：this is dai是传入的参数

可变参数

递归

package com.dai.method;

public class Demo05 {

    public static void main(String[] args) {
        System.out.println(f(5));
    }
    //递归：方法自己调用自己
    //阶乘：n! = n*(n-1)!
    //计算过程：5! = 5*4! = 5*4*3! = 5*4*3*2! = 5*4*3*2*1! = 5*4*3*2*1 = 120
    public static int f(int n){
        //递归结束条件
        if (n == 1){
            return 1;
        }else{
            return n*f(n-1);
        }
    }
}

作业:写一个计算器

package com.dai.method;

import java.util.Scanner;

public class TestDemo {
    public static void main(String[] args) {
        // 写一个计算器
        Scanner sc = new Scanner(System.in);

        while (true){
            System.out.println("欢迎使用计算机！");
            System.out.println("请输入第一个数字：");
            double a = sc.nextDouble();

            System.out.println("请输入第二个数字：");
            double b = sc.nextDouble();

            System.out.println("请选择您的操作：1.加法 2.减法 3.乘法 4.除法 5.退出");
            int choice = sc.nextInt();

            switch (choice){
                case 1:
                    System.out.println(a + " + " + b + " = " + add(a, b));
                    break;
                case 2:
                    System.out.println(a + " - " + b + " = " + sub(a, b));
                    break;
                case 3:
                    System.out.println(a + " * " + b + " = " + mul(a, b));
                    break;
                case 4:
                    if (b != 0) {
                        System.out.println(a + " / " + b + " = " + div(a, b));
                    } else {
                        System.out.println("错误：除数不能为零！");
                    }
                    break;
                case 5:
                    System.out.println("感谢使用，再见！");
                    sc.close();
                    return;
                default:
                    System.out.println("无效的选择，请重新输入。");
                    break;

            }

        }

    }

    public static double add(double a, double b) {
        return a + b;
    }

    public static double sub(double a, double b) {
        return a - b;
    }

    public static double mul(double a, double b) {
        return a * b;
    }

    public static double div(double a, double b) {
        return a / b;
    }
}

java方法调用

实例方法的调用

实例方法是指没有被static修饰的方法，它属于 “对象”，必须通过 “类的实例（对象）” 才能调用

同一类中调用实例方法

如果调用的实例方法和当前方法在同一个类中，直接通过当前对象（this） 或省略this调用（默认用this）。

public class Student{
    public static void main(String[] args){
        //main是静态方法，调用实例方法必须先创建对象
        //这个创建的是自己的类名
        Student s = new Student();
        s.study();
    }
    //实例方法：打印学生信息
    public void printInfo(){
        System.out.println("学生信息....");
    }
    
    //实例方法：调用同一类中的printInfo()
    public void study(){
        //方式1：直接调用（默认this）
        printInfo();
        //方式2：显示用this调用
        this.printInfo();
    }
    
}

不同类中调用实例方法

如果调用的实例方法在另一个类中，步骤是：

① 创建目标类的对象 → ② 通过 “对象.方法名 ()” 调用。

示例（类 A 调用类 B 的实例方法）：

// 类B：包含实例方法
class Teacher {
    public void teach() {
        System.out.println("老师讲课中...");
    }
}

// 类A：调用类B的teach()方法
public class School {
    public static void main(String[] args) {
        // 1. 创建Teacher类的对象;这个是创建调用类的对象
        Teacher t = new Teacher();
        // 2. 通过对象调用实例方法
        t.teach(); // 输出：老师讲课中...
    }
}

静态方式调用（static修饰）

静态方法是被static修饰的方法，它属于 “类” 本身，不需要创建对象，直接通过 “类名。方法名 ()” 调用（同一类中可省略类名）。

同一类中调用静态方法

直接写方法名（或 “类名。方法名 ()”，更规范）。

public class MathUtil {
    // 静态方法：计算两数之和
    public static int add(int a, int b) {
        return a + b;
    }

    // 静态方法：调用同一类中的add()
    public static void calculate() {
        // 方式1：直接调用（同一类中可省略类名）
        int sum1 = add(1, 2); 
        // 方式2：显式用类名调用（推荐，清晰）
        int sum2 = MathUtil.add(3, 4); 
        System.out.println(sum1 + "，" + sum2); // 输出：3，7
    }

    public static void main(String[] args) {
        // main是静态方法，直接调用同类型的静态方法
        calculate(); 
    }
}

不同类中调用静态方法

通过 “目标类名.方法名 ()” 调用（无需创建对象）。

示例（类 C 调用类 D 的静态方法）：

// 类D：包含静态方法
class ArrayUtil {
    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

// 类C：调用类D的静态方法
public class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        // 直接通过类名调用静态方法，无需创建ArrayUtil对象
        ArrayUtil.printArray(arr); // 输出：1 2 3 
    }
}

注意：静态方法中不能直接调用实例方法（因为实例方法属于对象，而静态方法不依赖对象存在），反之实例方法可以调用静态方法。**

构造方法的调用（初始化对象时自动调用）

构造方法是与类名同名、无返回值的特殊方法，用于创建对象时初始化对象（如给属性赋值）。它不能手动通过 “对象.方法名 ()” 调用，而是在执行new 类名(...)时自动触发。

默认构造方法

如果类中没有定义构造方法，Java 会自动生成一个无参默认构造方法，创建对象时自动调用。

public class Book {
    // 未定义构造方法，Java自动生成默认无参构造方法

    public static void main(String[] args) {
        // 创建对象时，自动调用默认构造方法
        Book b = new Book(); // 此处隐含调用Book()构造方法
    }
}

自定义构造方法

如果手动定义了构造方法（有参 / 无参），Java 不再生成默认构造方法。创建对象时，需传入匹配的参数，触发对应的构造方法。

public class Person {
    String name;
    int age;

    // 自定义有参构造方法（初始化name和age）
    public Person(String n, int a) {
        name = n;
        age = a;
        System.out.println("构造方法被调用，初始化完成");
    }

    public static void main(String[] args) {
        // 创建对象时，传入参数触发自定义构造方法
        Person p = new Person("张三", 20); 
        // 输出：构造方法被调用，初始化完成
        System.out.println(p.name + "，" + p.age); // 输出：张三，20
    }
}

重载方法的调用（方法名相同，参数不同）

重载是指同一类中，方法名相同但参数列表（类型 / 数量 / 顺序）不同的方法。调用时，Java 会根据传入的参数自动匹配对应的方法。

public class Calculator {
    // 重载方法1：两个int相加
    public int add(int a, int b) {
        return a + b;
    }

    // 重载方法2：三个int相加（参数数量不同）
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // 重载方法3：两个double相加（参数类型不同）
    public double add(double a, double b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calc = new Calculator();
        // 根据传入的参数，自动匹配对应的重载方法
        System.out.println(calc.add(1, 2)); // 调用方法1，输出3
        System.out.println(calc.add(1, 2, 3)); // 调用方法2，输出6
        System.out.println(calc.add(1.5, 2.5)); // 调用方法3，输出4.0
    }
}

递归方法的调用（方法自身调用自身）

递归是指方法内部调用自己，通常用于解决有 “重复子问题” 的场景（如阶乘、斐波那契数列）。调用时需注意终止条件，否则会陷入无限循环导致栈溢出。

示例（计算 n 的阶乘：n! = n × (n-1) × ... × 1）：

public class RecursionDemo {
    // 递归方法：计算n的阶乘
    public static int factorial(int n) {
        // 终止条件：n=1时返回1（不再递归）
        if (n == 1) {
            return 1;
        }
        // 递归调用：n! = n × (n-1)!
        return n * factorial(n - 1); 
    }

    public static void main(String[] args) {
        System.out.println(factorial(5)); // 输出：120（5! = 5×4×3×2×1）
    }
}

方法类型	调用前提	调用语法	示例
实例方法	必须创建对象	对象。方法名 (参数)	student.study();
静态方法	无需创建对象，属于类	类名。方法名 (参数)（同一类可省略类名）	MathUtil.add(1,2);
构造方法	创建对象时自动调用	new 类名 (参数)	new Person("张三", 20);
重载方法	根据参数自动匹配	方法名 (参数)（参数需与重载版本匹配）	calc.add(1,2); calc.add(1.5,2.5);
递归方法	需有终止条件，方法内部调用自身	方法名 (参数)（参数逐步逼近终止条件）	factorial(n-1);