方法

System.out.println();//是什么吗?
//系统类+对象+方法

Java方法是一对语句的集合,他们一起负责执行一个功能
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建,在其他地方被引用
设计原则: 方法本意是功能块(类似C语言的函数), 就是实现某个功能的语句块集合,设计方法最好保持方法的原子性,就是一个方法只完成1个功能,这样有利于后期的扩展
命名规范: 首字母小写+驼峰规则
方法都是写在main外面的

package Method;

public class Demo_0 {
    public static void main(String[] args) {
        //调用了add方法
        			//实参
        int sum = add(1, 2);//int sum = add(1, 2);
        System.out.println(sum);
        //System.out.println(add(1, 2));
        System.out.println(\"======================================\");

        //调用test
        test();
    }

    //加法					形式参数
    public static int add(int a, int b) {//有返回值需要int等类型
        return a + b;//返回值
    }

    //方法2
    public static void test() {//返回值为空void
        //while循环输出1~1000之间被5整除的数,并且3个每行
        int i_1 = 0;
        while (i_1 <= 1000) {
            ++i_1;
            if (i_1 % 5 == 0) {
                System.out.print(i_1 + \"\\t\\t\");//不要加ln
            }    //println输出后会自动换行
            if (i_1 % (5 * 3) == 0) {
                System.out.println();
            }
        }

    }

}
//此段代码不显示图片, 自身去试试代码

方法的定义

方法包含一个方法头和一个方法体
- **修饰符: **是可选的, 让编译器知道如何调用方法, 并且定义了方法的访问类型
- 返回值类型: 方法会有返回值, return ValueType是方法返回值的数据类型;,修饰符中需要使用static; 倘若方法无需返回值, 需要使用关键字void
- **方法名: **方法的实际名称, 方法名和参数表共同构成方法签名
- **参数类型: **参数类似一个占位符, 当方法需要调用时, 传递给参数, 这个值被称为实参或者变量;参数列表是指方法的参数类型、顺序和参数的个数; 参数是可选的,意思就是方法名可以不包含任何参数
  - 形式参数: 在方法被调用时用于接收外界输入的数据(类似add(int a, int b)中的a与b)
  - 实参: 调用方法的时实际传递给方法的数据(类似add(1, 2)中的1与2)
- **方法体: **方法体包含具体的语句、定义方法的功能
```
修饰符 返回值类型 方法名(参数类型 参数名){
    //修饰符包含了static或者void
	...
	方法体
	...
	return 返回值;
}
```

方法调用

```
//对象名.方法名(实参列表)
```
Java支持调用方法的方式有两种,根据方法是否返回值来选择
当方法返回一个值的时候, 方法调用通常直接当作一个值
- ```
    int larger = Max(30, 40);
```
若返回值时void, 方法调用是一条语句
Java是值传递(暂且知道就行)

package Method;

import java.util.Scanner;

public class Demo_1 {
    public static void main(String[] args) {
        System.out.println(\"比谁大\");
        System.out.print(\"Input Number_1: \");
        Scanner Input = new Scanner(System.in);//创建一个名字\"Input\"的扫描器
        int Number_1 = Input.nextInt();//用next方法接收
        //nextInt()接收int类型的数值
        //
        System.out.print(\"Input Number_2: \");
        Scanner Input2 = new Scanner(System.in);//创建一个名字\"Input\"的扫描器
        int Number_2 = Input2.nextInt();
        System.out.println(\"\\t两个数中这个最小: \" + Max(Number_1, Number_2));
        System.out.println(\"============================================\");
        System.out.println(\"比谁小\");
        System.out.print(\"Input Number_3: \");
        Scanner Input_Num3 = new Scanner(System.in);//创建一个名字\"Input\"的扫描器
        int Number_3 = Input.nextInt();//用next方法接收
        //nextInt()接收int类型的数值
        
        System.out.print(\"Input Number_4: \");
        Scanner Input_Num4 = new Scanner(System.in);//创建一个名字\"Input\"的扫描器
        int Number_4 = Input2.nextInt();
        System.out.println(\"\\t两个数中这个最小: \" + Min(Number_3, Number_4));
    }

    //两个数比大小,输出大的
    public static int Max(int a, int b) {
        if (a == b) {
            System.out.println(\"\\tNumber_1 == Number_2\");
            //return 0; //终止方法
            return a;
        } else if (a > b) {
            System.out.println(\"\\t两个数中Number_1最大\");
            return a;
        } else {
            System.out.println(\"\\t两个数中Number_2最大\");
            return b;
        }
    }
    //

    //两个数比大小,输出小的
    public static int Min(int x, int y) {
        if (x == y) {
            System.out.println(\"\\tNumber_3 == Number_4\");
            return x;
        } else if (x < y) {
            System.out.println(\"\\t两个数中Number_3最小\");
            return x;
        } else {
            System.out.println(\"\\t两个数中Number_4最小\");
            return y;
        }
    }
    //
}

方法重载

重载就是在一个类中,有相同函数名称, 但形参不同的函数
重载规则
- 方法名必须相同
- 参数列表必须不同(个数, 类型, 参数排列顺序不同等)
- 方法返回的类型可相同也可不通
- 仅仅返回类型不同不足以成为方法重载
实现理论: 方法名称相同时,编译器会根据调用方法的参数个数,参数类型等逐个匹配, 以选择对应的方法,如果匹配失败,则编译器报错
重载与返回值无关(返回类型可相同也可不同)

package Method;

import java.util.Scanner;

public class Demo_1 {
    public static void main(String[] args) {
        //System.out.println(\"比谁大\");
        //System.out.print(\"Input Number_1: \");
        //Scanner Input = new Scanner(System.in);//创建一个名字\"Input\"的扫描器
        //int Number_1 = Input.nextInt();//用next方法接收
        ////nextInt()接收int类型的数值
        //
        //System.out.print(\"Input Number_2: \");
        //int Number_2 = Input.nextInt();
        //System.out.println(\"\\t两个数中这个最小: \" + Max(Number_1, Number_2));
        //Input2.close();
        //Input.close();
        //System.out.println(\"==============================================\");
        //System.out.println(\"比谁小\");
        //System.out.print(\"Input Number_3: \");
        //Scanner Input = new Scanner(System.in);//创建一个名字\"Input\"的扫描器
        //int Number_3 = Input.nextInt();//用next方法接收
        ////nextInt()接收int类型的数值
        //
        //System.out.print(\"Input Number_4: \");
        //int Number_4 = Input.nextInt();
        //System.out.println(\"\\t两个数中这个最小: \" + Min(Number_3, Number_4));
        //Input_Num3.close();
        //Input_Num4.close();
        ///////////////////
        System.out.println(\"比谁大\");
        System.out.print(\"Input Number_1: \");
        Scanner Input = new Scanner(System.in);//创建一个名字\"Input\"的扫描器
        double Number_1 = Input.nextDouble();//用next方法接收
        //nextInt()接收int类型的数值

        System.out.print(\"Input Number_2: \");
        double Number_2 = Input.nextDouble();//若nextDouble变为nextInt不会出崔,但最后结果会跟随最开头的Double
        System.out.println(\"\\t两个数中这个最小: \" + Max(Number_1, Number_2));
        Input.close();
        Input2.close();
    }


    //两个数比大小,输出大的
    public static int Max(int a, int b) {
        if (a == b) {
            System.out.println(\"\\tNumber_1 == Number_2\");
            //return 0; //终止方法
            return a;
        } else if (a > b) {
            System.out.println(\"\\t两个数中Number_1最大\");
            return a;
        } else {
            System.out.println(\"\\t两个数中Number_2最大\");
            return b;
        }
    }

    public static double Max(double a, double b) {//针对Max()方法的重载;返回double类型
        if (a == b) {
            System.out.println(\"\\tNumber_1 == Number_2\");
            //return 0; //终止方法
            return a;
        } else if (a > b) {
            System.out.println(\"\\t两个数中Number_1最大\");
            return a;
        } else {
            System.out.println(\"\\t两个数中Number_2最大\");
            return b;
        }
    }
    //


    //两个数比大小,输出大的
    public static int Min(int x, int y) {
        if (x == y) {
            System.out.println(\"\\tNumber_3 == Number_4\");
            return x;
        } else if (x < y) {
            System.out.println(\"\\t两个数中Number_3最小\");
            return x;
        } else {
            System.out.println(\"\\t两个数中Number_4最小\");
            return y;
        }
    }
    //
}

注释了的代码可全部解开, 试试输入的double类型和int类型的,最后输出若有.0就是double类型;注意更改我代码中Scanner等变量

命令行传参(可以简单了解)

以下代码是需要在java文件的路径下用cmd进行编译,参考Hello.java
以下代码需要用更改编码格式才可编译

javac -encoding utf8 CmdTran.java
     //编码格式

package Method;//注意自己的包名

public class CmdTran {//注意自己的文件名
    public static void main(String[] args) {
        //命令行传参
        for (int i = 0; i < args.length; i++) {
            System.out.println(\"args[\" + i + \"] = \" + args[i]);
        }
    }
}

cmd窗口解析
- 在java文件的所在路径下编译java文件
- cd ../回退上一级文件夹(可以体会下在其他文件下引用自己写的java文件)
- 运行编译好的java文件(为何没有输出, 因为我们的java代码是需要将参数输出, 我并没有参数输入)
- 再一次运行java文件, 在java Method.CmdTran输入四个参数I am your Father
- 输出了四个刚刚输入的参数(数组下标由0开始)

可变参数(不定项参数)

在JDK 1.5开始, Java支持传递同类型的可变参数给一个方法
方法声明中, 在指定参数类型后加一个省略号(...)
一个方法中只能指定一个可变参数, 它必须是方法的最后一个参数; 任何普通的参数必须在它之前声明
在一开始写方法时,会有很多不确定变量, 我们需要写多种方法(方法重载), 而每种方法都是只实现一个功能,依次针对不同情况

package Method;

public class ChangeData {
    public static void main(String[] args) {
        ChangeData cd = new ChangeData();//创建类的对象
        cd.test(1.5F, 222, 3, 2);//创建一个对象cd, 并使用类中的test方法
    }		  //x:1.5 i:222, 3, 2

    public void test(float x, int... i) {
        //不知道要传入多少参数
        System.out.println(x + \" \" + i[0] + \" \" + i[2]);
    }
}

变长参数是 Java 的一个语法糖，本质上还是基于数组的实现：

package Method;

public class ChangeData {
    public static void main(String[] args) {
        printMax(21, 25, 2, 56);
        printMax(new double[]{1, 2, 5, 6, 7, 8, 9});//本质是数组因此可以用数组形式
    }
    public static void printMax(double... number) {
        if (number.length == 0) {//当数组长度=0
            System.out.println(\"No argument passed\");
            return;
        }

        double max = number[0];//初始化
        //找出最大值
        for (int i = 1; i < number.length; i++) {
            if (number[i] > max) {
                max = number[i];
            }
        }
        System.out.println(\"The Max value is \" + max);
    }
}

递归

A方法调用A方法! 自己调用自己
思想: 简单程序解决复杂问题; 把大型复杂的问题层层转化为一个与原问题相似的规模较小问题来求解
递归结构: 递归头就是啥时候不调用自己,如果没有就陷入死循环
递归结构: 递归体就是啥时候调用自身方法
虽然代码量简单且少,但会占用很多空间

package Method;

public class InterJava {
    public static void main(String[] args) {
        InterJava inter = new InterJava();
        // 没有递归头, 写会错误(栈溢出)
        System.out.println(inter.f(5));
    }

    //5! = 1*2*3*4*5
    public static int f(int n) {
        if (n == 1) {//递归头
            return 1;
        } else {//递归体
            return n * f(n - 1);
        }
    }
}

递归: 本质就是当我调用时, 只要我调用方法时没用到递归头的条件我就必须使用递归体语句从而不断缩小了问题的本质, 当进行递归体语句时,就可以将递归体语句的结果不断返回上去

计算器实现

计算器,实现加减乘除,并能循环接收新数据,通过交互实现

package Method;//注意包名

import java.util.Scanner;//创建输入对象需要的包

public class Counter {//注意类名
    public static void main(String[] args) {
        //计算器,实现加减乘除,并能循环接收新数据,通过交互实现
        /*
        写4个方法:
        加减乘除
        利用循环+ switch进行用户交互
        传递需要操作的两个数
        输出结果
         */
        Scanner scanner = new Scanner(System.in);//创建输入
        String m = \"Y\";//初始化循环条件
        while (m.equals(\"Y\")) {
            System.out.print(\"请输入第一个数:\");//输入数值
            int x = scanner.nextInt();

            System.out.print(\"请输入运算符:\");//输入运算符,作为switch条件
            String o = scanner.next();

            System.out.print(\"请输入第二个数:\");//输入数值
            int y = scanner.nextInt();

            int result = 0;//初始化结果变量

            switch (o) {//根据运算符变量,选择一个case
                case \"+\":
                    result = Add(x, y);
                    break;
                case \"-\":
                    result = Sub(x, y);
                    break;
                case \"*\":
                    result = Mul(x, y);
                    break;
                case \"/\":
                    result = Div(x, y);
                    break;
                default:
                    System.out.print(\"输入错误\");
            }
            
            System.out.println(x + o + y + \"=\" + result);

            System.out.print(\"是否继续下一组计算(Y/N): \");
            m = scanner.next();//重新定义循环条件;输入N就跳出while
        }
        scanner.close();//关闭IO
        System.out.println(\"老子写的计算器牛逼吧!!!\");
    }

    //加减乘除的方法定义
    public static int Add(int a, int b) {
        return a + b;
    }

    public static int Sub(int c, int d) {
        return c - d;
    }

    public static int Mul(int e, int f) {
        return e * f;
    }

    public static int Div(int g, int h) {
        return g / h;
    }
}

计算器可以对其数据类型更改为double类型, 让其除法运算有更高的精度;
思路:
1. 对加减乘除方法进行编写
2. 思考利用什么条件来对switch条件进行判断运算选择(利用运算符)
3. 由于条件需要循环不断接收数值, 所以利用while语句的判定, 并且在一次循环结尾重新定义while语句的判定,判断是否再一次进行二元运算

本文来自博客园，作者：Wo_OD，转载请注明原文链接：https://www.cnblogs.com/WoOD-outPut/p/17035921.html

来源：https://www.cnblogs.com/WoOD-outPut/p/17035921.html
本站部分图文来源于网络，如有侵权请联系删除。

Java方法

方法

方法的定义

方法调用

方法重载

命令行传参(可以简单了解)

可变参数(不定项参数)

递归

计算器实现

相关推荐

热门文章