Java学习笔记(No.10)

最新推荐文章于 2024-02-04 08:52:23 发布

学山学海

最新推荐文章于 2024-02-04 08:52:23 发布

阅读量140

点赞数 1

分类专栏：学习笔记文章标签： java

本文链接：https://blog.csdn.net/baidu_28055785/article/details/117635616

版权

学习笔记专栏收录该内容

25 篇文章 0 订阅

订阅专栏

Java方法详解(No.10)

1、方法的含义及设计原则(The Meaning And Design Principle Of The Method)

1.1、方法的含义(Meaning Of Method)

Java方法是语句的集合，它们在一起执行一个功能。

1.1.1、方法是解决一类问题的步骤的有序组合。
1.1.2、方法包含于类或对象中。
1.1.3、方法在程序中被创建，在其它地方被引用。

1.2、方法的设计原则(The Design Principle Of The Method)

Java方法的本意是功能块，就是实现某个功能的语句块的集合。在设计方法的时候，最好保持方法的原子性(即，每一个方法只完成一个功能，有利于后续程序的扩展)。

2、方法的定义与调用(Definition And Call Of Method)

2.1、方法的定义(Definition Of Method)

Java方法类似于其它语言的函数，是一段用来完成特定功能的代码片段。其包含一个方法头和一个方法体。

2.2、方法的语法(Grammar Of Method)

2.2.1、语法格式(Grammatical Format)

其语法格式为：

“修饰符返回值类型方法名称([参数类型1 参数名称1 [,参数类型… 参数名称… [,参数类型n 参数名称n]]]){

…//方法体

return 返回值;//若返回值类型为void，则无需此语句，否则，需要此语句

}”。
2.2.2、参数信息(Parameter Information)
- 2.2.2.1、修饰符：可选的，告诉编译器如何调用该方法，定义了该方法的访问类型。
- 2.2.2.2、返回值类型：有些方法可能会返回值，返回值类型是方法返回值的数据类型；而有些方法执行所需的操作，但没有返回值(这时返回值类型需使用关键字“void”)。
- 2.2.2.3、方法名：是方法的实际名称，方法名和参数表共同构成方法签名。
- 2.2.2.4、参数类型：参数像是一个占位符，当方法被调用时，传递值给参数，这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数，参数是可选的，方法可以不包含任何参数。
  - 2.2.2.4.1、形式参数(即，形参)：在方法被调用时用于接收外界传入的数据。
  - 2.2.2.4.2、实际参数(即，实参)：调用方法时实际传给方法的数据。
- 2.2.2.5、方法体：其包含具体的语句，定义该方法的功能。

2.3、方法的调用(Call Of Method)

Java支持2种调用方法的方式，根据方法是否有返回值来选择。

2.3.1、当方法有返回值时，方法调用通常被当做一个值，如：“int maxNum=max(1,2);”。
2.3.2、当方法无返回值时，方法调用一定是一条语句，如：“System.out.println(“Hello!World!”);。

2.4、示例(Example)

其示例，如以下代码所示。

package com.xueshanxuehai.Method;
public class DefinitionAndCallMethod {
    public static void main(String[] args) {
        System.out.println("调用有参有返回值方法：");
        System.out.println("=============================");
        //实际参数：实际调用传递给方法的参数
        int maxNum = max(1, 2);
        if(maxNum==0){
            System.out.println("2个数字值相等");
        }else{
            System.out.println("2个数字中的最大数字："+maxNum);
        }
        System.out.println("=============================");
        System.out.println("调用无参无返回值方法：");
        System.out.println("=============================");
        testMethod();
        System.out.println("=============================");
    }
    //有参有返回值方法
    //比较2个数字的大小
    //形式参数：定义方法的参数
    public static int max(int num1,int num2){
        int maxNum=0;
        if(num1==num2){
            return 0;//返回数值并终止方法
        }else if(num1>num2){
            maxNum=num1;
        }else{
            maxNum=num2;
        }
        return maxNum;//返回数值并终止方法
    }
    //无参无返回值方法
    public static void testMethod(){
        System.out.println("Hello!World!");
    }
}

其运行结果，如下图所示。

方法的定义与调用运行结果

2.5、注意事项(Matters Needing Attention)

Java方法的参数都是值传递(Value Delivery)，不是地址传递(Address Delivery，[即,引用传递(Reference Delivery)])。

3、方法的重载(Overload Of Method)

方法的重载就是在一个类中，有相同的方法名称，但形参不同的方法。

3.1、重载规则(Overload Rule)

3.1.1、方法名称必须相同。
3.1.2、参数列表必须不同(个数不同/类型不同/参数排列顺序不同等)。
3.1.3、方法的返回类型可以相同也可以不同。
3.1.4、仅仅方法的返回类型不同是不足以成为方法的重载。

3.2、实现理论(Realization Theory)

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，若匹配失败，则编译器报错。

3.3、示例(Example)

其示例，如以下代码所示。

