当前位置： 首页 > news >正文

java方法学习

news 来源：原创 2025/5/14 10:46:15

java 方法

在Java中，方法是类（或对象）的行为或功能的实现。（一起实现一个功能）java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段。

  • 方法是解决一类问题步骤的有序结合。

  • 方法包含于类或对象中。

  • 方法在程序中被创建，在其他地方被引用。

    设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。设计方法时，最好保持方法的原子性。（就是一个方法只完成一个功能，有利于后期的拓展）

package com.jianstudy.method;
public class Demo01 {
    public static void main(String[] args) {
        //如果是实例方法要先创建类的实例:类名 声明的变量的名称 =new 类名() --- new 类的名称()是创建一个类的名称类型新对象的表达式。
        Demo01 demo01 = new Demo01();//创建一个Demo01类的demo01实例
        
        int result = demo01.add1(1, 2);//调用实例demo01里的add1方法
        
        System.out.println(result);
        
       //如果方法是静态的static修饰符
       
        int result1 =add(2,2);//实际参数：实际调用时，传递给他的参数
        
        System.out.println(result1);
    }
    /*方法的定义
    修饰符 返回类型 方法名(参数列表) {
            方法体
    }
    */
    //定义一个加法方法
    //静态方法             ↓形式参数，用来定义作用的参数。（接收外界输入的数据）
    public static int add(int a, int b) {
        return a+b ;
    }
    public  int add1(int a, int b) {
        return a+b ;
    }
}

在这里插入图片描述

package com.jianstudy.method;

public class Demo02 {
    public static void main(String[] args) {
        Demo02 demo02 = new Demo02();
        
        int max =demo02.max(6,6);
        
        System.out.println(max);
        
    }
    //比大小方法 显示对比结果，返回大的数
     // 如果不需要返回值直接使用void类型
    //public void max(int a, int b){}
    public int max(int a, int b) {
       int result=0;
       if(a==b){
           System.out.println("a==b");
           return 0;
       }
       if(a>b){
           System.out.println("a>b");
           result = a;
       }else{
           System.out.println("a<b");
           result = b;
       }
        return result ;
    }
}

不需要返回值的话 0 5 4 就不会显示了
在这里插入图片描述

方法的定义

在Java中，方法的定义是指声明一个具有特定名称、参数列表（可能为空）、返回类型（可能为void表示不返回任何值）以及方法体（包含执行语句的块）的代码段。

[修饰符] 返回的数据类型 方法名([参数列表]) {

方法体 …

执行语句 …

return 返回值; // 如果返回类型不是void，则需要有返回语句

}

  1. 修饰符（可选）：这是方法的访问控制符或其他修饰符，如public、private、protected、static、final等。它们定义了方法的可见性、是否可以被继承、是否是静态的等特性。

  2. 返回类型：这是方法执行完毕后返回的数据类型*。如果方法不返回任何值，则使用void关键字。

  3. 方法名：这是方法的标识符，用于在代码中引用该方法。方法名应该是描述性的，以便清楚地表明方法的功能。（命名要见名知义）

  4. 参数列表（可选）：这是一组由逗号分隔的变量声明，它们定义了方法接收的输入。如果方法不接受任何参数，则参数列表为空，但仍需要保留圆括号()。

    每个参数都包括类型和变量名。参数像是一个占位符，当方法被调用时，传递值给参数。这个值被称为实参（实际参数）或变量。

    • 形式参数：在方法被调用时，用于接收外界输入的数据。
    • 实参：调用方法时，实际传递给的方法的数据。

  5. 方法体：这是包含方法执行语句的代码块。方法体由大括号{}包围，并且包含了实现方法功能的Java语句。（实现功能的代码）

  6. 返回语句（可选）：如果方法有一个非void的返回类型，则必须包含一个return语句来返回相应类型的值。return语句也可以用于提前退出方法或返回特定的值。

方法的调用

在Java中，方法的调用是指通过方法名以及必要的参数来执行该方法的过程。调用方法时，程序会跳转到方法定义中的方法体，并执行其中的代码。方法调用可以在同一个类中、子类中、或者不同类（通过对象实例或类名）之间进行。

以下是一些方法调用的基本形式：

  1. 同一类中的方法调用
    在类的内部，可以直接通过方法名来调用该类中定义的其他方法。
  2. 通过对象实例调用方法
    当方法不是静态的（即不是用static关键字修饰的）时，需要通过类的对象实例来调用该方法。格式：类名 声明的变量的名称 =new 类名()
  3. 通过类名调用静态方法
    静态方法属于类本身，而不是类的某个实例。因此，可以通过类名直接调用静态方法，而无需创建类的对象。

