Java课程 第02周 预习、实验与作业：Java基础语法2：面向对象入门
1.3 课前问题列表
方法相关问题
public class Main {
static void changeStr(String x) {
x = "xyz";
}
static void changeArr(String[] strs) {
for (int i = 0; i < strs.length; i++) {
strs[i] = strs[i]+""+i;
}
}
public static void main(String[] args) {
String x = "abc";
changeStr(x);
System.out.println(x);
changeArr(args);
System.out.println(Arrays.toString(args));
}
}
对于如上代码：
1.1 changeStr与changeArr的功能各是什么？
changeStr(String x) 的功能：接收一个字符串参数 x，并尝试将其重新赋值为 "xyz"。
changeArr(String[] strs) 的功能：该方法接收一个字符串数组，并遍历数组，将每个元素修改为原元素值加上其索引。
1.2 main方法的x有没有被改变？为什么？
没有被改变。
原因：
Java的参数传递是值传递（pass by value）。当调用 changeStr(x) 时，传递的是变量 x 的引用的副本（而不是引用本身）。
字符串是不可变对象，x = "xyz" 只是将方法内的局部参数 x（引用的副本）指向了新的字符串 "xyz"，但原始变量 x 仍然指向原来的字符串 "abc"。
1.3 main方法的args数组的内容有没有被改变？为什么？
main方法的args数组的内容被改变。
原因：
Java的参数传递是值传递，但对于引用类型，传递的是引用的副本，即副本和原始引用指向同一个数组对象。
changeArr 方法通过这个引用副本遍历数组，并修改了每个元素的值。由于修改的是同一数组对象的内容，因此原始数组（即 args）的内容被改变。
1.4 args数组中的值是从哪里来的？要怎么才能给他赋值。
1）args 数组中的值来自命令行参数（command-line arguments），即在运行程序时通过命令行传入的参数。
2） 有以下几种方式可以给 args 赋值：
a）命令行直接传入（最常用）：
例如，编译并运行程序：
bash
javac Main.java、
java Main arg1 arg2 arg3
则 args 数组为 ["arg1", "arg2", "arg3"]。
b）通过IDE配置：
在IDE（如IntelliJ IDEA、Eclipse）中运行程序时，可以在运行配置中设置命令行参数。
2.数组相关问题
对于如下程序
int[] arr = new int[3];
arr[0] = 1; arr[1] = 1;
int[] arrX = arr;
arr[0] = 2;
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(arrX));
2.1 这段程序输出结果是什么？为什么？
String[] strArr = {"aa","bb","cc"};
strArr[1] = "xx";
System.out.println(Arrays.toString(strArr));
输出结果：[aa, xx, cc]
原因：
1）字符串数组 strArr 初始化为 {"aa","bb","cc"}。
2）通过 strArr[1] = "xx"; 将索引1的元素（原为"bb"）重新赋值为"xx"。
(数组是可变的数据结构，允许通过索引修改元素的值。)
3）修改后数组变为 ["aa", "xx", "cc"]，Arrays.toString(strArr) 输出该内容。
2.2 字符串是不可变类，为什么可以对strArr[1]赋值"xx"。
字符串不可变指的是字符串对象本身的内容不可改变。即无法修改像"bb"这个字符串对象的内容，无法将它的某个字符改成其他字符。
但数组是可变的，即可以修改数组元素指向的对象。
3.使用int[5][]定义一个二维数组，其第二维到底有多长？尝试补全代码，然后使用foreach获其他循环方法遍历这个二维数组？
使用 int[5][] 定义的是一个第二维长度不确定的数组。第一维长度固定为5即5行，但第二维每个元素（每行）目前都是 null，需要手动初始化每行的长度。
补全代码：
public class Main {
public static void main(String[] args) {
int[][] arr = new int[5][];
arr[0] = new int[3]; // 第0行长度为3
arr[1] = new int[2]; // 第1行长度为2
arr[2] = new int[4]; // 第2行长度为4
arr[3] = new int[1]; // 第3行长度为1
arr[4] = new int[5]; // 第4行长度为5
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
arr[i][j] = i * 10 + j; // 任意赋值
}
}
System.out.println("使用嵌套for循环:");
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
System.out.println("\n使用foreach循环:");
for (int[] row : arr) {
for (int num : row) {
System.out.print(num + " ");
}
System.out.println();
}
4.类与对象的区别是什么？ Math类有对象吗？String类有什么属性是private的，有什么方法是public的，为什么这样设计(尝试举两例说明)？
1）类（Class）：是一个模板或蓝图，定义了对象的结构和行为。
对象（Object）：是类的一个具体实例，占用内存空间并存储实际数据。
2）Math类没有对象。Math 类被设计为工具类，所有方法都是static的，并且构造器是private的，因此无法创建Math对象。
3）String类的private属性：
private final byte[] value
private final int hash （缓存哈希值）
private final byte coder （编码标识）
String类的public方法（部分）：
public int length()
public char charAt
public String substring
4）例1：private final byte[] value（存储数据的数组被私有化）
为什么私有？
防止外部直接修改数组内容（字符串不可变的核心保障）。
如果数组是public，用户可能通过str.value[0] = 'x'修改字符串内容，破坏不可变性。
为什么提供public方法（如charAt()）？
通过公共方法安全地访问数据（方法内部可做边界检查，避免数组越界）。
例如：charAt(int index) 方法会检查index是否合法，再返回对应字符。
例2：private final int hash（缓存哈希值）
为什么私有？
哈希值计算需要成本，缓存后可提高性能（如用于HashMap键值），但缓存过程对用户应该是透明的。
如果hash是public，用户可能错误地修改它，导致哈希不一致。
为什么提供public的hashCode()方法？
允许用户获取哈希值，但内部实现延迟计算（第一次调用时计算并缓存，后续直接返回缓存值）。
这样既保证了效率，又封装了实现细节。
5.将类的属性设置为public可以方便其他类访问，但为什么Java中普遍使用setter/getter模式对对象的属性进行访问呢？这与封装性又有什么关系？
1）封装性是面向对象的核心原则
封装性要求将对象的内部状态（属性）隐藏起来，只通过受控的接口进行访问。setter/getter模式正是实现封装的关键手段。
2）setter/getter模式 vs public属性的优势
a）控制访问权限（安全性）
public属性：任何类都可以直接修改属性，可能破坏对象状态的完整性。例如，设置非法值。
setter方法：可以在方法中添加验证逻辑，确保赋值合法。
public void setAge(int age) {
if (age < 0 || age > 150) {
throw new IllegalArgumentException("年龄不合法");
}
this.age = age;
}
b）实现只读或只写属性
如果属性是public，无法限制只读或只写。
通过只提供getter（无setter）实现只读属性：
private String id; // 只读属性
public String getId() { return id; } // 无setter
c）隐藏内部实现细节（灵活性）
内部存储方式改变时，不影响外部代码（例如，属性名或类型变化）。
// 存储秒数
private long timeInSeconds;
public long getTime() { return timeInSeconds; }
d）支持延迟初始化
通过getter延迟加载资源，提高性能：
private HeavyObject heavy;
public HeavyObject getHeavy() {
if (heavy == null) {
heavy = new HeavyObject();
}
return heavy;
}
6.对象的属性可在什么时候进行初始化？都有哪些进行初始化的办法？
1）声明时即编译时，直接初始化
2）构造器初始化或初始化块，即创建对象时
3）延迟初始化，即第一次使用时
初始化方法：
a）声明时直接初始化
public class Person {
private String name = "未知"; // 直接初始化
private static int count = 0; // 静态属性初始化
private final int id = generateId(); // 方法调用初始化
}
b）构造器初始化
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
c）初始化块
public class Person {
private String name;
private List<String> hobbies;
// 实例初始化块（每次创建对象时执行）
{
name = "临时姓名";
hobbies = new ArrayList<>();
hobbies.add("阅读");
}
// 静态初始化块
private static Map<String, Integer> config;
static {
config = new HashMap<>();
config.put("max_age", 150);
config.put("min_age", 0);
}
}
d）延迟初始化
public class Database {
private Connection connection;
public Connection getConnection() {
if (connection == null) {
connection = createConnection();
}
return connection;
}
private Connection createConnection() {
// 创建数据库连接
return new Connection();
}
}