package com.xueshanxuehai.Method;
public class OverloadMethod {
    public static void main(String[] args) {
        System.out.println("方法的重载");
        System.out.println("*****************************");
        System.out.println("调用返回类型int的max方法：");
        System.out.println("=============================");
        int maxNumInt = max(1, 2);
        if(maxNumInt==0){
            System.out.println("2个数字值相等");
        }else{
            System.out.println("2个数字中的最大数字："+maxNumInt);
        }
        System.out.println("=============================");
        System.out.println("调用返回类型double的max方法：");
        System.out.println("=============================");
        double maxNumDouble = max(1.0, 2.0);
        if(maxNumDouble==0){
            System.out.println("2个数字值相等");
        }else{
            System.out.println("2个数字中的最大数字："+maxNumDouble);
        }
        System.out.println("=============================");
        System.out.println("*****************************");
    }
    //比较2个数字的大小，int类型返回值的方法
    public static int max(int num1,int num2){
        int maxNum=0;
        if(num1==num2){
            return 0;//返回数值并终止方法
        }else if(num1>num2){
            maxNum=num1;
        }else{
            maxNum=num2;
        }
        return maxNum;//返回数值并终止方法
    }
    //比较2个数字的大小，int类型返回值的方法
    public static double max(double num1,double num2){
        double maxNum=0.0;
        if(num1==num2){
            return 0.0;//返回数值并终止方法
        }else if(num1>num2){
            maxNum=num1;
        }else{
            maxNum=num2;
        }
        return maxNum;//返回数值并终止方法
    }
}

其运行结果，如下图所示。

方法的重载运行结果

4、命令行传递参数(Command Line Delivery Parameter)

有时候希望运行一个程序时再传递给它参数信息，这时候需要靠传递命令行参数给main()方法实现，如以下代码所示。

package com.xueshanxuehai.Method;
public class CommandLineDeliveryParameter {
    public static void main(String[] args) {
        //args.length 数组长度
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]="+args[i]);
        }
    }
}

其运行结果，如下图所示。

命令行传递参数运行结果

5、可变参数(Variable Parameter)

从Java SE 5[即，JDK5]开始，Java支持传递同类型的可变参数给一个方法。

5.1、语法格式(Grammatical Format)

其语法格式为：

“修饰符返回值类型方法名称([参数类型1 参数名称1 [,参数类型… 参数名称… [,参数类型n 参数名称n]]] [,] 可变参数类型… 可变参数名称){

…//方法体

return 返回值;//若返回值类型为void，则无需此语句，否则，需要此语句

}”。

5.2、示例(Example)

其示例，如以下代码所示。

package com.xueshanxuehai.Method;
public class VariableParameter {
    public static void main(String[] args) {
        //调用可变参数方法
        printMax("(可变参数方法调用1)",11.11,3,22.22,5.5);
        printMax("(可变参数方法调用2)",new double[]{1,9.9,3});
    }
    public static void printMax(String str,double... numbers){
        if(numbers.length==0){
            System.out.println(str+"未传递可变参数!!!");
            return;
        }
        double result=numbers[0];
        //查找可变参数中最大数
        for (int i = 0; i < numbers.length; i++) {
            if(result<numbers[i]){
                result=numbers[i];
            }
        }
        System.out.println(str+"可变参数中最大数："+result);
    }
}

其运行结果，如下图所示。

可变参数方法运行结果

5.3、注意事项(Matters Needing Attention)
- 1、方法声明时，在指定的参数类型后加一个省略号(…)。
- 2、一个方法中只能指定一个可变参数，且必须是方法最后一个参数，任何普通参数都要在它之前声明。

6、递归方法(Recursive Method)

递归方法就是方法自身调用方法自身(如：A方法调用A方法)。

6.1、结构组成

递归结构包括递归头与递归体两个部分。
- 6.1.1、递归头：什么时候不调用自身方法。若没有递归头，将陷入死循环。
- 6.1.2、递归体：什么时候需要调用自身方法。

6.2、示例(Example)

其示例，如以下代码所示。

package com.xueshanxuehai.Method;
public class RecursiveMethod {
    public static void main(String[] args) {
        System.out.println("使用递归方法\r\n5的阶乘(5!)="+f(5));
    }
    //递归方法：如“阶乘”
    //1!=1
    //2!=2*1!=2*1=2
    //3!=3*2!=3*2*1!=3*2*1=6
    //4!=4*3!=4*3*2!=4*3*2*1!=4*3*2*1=24
    //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);
        }
    }
}

其运行结果，如下图所示。

递归方法运行结果

6.3、注意事项(Matters Needing Attention)
- 6.3.1、利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转换为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需的多次重复计算，大大减少了程序的代码量。
- 6.3.2、递归的能力在于用有限的语句来定义对象的无限集合。
- 6.3.3、一般不建议使用递归(能不使用则不使用)，若计算基数越大，则Java栈消耗的内存空间越多，从而程序越容易崩溃(内存溢出)。

7、扩展应用(Extended Application)

实现需求：“写一个控制台计算器，要求实现加减乘除功能，并且能够循环接收新数据，通过用户交互实现”。

