从“追求尽量不出错”，到正视“出错是必然”的转变,才是微服|
收藏闪存小组博问

如此而已~~~

园龄：3年3个月粉丝：0关注：12

04_Java中的方法

Java中的方法

一、方法概述

1、方法：就是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

2、注意：

方法必须先创建才可以使用，该过程称为定义方法的定义

方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为方法的调用

二、方法的定义和调用

1、方法的定义：

格式：

public static void 方法名(){
    //方法体
}
2、方法的调用：

格式：

方法名();	//此处之所以是这样调用只是因为是在类中调用 在类外时注意作用域

注意：方法必须 先定义在调用，否则程序将报错

3、参考代码：
package com.itheima_01;
/*
方法的定义与调用
*/
public class MethodDemo {
    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);
        }
    }
}

三、方法调用过程

1、代码示例：

public class MethodDemo {
    public static void main(String[] args) {	//1、程序先从main方法开始执行
        isEvenNumber();		//2、运行方法调用
        //4、方法调用结束回到main方法
    }
 
    public static void isEvenNumber(){	//3、执行方法体
        //定义变量
        int number = 10;
 
        //判断该数据是否是偶数
        if(number % 2 == 0){
            System.out.println(true);
        }
        else{
            System.out.println(false);
        }
    }
}

2、方法练习：

package com.itheima_01;
/*
方法练习之 实现打印两个数中的较大值
 */
public class MethodTest {
    public static void main(String[] args) {
        //在main方法中调用方法
        getMax();
    }
 
    public static void getMax(){
        //定义两个数
        int num1 = 100;
        int num2 = 200;
 
        //定义一个变量接收较大值并输出
        int max = (num1 > num2)? num1 : num2;
 
        System.out.println(max);
    }
}

四、带参数的方法的定义和调用

1、带参数方法的定义：

1、格式：

public static void 方法名(参数){
    //方法体
}
 
//单个参数
public static void 方法名(数据类型 变量名){
    //方法体
}
 
//多个参数
public static void 方法名(数据类型1 变量名1, 数据类型2 变量名2,......){
    //方法体
}

2、注意：

方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错

方法定义时，多个参数之间使用逗号(, )分隔

2、带参数方法的调用：

1、格式：

方法名(参数);
 
//单个
方法名(变量名/常量值);
 
//多个
变量名(变量名1/常量值1, 变量名2/常量值2...);
3、（1和2的）参考代码：
package com.itheima_02;
 
//导包
import java.util.Scanner;
 
public class MethodDemo {
    public static void main(String[] args) {
 
        //一、常量值的调用
        isEvenNumber(66);
        System.out.println("------------------");
 
        //二、变量值的调用
        //创建对象
        Scanner sc = new Scanner(System.in);
 
        //定义一个变量来接收数据
        System.out.println("请输入一个数据整型：");
        int num = sc.nextInt();
 
        //方法的调用
        isEvenNumber(num);
 
    }
 
    //需求，定义一个方法，该方法接收一个参数，判断该数据是否是偶数
    public static void isEvenNumber(int number){
        if(number % 2 == 0){
            System.out.println("该数是一个偶数");
        }
        else{
            System.out.println("该数不是一个偶数");
        }
    }
 
}
4、形参和实参：

1、形参：方法定义中的参数

​ 等同于变量定义格式，例如：int number

2、实参：方法调用中的参数

​ 等同于使用变量或常量，例如：10， number

5、带参数方法练习：
package com.itheima_02;
/*
使用带参函数判断两个数的大小
 */
public class MethodTest {
    public static void main(String[] args) {
        //常量调用
        getMax(10, 90);
        System.out.println("-------------------");
 
        //变量调用
        int num1 = 66;
        int num2 = 99;
        getMax(num1, num2);
 
 
    }
 
    public static void getMax(int num1, int num2){
        //判断两个数中较大的数并将其打印
        if(num1 > num2){
            System.out.println("两个数中较大数为：" + num1);
        }
        else{
            System.out.println("两个数中较大数为：" + num2);
        }
    }
}

