前言

即使再小的帆也能远航

面向对象思想

一、什么是方法？

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