思路推荐
- 1、写4个方法：加减乘除。
- 2、利用循环+switch进行用户交互。
- 3、传递需要操作的2个数。
- 4、输出结果。
其功能实现，如以下代码所示。

package com.xueshanxuehai.Method;
import java.util.Scanner;
public class ConsoleCalculator {
    public static void main(String[] args) {
        //写一个控制台计算器，要求实现加减乘除功能，并且能够循环接收新数据，通过用户交互实现。
        Scanner scanner = new Scanner(System.in);//创建扫描器对象scanner
        boolean operator = true;
//        System.out.println("控制台计算器(只能加、减、乘、除计算功能)：");
        while (operator) {
            System.out.println("请输入加、减、乘、除运算符号(只能输入\"+\"、\"-\"、\"*\"、\"/\",若输入其它字符则退出计算)：");
            if (scanner.hasNext()) {
                String str = scanner.next();
                switch (str) {
                    case "+"://加法
                        System.out.println("请输入加法中第1个操作数：");
                        if (scanner.hasNextDouble()) {
                            double dbl1 = scanner.nextDouble();
                            System.out.println("请输入加法中第2个操作数：");
                            if (scanner.hasNextDouble()) {
                                double dbl2 = scanner.nextDouble();
                                System.out.println("(加法运算)" + dbl1 + "+" + dbl2 + "=" + addition(dbl1, dbl2));
                            } else {
                                scanner.next();
                                System.out.println("加法中第2个操作数类型输入有误(请重新开始输入)");
                            }
                        } else {
                            scanner.next();
                            System.out.println("加法中第1个操作数类型输入有误(请重新开始输入)");
                        }
                        break;
                    case "-"://减法
                        System.out.println("请输入减法中第1个操作数：");
                        if (scanner.hasNextDouble()) {
                            double dbl1 = scanner.nextDouble();
                            System.out.println("请输入减法中第2个操作数：");
                            if (scanner.hasNextDouble()) {
                                double dbl2 = scanner.nextDouble();
                                System.out.println("(减法运算)" + dbl1 + "-" + dbl2 + "=" + subtraction(dbl1, dbl2));
                            } else {
                                scanner.next();
                                System.out.println("减法中第2个操作数类型输入有误(请重新开始输入)");
                            }
                        } else {
                            scanner.next();
                            System.out.println("减法中第1个操作数类型输入有误(请重新开始输入)");
                        }
                        break;
                    case "*"://乘法
                        System.out.println("请输入乘法中第1个操作数：");
                        if (scanner.hasNextDouble()) {
                            double dbl1 = scanner.nextDouble();
                            System.out.println("请输入乘法中第2个操作数：");
                            if (scanner.hasNextDouble()) {
                                double dbl2 = scanner.nextDouble();
                                System.out.println("(乘法运算)" + dbl1 + "*" + dbl2 + "=" + multiplication(dbl1, dbl2));
                            } else {
                                scanner.next();
                                System.out.println("乘法中第2个操作数类型输入有误(请重新开始输入)");
                            }
                        } else {
                            scanner.next();
                            System.out.println("乘法中第1个操作数类型输入有误(请重新开始输入)");
                        }
                        break;
                    case "/"://除法
                        System.out.println("请输入除法中第1个操作数：");
                        if (scanner.hasNextDouble()) {
                            double dbl1 = scanner.nextDouble();
                            System.out.println("请输入除法中第2个操作数：");
                            if (scanner.hasNextDouble()) {
                                double dbl2 = scanner.nextDouble();
                                System.out.println("(除法运算)" + dbl1 + "/" + dbl2 + "=" + division(dbl1, dbl2));
                            } else {
                                scanner.next();
                                System.out.println("除法中第2个操作数类型输入有误(请重新开始输入)");
                            }
                        } else {
                            scanner.next();
                            System.out.println("除法中第1个操作数类型输入有误(请重新开始输入)");
                        }
                        break;
                    default://其他情形
                        operator = false;//退出While循环
                        break;
                }
            } else {
                scanner.next();
            }
        }
        System.out.println("加、减、乘、除计算已结束");
        scanner.close();//关闭扫描器对象scanner(若不关闭会一直占用内存空间资源)
    }
    //加法
    public static double addition(double add1, double add2) {
        return add1 + add2;
    }
    //减法
    public static double subtraction(double sub1, double sub2) {
        return sub1 - sub2;
    }
    //乘法
    public static double multiplication(double mul1, double mul2) {
        return mul1 * mul2;
    }
    //除法
    public static double division(double div1, double div2) {
        return div1 / div2;
    }
}

其运行结果，如下图所示。

控制台计算器运行结果

参考资料：

学习网址：Java方法详解

学山学海

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记(No.10)

Java方法详解(No.10)1、方法的含义及设计原则(The Meaning And Design Principle Of The Method)1.1、方法的含义(Meaning Of Method) Java方法是语句的集合，它们在一起执行一个功能。1.1.1、方法是解决一类问题的步骤的有序组合。1.1.2、方法包含于类或对象中。1.1.3、方法在程序中被创建，在其它地方被引用。1.2、方法的设计原则(The Design Principle Of The Method)
复制链接

扫一扫