五、带返回值方法的定义和调用

1、带返回值方法的定义：

1、格式：

public static 数据类型 方法名(参数){
    return 数据;
}
 
//示例1：
public static boolean isEvenNumber(int number){
    return true;
}
 
//示例2：
public static int getMax(int a, int b){
    return 100;
}

2、注意：

方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序报错

2、带返回值方法的使用：

1、格式

//格式一：
方法名(参数);
 
//示例
isEvenNumber(5);
 
//格式二(接受了返回值)：
数据类型 变量名 = 方法名(参数);
boolean flag = isEvenNumber(5);

2、注意：

方法的返回值通常会使用变量接收，否则改返回值将无意义

3、代码示例：
package com.itheima_03;
 
public class MethodDemo {
    public static void main(String[] args) {
        //方式一：
        //isEvenNumber(40);
        //对返回值没有进行操作
 
        //方式二：
        //定义一个变量用于接受返回值
        boolean flag = isEvenNumber(60);
        System.out.println(flag);
 
    }
 
    //需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数，并返回真假
    public static boolean isEvenNumber(int number){
        if(number % 2 == 0){
            return true;
        }
        else{
            return false;
        }
    }
}
4、带返回值方法练习：
package com.itheima_03;
/*
用有返回值的方法实现返回两个数中的最大值
 */
public class MethodTest {
    public static void main(String[] args) {
        //定义一个变量来接收结果
        int result = getMax(10, 20);
        System.out.println(result);
 
    }
 
    public static int getMax(int num1, int num2){
        if(num1 > num2){
            return num1;
        }
        else{
            return num2;
        }
    }
}

六、方法的注意事项

1、方法是是平级关系是不能进行嵌套定义的

2、void表示无返回值的，可以省略return，也可以单独的书写return，后面不加数据 例如：return;

3、参考代码：

package com.itheima_04;
/*
方法注意事项
 */
public class MethodDemo {
    public static void main(String[] args) {
 
    }
 
    public static void methodOne(){
 
    }
 
    public static void methodTwo(){
        return; //这样写只是表示这个方法结束了 后续语句不在执行
    }
}

七、方法的通用格式

1、格式：

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

解释：

public static 修饰符，目前记住这个格式

返回值类型 方法操作完毕之后返回的数据的数据类型，如果方法操作完毕，没有数据返回，这里写void，且方法中一般不写return

方法名 调用方法时候使用的标识

参数 由数据类型和变量名组成，多个参数之间用逗号隔开

方法体 完成功能的代码块

return 如果方法操作完成，有数据返回，用于把数据返回给调用者

2、定义方法时的两个明确

​ 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void，如果有，写对应的数据类型

​ 明确参数：主要是明确参数的类型和数量

3、调用方法时

​ void类型的方法，直接调用即可

​ 非void类型的方法，推荐用变量接收调用

八、方法重载

1、方法重载的概述：

指的是同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

2、条件：

​ 多个方法都在同一个类中

​ 多个方法具有相同的方法名

​ 多个方法的参数不相同（类型或数量），类型不同或者数量不同

3、方法重载的特点：

​ 重载仅对应方法的定义，与方法调用无关，调用格式还是依据对应调用的格式

​ 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定

两个方法是否构成重载

4、代码示例：

package com.itheima_05;
/*
求和方法重载
 */
public class MethodDemo {
    public static void main(String[] args) {
        //调用方法
        int result = mySum(10, 20);
        System.out.println(result);
 
        double result2 = mySum(10.34, 24.66);
        System.out.println(result2);
 
        int result3 = mySum(66, 88 ,99);
        System.out.println(result3);
 
    }
 
    //需求1，求两个int类型数据和的方法
    public static int mySum(int num1, int num2){
        return num1 + num2;
    }
 
 
    //需求2，求两个double类型数据和的方法
    public static double mySum(double num1, double num2){
        return num1 + num2;
    }
 
 
    //需求3，求三个int类型数据和的方法
    public static int mySum(int num1, int num2, int num3){
        return num1 + num2 + num3;
    }
}

