方法 方法的调用，有参，无参的方法传递

最新推荐文章于 2024-07-23 04:12:47 发布
最新推荐文章于 2024-07-23 04:12:47 发布
阅读量281 收藏 1
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62491932/article/details/130464328
版权 
/*
    方法：是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

    定义格式：
        public static void 方法名 ( ) {
           //方法体
       }

   调用格式：
       方法名();
 */

public class MethodDemo {
    public static void main(String[] args) {
        //调用方法
        System.out.println("这是方法1的标示");
        isEvenNumber();
        isEvenNumber();
        isEvenNumber();
        isEvenNumber();
        isEvenNumber();



    }



    //需求：定义一个方法，在方法中定义一个变量，判断该数据是否是偶数     方法是不带主函数的   而且是单独的   true
    public static  void isEvenNumber() {
        //定义变量
        int number = 10;

        //判断该数据是否是偶数
        if(number%2 == 0) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
    }


}

/*
    需求：
        设计一个方法用于打印两个数中的较大数

    思路：
        1:定义一个方法，用于打印两个数字中的较大数，例如getMax()
        2:方法中定义两个变量，用于保存两个数字
        3:使用分支语句分两种情况对两个数字的大小关系进行处理
        4:在main()方法中调用定义好的方法
 */
public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法
        getMax();
    }

    //定义一个方法，用于打印两个数字中的较大数，例如getMax()

    public static void getMax() {
        //方法中定义两个变量，用于保存两个数字
        int a = 10;
        int b = 20;

        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }

}

测试

public class test {
    public static void main(String[] args) {
        //变量       参数传进来
        int a=11;


        //判断  作为一个方法
        if (a%2==0){
            System.out.println("偶数");
        }else {
            System.out.println("奇数");
        }
    }
}

/*
    带参数方法的定义和调用

    定义格式：
        public static void 方法名(参数) { … … }

   调用格式：
        方法名(参数);
 */
public class MethodDemo {

    //主函数  只写参数    调用方法
    public static void main(String[] args) {
        //常量值的调用
        isEvenNumber(11);
        isEvenNumber(20);



    }

    //需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数    只写判断
    public static void isEvenNumber(int number) {

        if(number%2 == 0) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
    }

}

/*
    需求：
        设计一个方法用于打印两个数中的较大数，数据来自于方法参数

    思路：
        1:定义一个方法，用于打印两个数字中的较大数，例如getMax()
        2:为方法定义两个参数，用于接收两个数字
        3:使用分支语句分两种情况对两个数字的大小关系进行处理
        4:在main()方法中调用定义好的方法（使用常量）
        5:在main()方法中调用定义好的方法（使用变量）
 */
public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法（使用常量）
//        getMax(10,20);  //20
        //调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的
        //getMax(30);
        //getMax(10.0,20.0);

        //在main()方法中调用定义好的方法（使用变量）
//        int a = 100;
//        int b = 2000;
//        getMax(a, b);
    }

    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
    //为方法定义两个参数，用于接收两个数字
    //方法重载    除了方法名一样   其他的啥都不一样
    public static void getMax(int a, int b) {
        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }

}

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

    定义格式：
        public static 数据类型 方法名(参数) {
           return 数据;
       }

   调用格式：
        1:方法名(参数);
        2:数据类型 变量名 = 方法名(参数);
 */
public class MethodDemo {
    public static void main(String[] args) {
        //1:方法名(参数);
        //isEvenNumber(10);
        //true;

        //2:数据类型 变量名 = 方法名(参数);
        boolean flag = isEvenNumber(10);//true
        //boolean flag = true;
        System.out.println(flag);
    }

    //需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数，并返回真假值
    public static boolean isEvenNumber(int number) {
        if(number%2 == 0) {
            return true;
        } else {
            return false;
        }
    }

}

/*
    需求：
        设计一个方法可以获取两个数的较大值，数据来自于参数

    思路：
        1:定义一个方法，用于获取两个数字中的较大数
        2:使用分支语句分两种情况对两个数字的大小关系进行处理
        3:根据题设分别设置两种情况下对应的返回结果
        4:在main()方法中调用定义好的方法并使用变量保存
        5:在main()方法中调用定义好的方法并直接打印结果
 */
public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法并使用变量保存
        int result = getMax(10,20);
        System.out.println(result);

        //在main()方法中调用定义好的方法并直接打印结果
        System.out.println(getMax(99,88));

    }

    //定义一个方法，用于获取两个数字中的较大数
    public static int getMax(int a, int b) {
        //使用分支语句分两种情况对两个数字的大小关系进行处理
        //根据题设分别设置两种情况下对应的返回结果
        if(a > b) {
            return a;
        } else {
            return b;
        }
    }
}

/*
    方法注意事项：
        方法不能嵌套定义
        void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
 */
