Java基础编程题

1 String与char[]的更改

实验代码1

public class Test1 {
    public static void main(String[] args) {
        String str = new String("world");
        char[] ch = new char[]{'h','e','l','l','o'};
        str = "change";
        ch[0] = 'a';
        ch[1] = 'b';
        ch[2] = 'c';
        ch[3] = 'd';
        ch[4] = 'e';
        System.out.println(str);
        System.out.println(String.valueOf(ch));
    }
}

运行结果1

change
abcde

实验代码2

public class Test {
    public static void main(String[] args) {
        String str = new String("world");
        char[] ch = new char[]{'h','e','l','l','o'};
        change(str,ch);
        System.out.println(str);
        System.out.println(String.valueOf(ch));
    }
    public static void change(String str, char[] arr){
        str = "change";
        arr[0] = 'a';
        arr[1] = 'b';
        arr[2] = 'c';
        arr[3] = 'd';
        arr[4] = 'e';
    }
}

运行结果2

world
abcde

结果分析

1. 为何调用方法后Str字符串内容并未改变？
   答：在方法中虽然把str传入并进行了重赋值操作，但此操作只是改变change方法中str变量的引用，并未对main方法中的str进行操作。
2. 为何调用方法后char[]数组改变了？
   答：调用方法后，change方法通过传入的字符数组地址对数组内容进行更改，而main方法也是通过相同地址访问数组元素，即此刻数组元素为改变后的元素。

2 i++与++i 的区别

实验代码

public class Test {
    static int x, y, z;

    static {
        int x = 5;
        x--;
    }
    static {
        x--;
    }

    public static void main(String[] args) {
        System.out.println("x=" + x);
        z--;
        method();
        System.out.println("result:" + (z + y + ++z));
    }

    public static void method() {
        y = z++ + ++z;
        System.out.println(y);
    }
}

运行结果

x=-1
0
result:3

结果分析

1. 在静态代码块中x进行了两次自减操作，为什么结果为-1？
   答：在第一个静态代码块中定义了局部变量x，所以此代码块的自减是对于代码块中的局部变量x，因此只有第二个静态代码块中的自减生效，即x=x-1=-1
2. y的值为何为0？
   答：i++先赋值再自增，++i先自增再赋值，z自减过后为-1，先赋值-1，再自增为0，再自增为1，赋值为1，y=-1+1=0

3 类在继承时对于构造方法和方法的调用

3.1 对于构造方法的调用

实验代码

public class Test {
    public static void main(String[] args) {
        A a = new A();
        B b1 = new B();
        B b2 = new B(1);
    }

}
class A{
    A(){
        System.out.println("A的无参构造函数");
    }
}
class B extends A{
    public B() {
        System.out.println("B的无参构造函数");
    }
    public B(int i) {
        System.out.println("B的有参构造函数");
    }
}

运行结果

A的无参构造函数
A的无参构造函数
B的无参构造函数
A的无参构造函数
B的有参构造函数

结果分析

在子类创建对象时，如果未显示调用父类的构造方法，则默认先调用父类的无参构造方法，再调用子类的构造方法。

3.2 对于方法的调用

实验代码

public class Test {
    public static void main(String[] args) {
        Base b1 = new Base();
        Base b2 = new Sub();
    }
}
class Base{
    Base(){
        method(100);
    }
    public void method(int i){
        System.out.println("base : " + i);
    }
}
class Sub extends Base{
    Sub(){
        super.method(70);
    }
    public void method(int j){
        System.out.println("sub : " + j);
    }
}

运行结果

base : 100
sub : 100
base : 70

结果分析

子类对象在调用方法时优先调用子类中的方法