5、方法重载的练习：

package com.itheima_05;
/*
方法重载的练习
 */
public class MethodTest {
    public static void main(String[] args){
        //定义boolean变量接收数据
        boolean flag1 = compare(10, 20);
        System.out.println(flag1);
 
        boolean flag2 = compare(1000000000L, 1000000000L);
        System.out.println(flag2);
 
        //由于整数默认为int 需要强制转换或者定义对应类型变量传入
        boolean flag3 = compare((byte)20, (byte)20);
        System.out.println(flag3);
 
        boolean flag4 = compare((short)10, (short)40);
        System.out.println(flag4);
 
    }
 
    //定义四个方法重载
    public static boolean compare(int num1, int num2){
        System.out.println("int");
        return num1 == num2;
    }
 
    public static boolean compare(long num1, long num2){
        System.out.println("long");
        return num1 == num2;
    }
 
    public static boolean compare(byte num1, byte num2){
        System.out.println("byte");
        return num1 == num2;
    }
 
    public static boolean compare(short num1, short num2){
        System.out.println("short");
        return num1 == num2;
    }
}

九、方法的参数传递

1、方法参数传递（基本类型）：

1、对于基本数据类型的参数，形参无法修饰实参

2、参考代码（根据传入的实参形式决定，Java删除了指针，如果不使用引用（目前已知引用）传参则形参无法修饰实参）

package com.itheima_06;
/*
对于基本数据类型形参无法修饰实参
 */
public class ArgsDemo01 {
    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;
    }
}
2、方法的参数传递（引用类型）：

1、对于引用数据类型的参数，形参可以修饰实参

2、参考代码（以数组名为例）：

package com.itheima_06;
/*
对于引用类型形参可以修饰实参
 */
public class ArgsDemo02 {
    public static void main(String[] args) {
        //定义一个数组类型
        int[] arr = {11, 22, 33, 44, 55};   //int[] 表示一个数组类型 变量是arr
 
        //方法调用前
        System.out.println("调用change方法前：" + arr[1]);
 
        //方法调用后
        change(arr);
        System.out.println("调用change方法后：" + arr[1]);
    }
 
    public static void change(int[] arr){   //int[] 表示一个数组类型 变量是arr
        arr[1] = 200;
    }
}
3、方法的参数传递案例：

1、数组的遍历：

package com.itheima_07;
/*
数组遍历：设计一个方法用于实现数组遍历，要求结果是在一行上
 */
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循环来遍历
        System.out.print("[");
 
        for(int i = 0; i < arr.length; i++){
            if(i < arr.length - 1){
                System.out.print(arr[i] + ", ");
            }
            else{
                System.out.print(arr[i]);
            }
        }
 
        System.out.println("]");
    }
}

2、数组最大值：

package com.itheima_07;
 
public class MethodTest02 {
    public static void main(String[] args){
        //定义一个数组
        int[] arr = {12, 46, 66, 24, 50, 33};
 
        //调用方法
        int result = maxArray(arr);
        System.out.println(result);
 
    }
 
    public static int maxArray(int[] arr){
        //定义一个变量接收数组最大值并返回
        int max = arr[0];
 
        //使用for循环找到最大值
        for(int i = 1; i < arr.length; i++){
            //判断
            if(max < arr[i]) {
                max = arr[i];
            }
        }
        //返回结果
        return max;
    }
}

本文作者：编程初学者求大佬指点

本文链接：https://www.cnblogs.com/fragmentary/p/16732651.html

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   如此而已~~~  阅读(71)  评论(0)  编辑  收藏  举报
    //雪花飘落效果
    点击右上角即可分享
    微信分享提示
    AI IDE Trae
    评论
    收藏
    关注
    推荐
    深色
    回顶
    收起
    ✽
    ✽