参数

参数（parpamter）：

参数分为形式参数和实际参数，打一个比方在高中的函数中F（x，y）=x^2+2y-3，将x=3，y=7代入函数，得到33+27-3=20,这里分F（x，y）就是形式参数，3与7就是实际参数。参数是自变量。而F（x，y）函数，既代码中的方法是因变量，是一个逻辑执行的结果。形参是在方法定义阶段，实参是在方法调用阶段，我们举一个列子来看看参数的传递

public class param {
    private static int intStatic=222;
    private static String StringStatic="old string";
    private static StringBuilder stringBuilder=new StringBuilder("old stringBuilder");

    public static void main(String[] args) {
       method(intStatic);//A方法过后
        System.out.println(intStatic);
       method(StringStatic);//B
        System.out.println(StringStatic);
       method(stringBuilder,stringBuilder);//C
        System.out.println(stringBuilder);
       method();//D
        System.out.println(intStatic);
    }
    //A方法
    public static void method(int intStatic){
        intStatic=777;
    }
    public static void method(){
        intStatic=888;
    }
     public static void method(String stringStatic){
        stringStatic="new string";
     }
     public static void method(StringBuilder stringBuilderStatic,StringBuilder stringBuilderStatic1){
        stringBuilderStatic.append(".method.first");
        stringBuilderStatic1.append(".method.second");
        stringBuilderStatic=new StringBuilder("new stringBuilder");
        stringBuilderStatic.append("new method");
     }
}

接下来是这个程序片段的运行答案：
在调用A方法的时候,虽然在方法内部的intStatic与静态变量同名，但是因为作用域的就近原则，他是局部变量的参数，所有的操作与静态变量无关。而无参的D方法中，先把本地赋值的888压入虚拟机栈中的操作栈，然后给静态变量赋值。总之，无论是对于基本数据类型还是引用变量，Java中的参数传递都是值复制的传递过程。对于引用变量，复制指向对象的首地址，双方都可以通过自己的引用变量修改指向对象的相关属性。
我们再来一个例子

public class People {
    int age = 20;

    public int getAge(People people) {
        return people.age = 30;
    }
    public static void main(String[] args) {
        People people = new People();
        int a = people.age;
        System.out.println(a);
        people.getAge(people);
        int b = people.age;
        System.out.println(b);
    }
}

可能这段代码看起来比较绕，但是我们先来看一下答案，下面再来讲解：

首先我们先看main方法中，我们先new出来了一个空间在定义了一个整数型 a，将people的age赋值给了a，那么我们的a=20，我们接着往下面看people调用了方法getAge并传入一个参数people，那么我们的实际参数people将赋给getAge中的形式参数，那么我们继续运行该方法，该方法返回了people.age=30；此时此刻我们就需要画图来理解

首先我们的people引用指向的age=20，但是我们又有一个people引用将age=20更改为age=30，所以我们的b=30，a=20。
那么我们再在getAge方法中添加一段代码，我们的结果又会改变：

public class People {
    int age = 20;

    public int getAge(People people) {
        people=new People();
        return people.age = 30;
    }

    public static void main(String[] args) {
        People people = new People();
        int a = people.age;
        System.out.println(a);
        people.getAge(people);
        int b = people.age;
        System.out.println(b);
    }
}

我们仍然用一张图来表示：

我们getAge中的方法的people引用重新开辟了一个空间将age=30储存在第二个空间中，而第一个空间中的age仍然等于20不变，所以我们的a与b的结果都是20。

可变参数：

对于可变参数，说法不同，有人说可变参数更简单，省去了手工开创数组的麻烦，但是也有人说这是一种语法糖，是一种恶魔果实。如果在实际开发中使用不当，会严重影响代码的可读性和可维护性。我们贴上代码来解读！

public class parpam1 {
    public static void listUser(Object...args){
        System.out.println(args.length);
    }
    public static void main(String[] args){
        listUser(1,2,3);
        listUser(new int[]{1,2,3});
        listUser(3,new String[]{"1","2"});
        listUser(new Integer[]{1,2,3});
        listUser(3,new Integer[]{1,2,3});
    }
}

这种写法是不是很神奇，就像一个数组一样，那么我们在贴上控制台：
感觉是不是很灵活将Object作为参数，类型的转化场景不好预判，比如Interger[ ]可以转化为Object[ ]，也可以作为一个Object对象，导致出现的结果不同。