JavaSE：方法

JavaSE：方法

文章目录

• 前言
• 一、什么是方法？
• 二、方法的定义和调用
• • 1.方法的定义
  • 2.方法调用
• 三、方法的重载
• 四、命令行传参
• 五、可变参数
• 六、递归
• 总结

---

前言

即使再小的帆也能远航

面向对象思想

---

一、什么是方法？

• eg. System.out.println();
  • System：系统的一个类
  • out：System下的一个输出对象
  • println：方法
• Java方法是语句的集合，他们在一起执行一个功能
  • 方法是解决一类问题的步骤的有序组合
  • 方法包含于类或对象中
  • 方法在程序中被创建，在其他地方被引用
• 设计方法的原则：
  • 方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的扩展
• 方法的命名规则：驼峰原则，首字母小写且驼峰

public class Demo01 {
    //main方法
    public static void main(String[] args) {

		//实际参数，实际调用传递给他的参数
        int sum = add(1, 2);
        System.out.println(sum);

        System.out.println("========");
        test();
    }

    //加法
    //形式参数，用来定义作用的
    public static int add(int a,int b){
        return a+b;
    }

    public static void test(){
    //练习2：用while或for循环输出1-1000之间能被5整除的数，并且每行输出3个
        for (int i = 1; i < 1000; i++) {
            if (i % 5 == 0) {
                System.out.print(i + " ");
            }
            if (i % (5 * 3) == 0) {    //每3个换行
                System.out.println();
                //System.out.print("\n");
            }
        }
    }
}

二、方法的定义和调用 1.方法的定义

• Java的方法类似于其他语言的函数，是一段用来完成特定工程的代码片段
• 语法：方法包含一个方法头和一个方法体
  • 修饰符
  • 返回值类型
  • 方法名
  • 参数类型（像是一个占位符；实参，形参）
  • 方法体
• eg. public static void main(String[] args)
  修饰符 修饰符 返回值类型 方法名（参数类型）{方法体}
• 实际参数，实际调用传递给他的参数
• 形式参数，用来定义作用的

public class Demo02 {
    public static void main(String[] args) {
        int i = max(2, 2);
        System.out.println(i);
    }

    //比大小
    public static int max(int a,int b){
        if (a==b) return 0; //遇到return则终止方法
        return a>b?a:b ;
    }
}

2.方法调用

• 调用方法：对象名.方法名（实参列表）
• 拓展了解：值传递（Java都是值传递） 和 引用传递（指针概念）

三、方法的重载

• 定义：在一个类中，有相同的函数名称，但形参不同（类型、个数、顺序不同）的函数

public class Demo02 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        double c = 3.0;
        double d = 4.0;
        System.out.println(max(a,b));   //2     //int,int
        //System.out.println(max(c,a));         //double,int
        System.out.println(max(c,d));   //4.0   //double,double
        System.out.println(max(a,d));   //4.0   //int,double  -->  double,double
        //优先匹配double型，所以调用形参都为double型的max函数，自动将int型的实参强转为double型
        System.out.println(max(a,b,c)); //3.0   //int,int,double  -->  double,double,double
    }

    //比大小
    public static double max(double a,double b){
        if (a==b) return 0; //遇到return则终止方法
        return a>b?a:b ;
    }

    //比大小
    public static int max(int a,int b){
        if (a==b) return 0; //遇到return则终止方法
        return a>b?a:b ;
    }

    //比大小
    public static double max(double a,int b){
        if (a==b) return 0; //遇到return则终止方法
        return a>b?a:b ;
    }

    //比大小
    public static double max(double a,double b,double c){
        if (a==b&&b==c) return 0; //遇到return则终止方法
        return a>b?(a>c?a:c):(b>c?b:c) ;
    }
}

• 仅仅返回类型不同不足以成为方法的重载

四、命令行传参

• 点击 IDEA 最下面一栏的 Terminal 命令行窗口
• cd 进到.java文件层的文件夹
• javac 该.java文件 eg. javac Demo03.java
• cd… 退到 src 文件夹层次
• java 完整包下的运行文件 eg. java com.qia.method.Demo03

---

• eg. java com.qia.method.Demo03 为无传参
• eg. java com.qia.method.Demo03 今天 吃的 0320 兔兔 为有传参
  结果为：
  args[0]今天
  args[1]吃的
  args[2]0320
  args[3]兔兔

五、可变参数

• 也叫做“不定向参数”
• 支持传递同类型的可变参数
• 可变参数必须在参数列表的最后一个

eg. Public void test(int x,int... i){} 

public class Demo04 {
    public static void main(String[] args) {
        //调用可变参数的方法
        Demo04 demo04 = new Demo04();
        demo04.printMax(3,20,9,11,12,4);
    }

    public void printMax(int... i){
        if (i.length==0){
            System.out.println("defeat");
            return;
        }

        int max=0;
        for (int j = 0; j < i.length; j++) {
            if(i[j]>max){
                max=i[j];
            }
        }
        System.out.println(max);
    }
}

六、递归

• 自己调用自己
• 递归结构包括：
  • 递归头（什么时候不调用自身方法，防止死循环）
  • 递归体（什么时候需要调用自身方法）
• 递归一定要有递归出口（终止条件），防止递归死循环造成栈溢出
• 递归深度越大，时间复杂度越大，应尽量少使用递归，递归算法都能转换为非递归算法

public class Demo06 {
    public static void main(String[] args) {
        System.out.println(factorial(3));
    }

    //阶乘  factorial
    //1！  1
    //2！  2*1
    //5！  5*4*3*2*1
    public static int factorial(int n){
        if (n==1){
            return 1;   //返回1的同时结束程序，即边界条件
        }else {
            return n*factorial(n-1);    //先递归再回归，即出栈入栈
        }
    }
}

作业

• 写一个计算器，要求实现加减乘除功能，并且能够循环接收新的数据，通过用户交互实现
• 思路推荐
  • 写4个方法：加减乘除
  • 利用循环+switch进行用户交互
  • 传递需要 *** 作的俩个数
  • 输出结果

import java.util.Scanner;

public class Demo07 {
    public static void main(String[] args) {
        //计算器：加减乘除
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入：");
        double a = scanner.nextDouble();
        while (scanner.hasNext()) {
            String c = scanner.next();
            double b = scanner.nextDouble();
            a = op(a,c,b);
            if (a==0){
                System.out.println("输入非法字符");
                break;
            }
            System.out.println(a);
        }
        scanner.close();
    }

    public static double op(double a,String c,double b){
        switch (c){
            case "+":
                return a+b;
            case "-":
                return a-b;
            case "*":
                return a*b;
            case "/":
                return a/b;
            default:
                return 0;
        }
    }
}

代码还可以优化… …

---

总结

即使再小的帆也能远航