【Java 进阶实战】一 学习成果检验
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 } }
str.toUpperCase() 将字符串小写字母转换为大写字母,但是它不会改变原始的字符串。