在方法调用时，需要注意以下几点：

  • 确保方法的存在性：调用的方法必须在类中被定义，否则会导致编译错误。
  • 参数匹配：传递给方法的参数类型、数量和顺序必须与方法定义中的参数列表相匹配。
  • 访问权限：调用方法时，必须遵守Java的访问控制规则。例如，私有方法（private）只能在定义它们的类内部被调用。
  • 静态上下文：在静态方法或静态初始化块中，只能直接调用静态方法或访问静态字段。要调用非静态方法或访问非静态字段，需要先创建类的对象实例

方法的重载

在Java中，方法的重载（Overloading）是一种允许在同一个类中定义多个同名方法的技术，只要它们的参数列表不同即可。参数列表的不同可以体现在参数的类型、数量或顺序上。方法重载的主要目的是提高代码的可读性和易用性，使得程序员可以用一种更自然的方式来表示相同的功能。

方法重载的关键点

  1. 方法名相同：重载的方法必须具有相同的名称。
  2. 参数列表不同：重载的方法参数列表必须不同，这可以通过改变参数的类型、数量或顺序来实现。
  3. 返回类型可以相同也可以不同：方法的返回类型不是重载的考虑因素。即使两个方法具有相同的名称和不同的返回类型，但如果它们的参数列表相同，那么它们就不是重载方法。
  4. 访问修饰符和异常声明可以不同：访问修饰符（如public、private等）和抛出的异常类型也不会影响方法的重载。

方法重载的原理

方法重载的实现依赖于编译器（jvm）。当编译器遇到一个方法调用时，它会根据传递给方法的参数类型和数量来选择合适的方法进行调用。如果有多个同名方法，编译器会根据参数列表的不同来进行匹配。

需要注意的是，虽然方法重载可以提高代码的可读性和灵活性，但过度使用也可能会导致代码的可读性下降。因此，在使用方法重载时，应该遵循一定的命名和规范，以确保代码的可维护性。

package com.jianstudy.method;
public class Demo03 {
    public static void main(String[] args) {
        Demo03 demo03 = new Demo03();
        
        int result1 = demo03.add(5,4);
        
        int result2 = demo03.add(1,2,3);
        
        double result3 =add(10.1,5.5)  ;//静态的方法可以直接调用
        
        double result4 =demo03.add(10,5,5.5)  ;
        
        System.out.println(result1);        
        System.out.println(result2);        
        System.out.println(result3);
        System.out.println(result4);
    }
    //方法的重载
    /*
    方法名相同，参数列表必须不同，返回值类型可以相同，也可以不同，访问修饰符和异常声明可以不同
     */
    public  int add(int a, int b) {
        return a+b ;
    }
    public  int add(int a, int b,int c) {
        return a+b+c ;
    }
    //这里使用了静态方法
    public static double add(double a, double b){
        return a+b ;
    }
    public double add(int a, int b,double c) {
        return a+b+c;
    }

}

在这里插入图片描述
可以看出虽然用的方法名都是add但是根据参数列表的不同选择了对应参数的add方法。

命令行传参

当运行一个程序时再传给它数据，这就要用命令行传参给 main（）函数实现。

Java命令行传参不是一种方法，而是一种在运行Java程序时向程序传递参数的方式。这些参数在程序启动时通过命令行传递给main方法，并作为main方法的参数String[] args数组的一部分被接收和处理。

在Java中，main方法是程序的入口点，它的签名是固定的，即public static void main(String[] args)。其中，args参数是一个字符串数组，用于接收命令行传递的参数。当你通过命令行运行Java程序时，可以在类名后面跟上任意数量的参数，这些参数将被作为字符串数组传递给main方法。