public class MethodDemo {
    public static void main(String[] args) {
        int i=140;
        methodTwo(i);

    }



    public static int methodTwo(int i) {
        int a=5;
        int sum=i+a;
        System.out.println(sum);   //145
        return sum;


    }

}

/*
    方法重载：
        多个方法在同一个类中
        多个方法具有相同的方法名
        多个方法的参数不相同，类型不同或者数量不同

        与返回值无关
        在调用的时候，Java虚拟机会通过参数的不同来区分同名的方法
 */
public class MethodDemo {
    public static void main(String[] args) {
        //调用方法
        int sums = sums(22,33);
        System.out.println(sums);   //55

        double sum=sum(3.0,4.0);
        System.out.println(sum); //7.0

        int sum1 = sum(1, 2, 3);
        System.out.println(sum1);   //6
    }

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


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


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

}

/*
    需求：
        使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）

    思路：
        1:定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
        2:定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
        3:定义所有的重载方法，两个byte类型与两个short类型参数
        4:完成方法的调用，测试运行结果
 */
public class MethodTest {
    public static void main(String[] args) {
        //调用方法

        System.out.println(compare(10, 20));  //fasle
        System.out.println(compare((byte) 10, (byte) 20));//false
        System.out.println(compare((short) 10, (short) 20));//false
        System.out.println(compare(20L, 20L));//true
    }

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

    //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;
    }

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

}

/*
    对于基本数据类型的参数，形式参数的改变，不影响实际参数的值
 */
public class ArgsDemo01 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number);

        
        int change = change(number);
        System.out.println(change);

    }

    //方法
    public static int change(int number) {
        number = 200+number;
        return number;
    }
}

/*
    对于引用类型的参数，形式参数的改变，影响实际参数的值   作业
 */
/*
    对于引用类型的参数，形式参数的改变，影响实际参数的值   作业
 */
public class ArgsDemo02 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        change(arr);
        change01(arr);
        System.out.println(arr[1]);
        System.out.println(arr[0]);

    }

    public static void change(int[] arr) {
        arr[1] = 3000;
    }
    public static void change01(int[] arr) {
        arr[0] = 6000;
    }
}

/*
    数组遍历

    需求：
        设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]

    思路：
        1:因为要求结果在一行上输出，所以这里需要在学习一个新的输出语句System.out.print(“内容”);
            System.out.println(“内容”); 输出内容并换行
            System.out.print(“内容”); 输出内容不换行
            System.out.println(); 起到换行的作用
        2:定义一个数组，用静态初始化完成数组元素初始化
        3:定义一个方法，用数组遍历通用格式对数组进行遍历
        4:用新的输出语句修改遍历操作
        5:调用遍历方法
 */
public class MethodTest01 {
    public static void main(String[] args) {


        //定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {11, 22, 33, 44, 55};

        //调用方法
        printArray(arr);
    }



    public static void printArray(int[] arr) {
        for(int x=0; x<arr.length; x++) {
            System.out.println(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.println("]");
//    }
}

/*
    数组最大值

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

    思路：
        1:定义一个数组，用静态初始化完成数组元素初始化
        2:定义一个方法，用来获取数组中的最大值
        3:调用获取最大值方法，用变量接收返回结果
        4:把结果输出在控制台
 */
public class test01 {
    public static void main(String[] args) {
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.println("请输入今天是本周的第 天，将为您显示今天的活动");
        int i = s.nextInt();
        if (i < 1 || i >= 8) {
            System.out.println("对不起，输入错误!");
        } else {
            if (i < 2) {
                System.out.println("跑步");
            } else if (i < 3) {
                System.out.println("游泳");
            } else if (i < 4) {
                System.out.println("慢走");
            } else if (i < 5) {
                System.out.println("动感单车");
            } else if (i < 6) {
                System.out.println("拳击");
            } else if (i < 7) {
                System.out.println("爬山");
            } else {
                System.out.println("好好吃一顿");
            }
        }
    }
}

作业

public class test02 {
    public static void main(String[] args) {
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.println("请输入今天是本周的第 天，将为您显示今天的活动");
        int num =s.nextInt();
        switch (num){
            case 1 :
                System.out.println("跑步");
                break;
            case 2 :
                System.out.println("游泳");
                break;
            case 3 :
                System.out.println("慢走");
                break;
            case 4 :
                System.out.println("动感单车");
                break;
            case 5 :
                System.out.println("拳击");
                break;
            case 6 :
                System.out.println("爬山");
                break;
            case 7 :
                System.out.println("好好吃一顿");
                break;
            default :
                System.out.println("对不起，您输入的数字不合法");
        }
    }
}

作业

public class test003 {
    public static void main(String[] args) {
        double num1 = 10;
        double num2 = 5;
        char operator = '+';
        double result = 0;

        switch (operator) {
            case '+':
                result = num1 + num2;
                break;
            case '-':
                result = num1 - num2;
                break;
            case '*':
                result = num1 * num2;
                break;
            case '/':
                if (num2 != 0) {
                    result = num1 / num2;
                } else {
                    System.out.println("Division by zero is not allowed.");
                    return;
                }
                break;
            default:
                System.out.println("Invalid operator.");
                return;
        }

        System.out.println("The result is: " + result);
    }
}

public class zuoye {

    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        sum(numbers);
    }
    public static void sum(int[] numbers) {
        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }
        System.out.println("The sum of the elements in the array is: " + sum);
    }



}

作业

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

