Java 几个基础问题

1.调用函数时传递参数问题

public a3{
    String a = "1";
    String[] b = {"2"};
    public static void main(String[] args){
        a3 app = new a3();
        app.operate(app.a, app.b);
        System.out.println(app.a+app.b[0]);
    }
    static void operate(String a, String[] b){
        a = new String("3");
        b[0] = new String("4");
    }
}

Java是传值的，当参数是基本类型的时候，传进去的是值，对值的改变，其实是将变量指向了另外的地方

a = 1;
a(int a){
    a = 2;
}
a----------> 1
变成了a----------> 2，这里1和2存的是不同的地方
而不是将存1的内存地址的值改成了2

当传的是对象时，值是引用，传进去的是地址的引用，所以对引用的改变就反应到了地址上，所以函数执行完以后地址存的值就改变了。

2.静态方法的多态

class Sup{
    void method(){
        System.out.println("Super method");
    }
    static void methodStatic(){
        System.out.println("Super method static");
    }
}
public class Sub extends Sup{
    void method(){
        System.out.println("Sub method");
    }
    static void methodStatic(){
        System.out.println("Sub method static");
    }
    public static void main(String[] args){
        Super a = new Sub();
        a.method();
        a.methodStatic();
        Sub b = new Sub();
        b.method();
        b.methodStatic();

    }
}

输出：
Sub method
Super method static
Sub method
Sub method static

关键：静态方法不能多态

3.函数调用对象时的成员变量

class ValHold{
    public int i = 10;
}
public class Main{
    public static void main(String[] args){
        Main o = new Main();
        o.amethod();
    }
    public void amethod(){
        int i = 99;
        ValHold v = new ValHold();
        v.i = 30;
        another(v, i);
        System.out.println(v.i + " " + i);
    }
    public void another(ValHold v, int i){
        i = 0;
        v.i = 20;
        ValHold vh = new ValHold();
        v = vh;
        System.out.println(v.i + " " + i);
    }
}

1. o.amethod();
2. i = 99;
3. v = new BalHold();
4. v.i = 30
5. another(v, i);
6. i = 0;
7. v.i = 20;
8. vh = new ValHold();
9. v = vh;  // v.i = 10;
10. 输出 10 0
11. 返回amethod()方法，v指向的还是原来的地址，不是another函数里vh的地址，但是原来地址的i的值已经改为20了
12. 输出 20 99

即最后输出为：
10 0
20 99