当前位置：首页 > article >正文

【Java 进阶实战】一学习成果检验

article 2025/3/15 20:07:07

Boolean 是一个类，而不是关键字。

boolean 类型的默认值为false。

下列代码输出结果为 false：
public class Test {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        System.out.println("s1 == s2 is:" + s1 == s2);
    }
}
因为 + 操作符的优先级比 == 高，输出部分表达式相当于

“s1 == s2 is:abc” == “abc”，结果为 false。

float 类型的在内存中的大小为 4 字节（一个字节存储 8 位，float 是 32 位数据类型）

局部变量必须要初始化。

线程属于一次性消耗品，在执行完 run() 方法之后线程便会正常结束了，线程结束后便会销毁，不能再次 start，只能重新建立新的线程对象。

所有异常类的基类是 Java.Lang.throwable。

空引用可以访问静态变量和方法：当我们通过一个对象的引用访问静态成员属性或者方法时，访问操作只与所声明的引用类型相关 ；与引用对象是否为 null 无关 ，因为访问静态成员不需要实例化对象；即便引用不为 null ，也与运行时多态无关，因为静态成员是类相关的。
public class Test {
    static int staticVar = 10;
    static void staticMethod() {
        System.out.println("Static method called");
    }

    public static void main(String[] args) {
        Test obj = null;
        // 通过空引用访问静态变量和方法
        System.out.println(obj.staticVar); // 输出 10（不会报空指针）
        obj.staticMethod();                // 输出 "Static method called"（不会报空指针）
    }
}

下面这段代码是正确的：
int a1 = 5;     
double a2 =(float)a1;
float → double：隐式扩宽转换（double 范围更大，无精度损失）。

布尔值不能与整数进行比较，因为boolean 类型不能转换成任何其它数据类型。

基础数据类型在堆栈上分配：

基本类型类型以及对象的引用变量是存储在栈内存中；而对象本身的值或者说 new 创建的对象和数组是存储在堆内存中。

下面程序输出结果为：1 2 3 4 5
class TestIt
{
    public static void main ( String[] args )
    {
        int[] myArray = {1, 2, 3, 4, 5};
        ChangeIt.doIt( myArray );
        for(int j=0; j<myArray.length; j++)
            System.out.print( myArray[j] + " " );
    }
}
class ChangeIt
{
    static void doIt( int[] z ) 
    {
        z = null ;
    }
}
java 基本数据类型传递参数时是值传递；引用类型传递参数时是引用传递 。然而数组虽然是引用传递，但是将引用 z = null 只是将引用z不指向任何对象，并不会对原先指向的对象数据进行修改 。

下面这段程序会出现编译错误：
class Main {
    public static void main(String args[]) { 
        System.out.println(fun());
    } 

    int fun()
    {
        return 20;
    }
}
因为Main 类中 main() 是一个静态函数， fun() 是一个非静态函数， Java 静态函数中不能调用非静态函数的方法。而 fun() 是实例方法（没有 static 修饰），必须通过对象实例才能调用，在 main 中直接调用 fun() 时，编译器无法确定该方法属于哪个对象实例，导致错误。

而下面的程序也会出现错误：
class Main {
    public static void main(String args[]) {   
        System.out.println(fun());
    }   
    static int fun(int x = 0)
    {
        return x;
    }
}
因为 Java 函数不允许参数设置默认值。

下面这段程序输出 null：
public class Main { 
    public static void main(String args[]) { 
       String x = null; 
       giveMeAString(x); 
       System.out.println(x); 
    } 
    static void giveMeAString(String y) 
    { 
       y = "abc"; 
    } 
}
因为 Java 中参数通过值传递，所以 x 传到函数中不会影响原来的值。

下面这段程序输出 i = 10, j = 20：

class Main {
public static void swap(Integer i, Integer j) {
      Integer temp = new Integer(i);
      i = j;
      j = temp;
   }
   public static void main(String[] args) {
      Integer i = new Integer(10);
      Integer j = new Integer(20);
      swap(i, j);
      System.out.println("i = " + i + ", j = " + j);
   }
}

因为 Java 函数参数通过值传递，内存中的变化如下：

调用前 main 方法中的引用：
i -> [Integer@1001 (value=10)]
j -> [Integer@1002 (value=20)]

swap 方法中的参数副本：
a -> [Integer@1001 (value=10)] (i 的副本)
b -> [Integer@1002 (value=20)] (j 的副本)

swap 内部交换后：
a -> [Integer@1002 (value=20)]
b -> [Integer@1001 (value=10)]

swap 方法结束后：
i 仍指向 [Integer@1001 (value=10)]
j 仍指向 [Integer@1002 (value=20)]

若要实现交换，可以使用两种方法：

法一：使用数组或者可变容器：

public class Main {
    public static void swap(int[] arr) {
        int temp = arr[0];
        arr[0] = arr[1];
        arr[1] = temp;
    }

    public static void main(String[] args) {
        int[] values = {10, 20};
        swap(values);
        System.out.println("i = " + values[0] + ", j = " + values[1]); // 输出 i=20, j=10
    }
}

法二：自定义可变包装类：

class IntHolder {
    int value;
    IntHolder(int value) { this.value = value; }
}

public class Main {
    public static void swap(IntHolder a, IntHolder b) {
        int temp = a.value;
        a.value = b.value;
        b.value = temp;
    }

    public static void main(String[] args) {
        IntHolder i = new IntHolder(10);
        IntHolder j = new IntHolder(20);
        swap(i, j);
        System.out.println("i = " + i.value + ", j = " + j.value); // 输出 i=20, j=10
    }
}