package com.jianstudy.method;
public class Demo04 {
    public static void main(String[] args) {
       for (int i =0; i<args.length;i++) {
           System.out.println("args["+i+"]="+args[i]);
       }
    }
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
当运行一个程序时再传给它数据，这就要用命令行传参给 main（）函数实现。

可变参数

在Java中，可变参数（varargs）是一种方法参数，它允许你向方法传递任意数量的参数，或者更具体地说，是传递一个可变数量的同类型参数。可变参数在方法声明中使用省略号（...）作为类型的一部分来表示。

当你不确定要传递给方法多少个参数，或者你想要方法能够接受不同数量的参数时，可变参数就非常有用了。

需要注意的是，可变参数在方法签名中必须是最后一个参数。如果一个方法接受其他类型的参数，那么可变参数必须放在这些参数的后面。

另外，虽然可变参数很方便，但也要谨慎使用，因为它们可能会使方法的签名变得不那么清晰，特别是当方法接受多个参数时。在可能的情况下，考虑使用重载（方法名相同但参数列表不同）来提供更清晰的方法接口。

方法的声明：

[修饰符] 返回的数据类型 方法名([参数列表]) {

方法体 …

执行语句 …

return 返回值; // 如果返回类型不是void，则需要有返回语句

}

可变参数声明方式：

返回类型 方法名(参数类型… 参数名) { // 方法体 }

可变参数在方法中被当作一个数组来处理。

package com.jianstudy.method;
public class Demo05 {
    public static void main(String[] args) {
        Demo05 demo05 = new Demo05();
        System.out.println(demo05.add());
        System.out.println(demo05.add(1, 2));
        System.out.println(demo05.add(3,1,2));
    }
    //不知道要加几次用可变参数 定义的可变参数就是数值。
    public int add(int... num) {
        //遍历数组num如果没有输入数据就输出"没有数据传入"
        if (num.length == 0) {
            System.out.print("没有数据传入");
            return 0;
        }
        //声明result 存放数组里的每一个数相加之后的结果
        int result = 0;
        //nums会依次取数组num里每个元素的值，然后执行循环体的程序
        //for each
        for (int nums : num) {
            result = result + nums;
        }
        return result;
    }
}

在这里插入图片描述

递归

在Java编程中，递归是一种特殊的编程技巧，它指的是一个方法在执行过程中能够调用自身的能力

  1. 递归的基本概念

    递归的核心在于一个方法能够自我调用，以解决那些可以被拆解为更小、更相似子问题的大问题。这种自我调用的过程会一直持续，直至达到某个预设的终止条件，此时递归将停止，并开始逐层返回之前调用的结果。

  2. 递归的两大要素

    • 递归公式：这是递归方法的核心，它定义了方法如何调用自身，并展示了如何将大问题分解为小问题进行求解
    • 终止条件）：递归必须有一个明确的结束点，以防止方法无限制地自我调用，从而避免栈溢出等严重问题。当满足这个条件时，递归将停止。

  3. 递归的执行流程

    递归的执行遵循“后进先出”的原则，这与栈的工作原理相似。在递归调用中，每一次的方法调用都会被压入调用栈中，直到达到终止条件。随后，方法会按照调用的相反顺序逐层返回结果，并从调用栈中弹出。

  4. 递归的优缺点

    • 优点：递归代码通常更简洁、更易读，尤其在处理递归性质的问题时（如树的遍历、斐波那契数列等）。
    • 缺点：递归可能导致性能问题（如栈溢出、重复计算等），并且有时难以调试。

  5. 递归的替代方案

    在某些情况下，我们可以使用循环等迭代方式来替代递归，以避免其潜在的缺点。然而，对于某些特定问题，递归可能是最自然、最高效的解决方案。
    综上所述，递归是Java编程中的一种重要技术，它允许我们以简洁的方式解决复杂问题。然而，在使用递归时，我们必须谨慎地设计终止条件和递归公式，以确保代码的正确性和效率。

递归可以看成两部分

递”的过程

“递”的过程，实际上是递归函数不断调用自身，以解决更小规模子问题的过程。每一次调用都会将当前问题的状态（如参数值）压入调用栈中，以便在后续能够恢复之前的状态。这个过程会一直进行下去，直到满足某个特定的终止条件（也称为基准情况或递归出口）

归”的过程

“归”的过程，则是当满足终止条件时，递归调用开始逐层返回的过程。每一次返回都会从调用栈中弹出之前的状态，并根据这些状态计算并返回结果。这些返回的结果会被组合起来，以形成最终问题的解。

package com.jianstudy.method;

public class Demo06 {
    public static void main(String[] args) {
        Demo06 demo06 = new Demo06();
        System.out.println(demo06.factorial(5));
    }
    //阶乘方法
    public int factorial(int n){
        // 1的阶乘是1  n！=n*(n-1)*n(n-2)*...*1        
        
        if(n==1 ){
            return 1;//factorial(1)=1  递归的基准条件
        }else{
         /* 程序处理时是从最高层返回上一层的结果，先有基准跳出的条件 n=1  f(1)=1;
         n*factorial(n-1)  5!=5*f(4)=5*24=120   4!=4*f(3)=4*6=24  3!=3*f(2)= 3*2=6 2!=2*(f1)=2*1=2
         2！=2*1  3！=3*2！=3*2=6  4！=4*3！=4*6=24  5！=5*4！=5*24=120
         */
            return n*factorial(n-1);
           
            //每次调用自身，递的过程先从最大项开始递，归的过程先从能返回基准条件开始归。2！=2*1  3！=3*2！=3*2=6  4！=4*3！=4*6=24  5！=5*4！=5*24=120
            /*
            ‌递过去‌：
            factorial(5)调用factorial(4)
            factorial(4)调用factorial(3)
            factorial(3)调用factorial(2)
            factorial(2)调用factorial(1)
            factorial(1)返回1（满足基准情况）            
            ‌归回来‌：
            factorial(2)返回2 * factorial(1)的结果，即2 * 1 = 2
            factorial(3)返回3 * factorial(2)的结果，即3 * 2 = 6
            factorial(4)返回4 * factorial(3)的结果，即4 * 6 = 24
            factorial(5)返回5 * factorial(4)的结果，即5 * 24 = 120            
             */
        }


    }
}

每次调用自身，递的过程先从最大项开始递，归的过程先从能返回基准条件开始归。
2！=2 * 1
3！=3 * 2！=3 * 2=6
4！=4 * 3！=4 * 6=24
5！=5 * 4！=5 * 24=120
‌递过去‌：
factorial(5)调用factorial(4)
factorial(4)调用factorial(3)
factorial(3)调用factorial(2)
factorial(2)调用factorial(1)
factorial(1)返回1（满足基准情况）
每一次返回都会从调用栈中弹出之前的状态，并根据这些状态计算并返回结果
‌归回来‌：
factorial(2)返回2 * factorial(1)的结果，即2 * 1 = 2
factorial(3)返回3 * factorial(2)的结果，即3 * 2 = 6
factorial(4)返回4 * factorial(3)的结果，即4 * 6 = 24
factorial(5)返回5 * factorial(4)的结果，即5 * 24 = 120
这些返回的结果会被组合起来，以形成最终问题的解

在这里插入图片描述

结合最近学习的内容写一个简易计算器

package com.jianstudy.method;
import java.util.Scanner;
public class Demo07 {
    public static void main(String[] args) {
        //简易计算器
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入第一个数: ");
        double num1 = scanner.nextDouble();

        System.out.print("请输入符号: ");
        //输入符号要使用scanner.next().charAt(0)语句
        char operators = scanner.next().charAt(0);
        
        System.out.print("请输入第二个数: ");
        double num2 = scanner.nextDouble();
		//使用完要关闭
        scanner.close();
        
		//声明result存放运算结果
        double result;
        
		//运算符选择  
		//每个case语句里要加上break 防止case穿透
        switch (operators) {
            case '+':
                result = add(num1, num2);
                System.out.println("计算结果为: " + result);
                break;
            case '-':
                result = sub(num1, num2);
                System.out.println("计算结果为: " + result);
                break;
            case '*':
                result = mult(num1, num2);
                System.out.println("计算结果为: " + result);
                break;
            case '/':
                if (num2 == 0) {
                    System.out.println("错误：除数不能为0！");
                } else {
                    result = div(num1, num2);
                    System.out.println("计算结果为: " + result);
                }
                break;
            default:
                System.out.println("错误：无效的运算符！");
        }
    }
	//全部使用了静态方法，如果不是使用静态方法去掉static 在main使用时只需要创建Demo07类的实例
    // 加法方法
    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 mult(double a, double b) {
        return a * b;
    }
    // 除法方法
    public static double div(double a, double b) {
        return a / b;
    }
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

相关文章：

  • 探索 Peewee：轻量级 Python ORM 简明指南
  • 更改visual studio 2022 默认NuGet包路径
  • 【uni-app】对齐胶囊容器组件
  • 基于SpringBoot实现的宠物领养系统平台功能七
  • 华为guass在dbever和springboot配置操作
  • 大厂出品！三个新的 DeepSeek 平替网站
  • 【AcWing】动态规划-线性DP -选数异或
  • springboot408-基于Java的樱洵宾馆住宿管理系统(源码+数据库+纯前后端分离+部署讲解等)
  • JDK源码系列(二)
  • 第44天：Web开发-JavaEE应用反射机制类加载器利用链成员变量构造方法抽象方法
  • 代码随想录刷题day28|（栈与队列篇:栈）232.用栈实现队列
  • pycharm中配置PyQt6详细教程
  • Turborepo 使用配置
  • 深入探讨Web应用开发：从前端到后端的全栈实践
  • LLaMA-Factory|微调大语言模型初探索(4)，64G显存微调13b模型
  • 苹果确认iOS 18.4四月初推出：Apple Intelligence将迎来中文支持
  • MFC开发：如何创建第一个MFC应用程序
  • 将 Vue 项目打包后部署到 Spring Boot 项目中的全面指南
  • Python在实际工作中的运用-基础操作
  • 数据库面试知识点总结
  • 首个偏头痛急性治疗药物可缓解前期症状
  • 微软宣布将裁员3%
  • 彭丽媛同巴西总统夫人罗桑热拉参观中国国家大剧院
  • 郑培凯：汤显祖的“至情”与罗汝芳的“赤子之心”
  • 地下5300米开辟“人造气路”，我国页岩气井垂深纪录再刷新
  • 超新星｜18岁冲击中超金靴，王钰栋的未来无限可能