        sum('*',1,2);


    }
    public static void sum(char operator,double num1,double num2) {
        double result = 0;
        switch (operator) {
            case '+':
                result = num1 + num2;
                break;
            case '-':
                result = num1 - num2;
                break;
            case '*':
                result = num1 * num2;
                break;
            case '/':
                if (num2 != 0) {
                    result = num1 / num2;
                } else {
                    System.out.println("Division by zero is not allowed.");
                    return;
                }
                break;
            default:
                System.out.println("Invalid operator.");
                return;
        }

        System.out.println("The result is: " + result);

    }
}

JAVA在开发hui
关注
初识有参方法的调用
weixin_46474145的博客
12-12 450
##案例分享从键盘输入五个学员成绩，求出平均成绩和最高成绩。 1、在主方法中建数组收集成绩 2、构造一个求平均值和最大值的方法，将实现数组平均值计算和最大值算法写入其中。 3、在主方法中调用该方法。 public class TestExam { public static void main(String[] args) { System.out.println("请输入5名参数者的成绩："); Scanner sc = new Scanner(System.in)
Java 中 无参·有参 方法的使用
weixin_33850890的博客
07-30 1074
Java 中无参无返回值方法的使用 如果方法不包含参数，且没有返回值，我们称为无参无返回值的方法。 方法的使用分两步： 第一步，定义方法 例如：下面代码定义了一个方法名为 show ，没有参数，且没有返回值的方法，执行的操作为输出 “ welcome to imooc. ” 注意哦： 1、 方法体放在一对大括号中，实现特定的操...
java 怎么设置参数可传可不传
最新发布
weixin_29809927的博客
07-23 269
在Java编程中，我们经常需要编写方法来处理不同的参数。有时候，我们希望某些参数是可选的，也就是说，调用者可以选择传递或者不传递这些参数。在Java中，我们可以通过多种方式实现参数的可选性。本文将详细介绍这些方法，并提供相应的代码示例。 1. 使用重载方法 重载是实现参数可选性的一种简单方法。我们可以为同一个方法名提供多个...
如何调用带参方法
weixin_30448603的博客
03-08 1446
语法如下： 创建带参方法: <访问修饰符> 返回值类型<方法名>(<参数列表>){ //方法的主体 } 调用带参方法: 语法: 对象名.方法名(参数1,参数2,,,,,参数n) 注意参数类型:调用方法使用实际参数(需要方法操作的参数) 转载于:https://www.cnblogs.com/chimingyang/p/5255165.html...
调用带参方式
Annmonth的博客
02-24 791
在定义方法和调用方法时，把参数分别称为形式参数和实际参数，简称形参和实参。实参是在调用方法时传递给方法处理的实际的值。实参可以是常量、变量、表达式、方法等，无论实参是何种类型的量，在进行方法调用时，它们都必须具有确定的值， 以便把这些值传送给形参。发生方法调用时，主调方法把实参的值传送给被调方法的形参从而实现主调方法向被调方法的数据传送。调用带参方法与调用无参方法的语法相同，但是在调用带参方法时必须传入实际的参数的值。实际传入的参数的值的顺序与方法定义中形式参数的顺序是一致的。先实例化对象，再调用方法。
有参方法声明实现及调用
CG-L 的技术博客
03-21 335
关于JS中setTimeout()无法调用带参函数问题的解决方法
10-22
本文介绍了两种解决 JavaScript 中 setTimeout() 无法调用带参函数问题的方法。第一种方法通过重写 setTimeout 函数，实现了一个可以接收额外参数的 setTimeout 版本。第二种方法则通过字符串拼接，在一定条件下简单...
JavascriptBridge:android app 演示 ①android 调用JS 方法，有参和无参 ②JS 调用 android 方法，有参和无参 的一个小例子
05-10
- **调用有参和无参方法：** 在JavaScript中，可以像调用本地函数一样调用暴露的Java方法，传递参数（如果有的话）并在JavaScript中接收返回值。 2. **JS调用Android方法：** - **JavaScript注入：** 可以通过`...
Java中带参无返回值方法的使用共4页.pdf.zip
10-30
本篇文章将详细讲解Java中带参无返回值方法的使用，帮助开发者更好地理解和运用这一核心概念。 1. 方法定义： 在Java中，一个无返回值的方法会被声明为`void`类型。这样的方法没有`return`语句，其主要目的是执行一...
在html中引入外部js文件,并调用带参函数的方法
10-21
这种方法也有助于提升页面加载速度，因为浏览器可以并行加载外部资源。本篇文章将详细讲解如何在HTML中引入外部JS文件，并调用其中的带参数函数。 首先，我们来看一下项目的基本结构。通常，HTML文件（如`test....
JS调用CS里的带参方法实例
10-27
在JS调用CS的带参数方法中，有几个关键点需要注意： - 当使用`<%= %>`标签嵌入JavaScript变量到服务器端代码时，外层使用单引号包围，内部的JavaScript变量则使用双引号。 - 这种嵌入方式实质上是在服务器端脚本中...
java 中函数的参数传递详细介绍
05-20
java 中函数的参数传递详细介绍 java 中函数的参数传递详细介绍
java形参和实参的三种传递方式（值传递，地址传递，引用传递）
weixin_44057803的博客
07-11 7486
博客博客值传递：对形参的修改不会影响到实参引用传递：对形参的修改会影响实参在主函数中 输出结果为： 因为在int j=i 时，这是一个开辟一个新内存，然后将i中的值复制到j中的过程。所以，j中的值改变不会引起i中的值的改变。 代码如下： 输出结果为： 因为在 int *j=&i 时，这是一个开辟一个新内存，然后将i的地址的值传入到j中的过程。所以，*j =20就是访问j中地址（就是i的地址），将20赋值于其中，改变值（等于i=20）。 三、引用传递 代码如下： 输出结果为：因为在 int &j=i 时
Java有参构造方法与无参构造方法（完全理解）
热门推荐
SoulNone的博客
03-05 3万+
Java有参构造方法与无参构造方法（完全理解）
java 可变参数（可传可不传）
weixin_42558305的博客
11-25 7412
因为写方法重载重复的代码会比较多，就改为用可变参数了。 public Map<String, String> xxx(Integer... parflag) {} public Map<String, String> xxx(String... parflag) {} 其中可变参数是一个数组，如果有固定参数的话，可变参数要放在最后。 获取可变参数的值。 if(parflag!=null && parflag.length>0){ System.o
Java方法的调用以及参数传递
weixin_47598133的博客
10-06 5488
周记(9/28-9/) 一.方法的调用及参数的传递 1.方法的调用 1.1 定义方法的语法 [访问修饰符] 返回值类型 方法名([参数类型 参数1,参数类型 参数2,…]){ ​ 方法体 } 详解: 访问修饰符:用于修饰这个方法的调用范围,目前默认public static 返回值类型:无返回值就写void或者方法执行后返回的结果的数据类型,方法执行之后会将结果返回 方法名:给方法取的名字,遵循标识符规则 参数类型,参数名:同时定义,方法在执行时未知的数据,需要在调用
java方法的参数传递的理解
qq_50721317的博客
08-21 1258
java方法的参数传递
66 有参函数的定义和调用
Blog of Lytracy
11-30 2205
文章目录1、引入2、定义有参函数3、调用有参函数4、形式参数和实际参数5、练一练 1、引入 现在需要定义一个函数，这个函数能够完成2个数的加法运算，并且把结果打印出来，该怎样设计？下面的代码可以吗？有什么缺陷吗？ 为了让一个函数更通用，即想让它计算哪两个数的和，就让它计算哪两个数的和，在定义函数的时候可以让函数接收数据，就解决了这个问题，这就是函数的参数。 2、定义有参函数 def functionname([parameterlist]): ['''comments'''] [func
JAVA.带参数方法定义和调用
yyyaif的博客
05-03 3587
1.带参数方法的定义 格式： public static void 方法名( 参数 ){. . . } 格式(单个参数)：public static void 方法名 (数据类型 变量名){ ... } 范例(单个参数)：public static void isEvenNumber (int number){ ... } 格式(多个参数)：public static void 方法名 (数据类型 变量名1，数据类型2 变量名2 ) { ... } 范例(多个参数)：public stat
关于java中参数传递问题（值传递还是引用传递）
lans_g的博客
05-22 391
参数传递问题 首先要明确，在程序设计语言中，将参数传递给方法（函数）的方式有两种： 按值传递：表示方法接收的是调用者提供的值； 按引用传递：表示方法接收的是调用者提供的地址。（引用可以理解为地址） 一个方法可以修改传递引用所对应的变量值，而不能修改传递值所对应的变量值！因为值传递实际上是对值进行拷贝后再传递，不会影响原来的值。 两个重要理解误区： 误区一、值传递和引用传递，区分的条件是传递的内容，如果是个值，就是值传递。如果是个引用，就是引用传递。 误区二、传递的参数如果是基本数据类型，那就是值传递，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值