java方法

System.out.println()，system是类，out是对象，println是方法。

其实就是C语言的函数。

命名规则：首字母小写，驼峰原则

设计原则：原子性，一个方法只完成一个操作。

调用方法：对象名.方法名

Java是值传递

C++有专门的引用回传机制，有值传递，指针传递和引用传递。（就是数据结构当时讲的三种回传方式）

什么是值传递？什么是引用传递？

值传递：指的是在方法调用时，传递的是参数是按值的拷贝传递。
特点：传递的是值的拷贝，也就是传递后就互不相关了。
引用传递：指的是在方法调用时，传递的参数是按引用进行传递，其实传递的是引用的地址，也就是变量所对应的内存空间的地址。
特点：传递的是值的引用，也就是说传递前和传递后都指向同一个引用（也就是同一个内存空间）。

值传递不会改变原参数的值,而是复制值到子方法（子函数）内计算，就同C语言一样，如一下代码：

public class Demo02 {
    public static void main(String[] args) {
        int number = 0;
        System.out.println(number);//结果是0
        addSelf(number);
        System.out.println(number);//结果还是0
    }
    public static void addSelf(int number) {
        number=number+1;
        System.out.println(number);//结果是1
    }
}

#include 
using namespace std;
void test(int a){
    a=a+1;
    cout<< a << endl;//结果为11
}
int main(){
    int a = 10;
    cout<< a << endl;//结果为10
    test(a);
    cout << a << endl;//结果还为10
    return 0;
}

而引用传递，就C++这个最经典，代码如下：

#include 
using namespace std;
void test(int &a){
    a=a+1;
    cout<< a << endl;//结果为11
}
int main(){
    int a = 10;
    cout<< a << endl;//结果为10
    test(a);
    cout << a << endl;//结果为11
    return 0;
}

即子函数的运用的数据是通过类似指针寻找到的地址，即共用的一个空间，子函数中的计算变化，就会影响到主函数里面的值变化。

即方法的名字相同，但是参数不同，可以共存。（卧槽C++也可以，我居然不知道！！！）

重载规则：

• 方法名称必须相同。
• 参数列表必须不同（如个数不同，类型不同，排列顺序不同）
• 返回类型可以相同也可以不相同。
• 只有返回类型不同，不能成为重载。

java的重载：

public class Demo02 {
    public static void main(String[] args) {
        int number = 0;
        double num = 0.0;
        addSelf(number);
        addSelf(num);
        System.out.println(number);
        System.out.println(num);
    }

    public static void addSelf(int number) {
        number=number+1;
        System.out.println(number);
    }
    public static void addSelf(double number){
        number++;
        System.out.println(number);
    }
}

C++的重载：

#include 
using namespace std;
void test(int &a){
    a=a+1;
    cout<< a << endl;//结果为11
}
double test(double x){
    return x*x;
}
int main(){
    int a = 10;
    cout<< a << endl;//结果为10
    test(a);
    cout << a << endl;//结果为11
    double b = 3.14;
    cout << test(b) << endl;//结果为9.8596
    return 0;
}

其操作意思就是main函数也是可以传入参数的，编写代码如下：

package com.niuya.method;

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

使用命令行javac进行编译

PS D:workspacejavaHellosrccomniuyamethod> javac Demo03.java

会生成class文件，这就是编译结果由01代码组成，再用java命令运行，发现错误！

PS D:workspacejavaHellosrccomniuyamethod> java Demo03
错误: 找不到或无法加载主类 Demo03

原因：java要从src文件开始执行，用cd …/返回上级

PS D:workspacejavaHellosrccomniuyamethod> cd ../
PS D:workspacejavaHellosrccomniuya> cd ../
PS D:workspacejavaHellosrccom> cd ../
PS D:workspacejavaHellosrc> java com.niuya.method.Demo03
PS D:workspacejavaHellosrc> java com.niuya.method.Demo03 this is father
args[0]:this
args[1]:is
args[2]:father

以上就完成了命令行传参。

• jdk5开始，java支持传递同类型的可变参数给一个方法。
• 在方法声明中，在指定参数类型后加一个省略号（…)
• 一个方法中只能指定一个可变参数，他必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class Demo04 {
    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        demo04.test(1,2,3,4,5);
    }
    public void test(int x,int... i){
        System.out.println(x);
        System.out.println(i[0]);
        System.out.println(i[3]);
    }
}

个人感觉像数组，设定一个可变的数组一样。

思路同C一样，所以用vscode调试，可以看到函数栈的变化更直接，操作如下：
下面展示一些 内联代码片。

#include 
using namespace std;

int f(int i){
    if (i==1){
        return 1;
    }
    else{
        return i*f(i-1);
    }
}
int main()
{
    int i;
    cin>>i;
    cout< 
运行起来，输入个5，让i等于5，进入第一层递归（i=5）
 
 
再判断进入i-1即第二层(i=4)
 
 
以此类推就到了i等于1的那层
 
 
之后就可以return返回上一层函数栈了
 
最后结果120
 
java这些都一样的。
 
作业 
写一个有加减乘除的计算器。代码如下：
 
import java.util.Scanner;

public class calculator {
    public static void main(String[] args) {
        double first_number;
        double second_number;
        String operator;
        Scanner scanner = new Scanner(System.in);
        System.out.println("欢迎使用计算器，输入退出完成退出，输入其他开始使用");
        while (!scanner.next().equals("退出"))
        {
            System.out.println("开始使用，输入格式为：数值 操作 数值 （即操作要用空格隔开）");
            first_number = scanner.nextDouble();//此处没有空格符则会抛出异常，可能是因为读取不到double，和操作符混在一起了
            operator = scanner.next();
            second_number = scanner.nextDouble();
            switch (operator){
                case "+":
                    System.out.println("完成了加法结果为"+add(first_number,second_number));
                    break;
                case "-":
                    System.out.println("完成了减法结果为"+dec(first_number,second_number));
                    break;
                case "*":
                    System.out.println("完成了乘法结果为"+chen(first_number,second_number));
                    break;
                case "/":
                    if(second_number==0.0){
                        System.out.println("除数不得为零！");
                    }else{
                        System.out.println("完成了除法结果为"+chu(first_number,second_number));
                    }
                    break;
                default:
                    System.out.println("输入操作违法！");
            }
            System.out.println("输入退出完成退出，输入其他继续使用");
        }
    }
    public static double add(double a,double b){
        return a+b;
    }
    public static double dec(double a,double b){
        return a-b;
    }
    public static double chen(double a,double b){
        return a*b;
    }
    public static double chu(double a,double b){
        return a/b;
    }
}