Java的方法是语句的集合， 一起执行一种功能 。

方法的命名 驼峰命名发 appleBoyDog![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/02/26/kuangstudyf9763521-fa5e-4718-94aa-333e48634e1c.png)
```java
public static a{
    //String[] args 是一个数组
    public static void main(String[] args){
        //这个1 2 的实参
        int add =add(1,2);
        System.out.println("add");
    }
    //内变量  保持原子性 一个方法一个功能 这个ab是形参
    public static int add(int a, int b ){
        return a+b;
    }
    //重载 方法名称相同 参数列表不同， 方法返回值可以相同可以不同
    public static double （double a,double b){}
        return a+b;
    }
}
```
idea执行java xxx.java要在src目录下 java是要有完整目录
```java
package com.cjg.javaBasics;

public class Method {
    public static void main(String[] args) {
        for (int i = 0; i <args.length ; i++) {
            System.out.println("args["+i+"]"+args[i]);
        }
    }
}
```
![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/02/26/kuangstudyb5c28ce4-a721-43f3-888b-30c9bd53db26.png)
![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/02/26/kuangstudy35c7e9e5-838d-47f3-bd0c-2af1d5008f5a.png)
```java
package com.cjg.javaBasics;

public class Change {
    public static void main(String[] args) {
        Change change = new Change();
        change.test(1,2,3,3);
    }
    //只能放在最后
    public void  test(int c,int ... a){
        System.out.println(c);
        for (int i = 0; i <a.length ; i++) {
            System.out.println(a[i]);
        }

}
}
```
# 递归
```java
package com.cjg.javaBasics;

public class diGui {
    public static void main(String[] args) {
        diGui diGui = new diGui();
        int f = diGui.f(3);
        System.out.println(f);
    }
    // 不是1返回 嫁入为3 3*f(2) f(2) =n*f(1) 所以 为3 * 2 *1；
    public int f(int n){
        if(n==1){
            return 1;
        }else return n*f(n-1);
    }
}
//学习思想 不一定是最好程序
//java 是栈机制 东西太多 占用太多内存 ，小地方用递归，大地方向其他算法
```
# 值传递和引用传递
![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/02/26/kuangstudye609e223-c06d-4e24-b496-f7cb87ba3b79.png)
如图所示，num是基本类型，值就直接保存在变量中。而str是引用类型，变量中保存的只是实际对象的地址。一般称这种变量为"引用"，引用指向实际对象，实际对象中保存着内容。

也就说 引用传递是传一个地址， 不改变值，值传递直接保存的变量中

赋值运算符会改变引用中所保存的地址，原来的地址被覆盖掉。但是原来的对象不会被改变（重要）
# 计算器
```java
package com.cjg.javaBasics;

import java.util.Scanner;

public class Calculator {
    public static void main(String[] args) {

String exit ="a";
        while(exit=="a"){
            System.out.println("请输入+-*/ 输入e退出");
            Scanner scanner = new Scanner(System.in);
            String next = scanner.next();
            switch (next){
                case "+" :
                    System.out.println("输入两个数 以回车分割");
                    Scanner scanner1 = new Scanner(System.in);
                    double v = scanner1.nextDouble();
                    double v1 = scanner1.nextDouble();
                    //获取多个
           /*     String[] s = scanner1.nextLine().split(" ");
                int[] i =new int[s.length];
                for (int j = 0; j <s.length ; j++) {
                    i[j]=Integer.parseInt(s.[j]);
                }*/
                    System.out.println(add(v,v1));
                    break;
                case "-" :
                    System.out.println("输入两个数 以回车分割");
                    Scanner scanner2 = new Scanner(System.in);
                    double z = scanner2.nextDouble();
                    double z1 = scanner2.nextDouble();
                    System.out.println(substract(z,z1));
                    break;
                case "*" :
                    System.out.println("输入两个数 以回车分割");
                    Scanner scanner3 = new Scanner(System.in);
                    double q = scanner3.nextDouble();
                    double q1 = scanner3.nextDouble();
                    System.out.println(multiply(q,q1));
                    break;
                case "/" :
                    System.out.println("输入两个数 以回车分割");
                    Scanner scanner4 = new Scanner(System.in);
                    double w = scanner.nextDouble();
                    double w1 = scanner4.nextDouble();
                    System.out.println(divide(w,w1));
                    break;
                case  "e" :
                    exit="e";
                    break;

}
        }

}

public static double add(double ... doubles){
        double sum = 1.0;
        for (int i = 0; i <doubles.length ; i++) {
            sum=sum*doubles[i];
        }
        return sum;
    }
    public static double substract(double a,double ... doubles){
        double sum = a;
        for (int i = 0; i <doubles.length ; i++) {
            sum=sum-doubles[i];
        }
        return sum;
    }
    public static double multiply(double ... doubles){
        double sum = 1.0;
        for (int i = 0; i <doubles.length ; i++) {
            sum=sum*doubles[i];
        }
        return sum;
    }
    public static double divide(double a,double ... doubles){
        double sum = a;
        for (int i = 0; i <doubles.length ; i++) {
            sum=sum/doubles[i];
        }
        return sum;
    }
}
```

Java复习一方法可变参数递归值传递引用传递 java计算器

总共已有 0 条评论

Java复习一 方法 可变参数 递归 值传递引用传递 java计算器

总共已有 0 条评论

Java复习一方法可变参数递归值传递引用传递 java计算器