山东大学高级程序设计期末复习
Java
不要像笔者一样，大一不好好学习考的烂，大三又在找补
-
在Java中，
%是取余运算符：System.out.println(-7 % 3); // 输出 -1 System.out.println(7 % -3); // 输出 1这是因为余数的符号与被除数相同。
-
静态方法中不能有
this和super静态方法属于类，而不是实例，因此不能使用
this和super，它们只能用于实例方法：public static void staticMethod() { // this 和 super 在这里不可用 } -
权限修饰符只能修饰成员变量和成员方法，不能修饰局部变量
权限修饰符（如
public,private）只适用于类的成员，不能用于局部变量：public void method() { private int a = 5; // 错误，局部变量不能有访问修饰符 } -
接口中可以有具体的成员方法
在Java 8之后，接口可以有默认方法和静态方法，这些方法可以有实现：
interface MyInterface { default void defaultMethod() { System.out.println("默认方法"); } } -
Java中只允许父类引用指向子类对象
是Java的多态机制，父类引用可以指向子类对象，但反过来不行：
class Parent {} class Child extends Parent {} Parent p = new Child(); // 合法 Child c = new Parent(); // 错误，子类不能指向父类对象 -
将子类对象强转为父类对象
编译可以通过，但父类引用只能调用父类中的方法：
Child c = new Child(); Parent p = (Parent) c; // 强制转换 -
将父类对象强转为子类对象时会报错
因为父类对象没有子类的额外成员，强转会失败：
Parent p = new Parent(); Child c = (Child) p; // 错误，父类对象不能转为子类对象 -
静态方法的重写和多态
静态方法属于类，而不是类的实例，因此静态方法不能像实例方法那样被重写。即使使用多态，静态方法仍然根据引用类型来调用，而不是对象的实际类型。
class Parent { static void show() { System.out.println("Parent show()"); } } class Child extends Parent { static void show() { System.out.println("Child show()"); } } public class Test { public static void main(String[] args) { Parent p = new Child(); p.show(); // 调用 Parent 类的 show()，静态方法是根据引用类型调用的 } }尽管
p引用的是Child类型，但因为是静态方法，实际上调用的是父类Parent的show()方法。 -
静态方法可以重载
静态方法是可以重载的，因为方法重载是基于方法签名（即方法名和参数类型）来区分的，而与是否是静态方法无关。
-
final修饰符的使用final修饰类：表示该类不能被继承。例如，final class MyClass { }。final修饰方法：表示该方法不能被重写。final修饰变量：表示该变量一旦被赋值就不能更改。
final不能用于修饰抽象类和接口，也不能用于修饰抽象方法。 -
多维数组的初始化
多维数组的第一维必须初始化，而后续维度可以不初始化，但使用时需要初始化。
int[][][] arr = new int[3][][]; arr[0] = new int[2][]; arr[0][0] = new int[5]; -
String str = "CHASD5SH"; int doub = str.charAt(5); System.out.println(doub);str.charAt(5)获取的是字符串str中索引为5的字符。str = "CHASD5SH"，所以str.charAt(5)返回的是字符'5'。
在 Java 中，字符是基于 Unicode 编码的。字符
'5'的 Unicode 编码是 53。char类型实际上是一个整数，表示该字符的 Unicode 编码。因此，charAt(5)返回的是字符'5'，将其赋值给int doub，结果是字符'5'的整数值 53。 -
String类的compareTo()方法返回的值是基于字符的 Unicode 编码值的差异。返回值的具体含义取决于字符串的字典顺序。- 返回值为 0：
- 表示两个字符串相等。
- 比较过程会依次检查两个字符串的每一个字符，直到找到不同的字符或字符串结束。如果没有发现不同，且两个字符串的长度也相同，
compareTo()返回0。
- 返回负数（< 0）：
- 表示当前字符串小于另一个字符串。
- 如果第一个不同的字符的 Unicode 值在当前字符串中较小，那么返回一个负数。该负数的大小是当前字符与另一个字符串对应字符的 Unicode 值之差。
- 返回正数（> 0）：
- 表示当前字符串大于另一个字符串。
- 如果第一个不同的字符的 Unicode 值在当前字符串中较大，那么返回一个正数。该正数的大小是当前字符与另一个字符串对应字符的 Unicode 值之差。
- 返回值为 0：
-
自动包装（自动装箱与拆箱）
自动包装是指Java语言中的基本数据类型与对应的包装类之间的自动转换。例如，
int类型自动转换为Integer类，double自动转换为Double类，等等。-
自动装箱（Autoboxing）：将基本数据类型转换为对应的包装类对象。
例如：
int a = 5; Integer b = a; // 自动装箱：int 转为 Integer -
自动拆箱（Unboxing）：将包装类对象转换为对应的基本数据类型。
例如：
Integer b = 10; int a = b; // 自动拆箱：Integer 转为 int
Java 会自动完成这些转换，因此我们不需要显式地调用构造函数来进行转换。这个机制使得基本数据类型和包装类之间的转换更加简便。
-
-
包的基本概念：
包是类的组织方式，用来组织类文件，以避免类名冲突，并可以实现访问控制。
- 包不是文件的组织方式：
- 在 Java 中，包主要是用来组织类和接口的逻辑分组，并不直接决定文件如何存储或组织。即使类在同一个包中，它们的源文件可能位于不同的目录。
- 包里的类相互使用：
- 同一个包中的类可以直接相互访问，通常不需要导入（
import）。如果不同包之间的类需要相互访问，就需要使用import来导入。
- 同一个包中的类可以直接相互访问，通常不需要导入（
- 包的最大好处：
- 避免类名冲突：不同的包中可以有同名的类而不冲突。
- 访问控制：包内的类可以通过访问修饰符（如
public、private、protected）控制访问权限。
- 包不是文件的组织方式：
-
阅读下面异常处理程序，写出执行结果(6分)
public class ExceptionDemo { public static void main(String[] args) { ExceptionTest et=new ExceptionTest(); et.m1(); } } class ExceptionTest{ int i; int[] a = new int[5]; void m1() { try { while (true) { m2(); System.out.println(); } }catch (Exception e) { System.out.println(" m1 runs "); } } void m2() throws Exception { try{ System.out.println(10/i); System.out.println(a[i]); }catch (ArithmeticException e) { i = 10; System.out.println("handle ArithmeticException"); } Finally { System.out.println("finally"); } System.out.println("m2 ends"); } }m1方法包含一个无限循环while (true)，每次循环都会调用m2方法。- 如果
m2抛出异常，m1会捕获到该异常并输出" m1 runs "。 m2方法首先尝试执行10 / i，然后尝试打印数组a[i]的值。- 如果发生
ArithmeticException（例如，i为 0 时），就会进入catch块，打印"handle ArithmeticException"，并将i设置为 10。 - 无论是否发生异常，
finally块都会执行，打印"finally"。 - 在
finally块之后，m2会输出"m2 ends"。
第一次调用
m2()：i默认值是0（因为它是类的实例变量）。10 / i会导致ArithmeticException，因为除以 0 会抛出异常。- 进入
catch块，打印"handle ArithmeticException"，并将i设置为10。 finally块执行，打印"finally"。m2 ends被打印。
第二次调用
m2()：- 由于
i已经被修改为10，执行10 / i会输出1。 - 然后尝试访问
a[i]，即a[10]，但是数组a只有 5 个元素，因此会发生ArrayIndexOutOfBoundsException异常。 - 因为
m2中没有捕获ArrayIndexOutOfBoundsException，这个异常会传递给m1，m1会捕获到这个异常并输出" m1 runs "。
m1捕获异常：- 当
m2抛出异常时，m1捕获到异常并输出" m1 runs "，然后退出。
执行结果：
handle ArithmeticException finally m2 ends m1 runs对于类的实例变量（如 int i 和 int[] a），它们会自动初始化为默认值：0 和 null。
-
Java 编译过程从源代码（
.java）开始，通过编译器生成字节码（.class文件），然后通过 JVM 来运行。 -
错误分为语法错误、运行时错误和逻辑错误，每种错误都有不同的表现和调试方式。
-
要运行 Java 程序，系统需要安装 JDK（用于开发）或者 JRE（仅用于运行）。
-
在 Java 中，变量可以分为 原型类型（基本类型）和 类类型（引用类型）：
原型类型（基本类型）：
这些类型是 Java 中最基础的类型，它们直接存储值，而不涉及对象的引用。原型类型有 8 种：
- byte：8 位，范围从 -128 到 127
- short：16 位，范围从 -32,768 到 32,767
- int：32 位，范围从 -2^31 到 2^31-1
- long：64 位，范围从 -2^63 到 2^63-1
- float：32 位单精度浮点数
- double：64 位双精度浮点数
- char：16 位，表示一个字符，范围从 ‘\u0000’ 到 ‘\uffff’
- boolean：表示布尔值，只有两个值：
true或false
类类型（引用类型）：
类类型是通过引用来指向对象的，它们可以是任何类类型（如
String、Object）以及数组。类类型的变量保存的是对象在内存中的地址，而不是对象本身。 -
标识符的命名规则
标识符是 Java 中用来命名变量、方法、类等的名称，命名时需要遵守一定的规则：
- 首字符：标识符必须以字母（A-Z，a-z）、下划线（
_）或美元符号（$）开头。- 例如：
_variable，$value，myVar
- 例如：
- 后续字符：标识符可以包含字母、数字（0-9）、下划线（
_）和美元符号（$）。- 例如：
my_var123，value$，num_1
- 例如：
- 不能使用 Java 关键字：
- Java 保留了一些关键字（如
int、class、if、else等），这些关键字不能作为标识符。
- Java 保留了一些关键字（如
- 可以包含
$：- 标识符中可以使用美元符号（
$），例如：$value，$testVar。但是它通常用于自动生成的代码，不建议在自定义标识符中使用$。
- 标识符中可以使用美元符号（
- 符号“-”：不可以作为标识符的一部分。
- 例如：
my-variable是非法的，my_variable才是合法的。
- 例如：
- 大小写敏感：
- Java 是区分大小写的，即
myVar和myvar是两个不同的标识符。
- Java 是区分大小写的，即
Java 区分大小写：
Return不是关键字，但是因为它首字母大写，可以作为变量名，虽然这不符合 Java 命名习惯。return是关键字，表示方法的返回语句，不能作为标识符使用。
- 首字符：标识符必须以字母（A-Z，a-z）、下划线（
-
字符串常用方法：
-
length()：返回字符串的长度（字符数）。String str = "Hello"; System.out.println(str.length()); // 输出 5 -
toLowerCase()：将字符串转换为小写字母。String str = "HELLO"; System.out.println(str.toLowerCase()); // 输出 "hello" -
substring()：提取字符串的子字符串。可以传入起始和结束索引。String str = "Hello"; System.out.println(str.substring(1, 4)); // 输出 "ell" (从索引1到3的字符) -
replace()：替换字符串中的字符或子字符串。String str = "Hello World"; System.out.println(str.replace("World", "Java")); // 输出 "Hello Java" -
charAt()：返回指定索引位置的字符。String str = "Hello"; System.out.println(str.charAt(1)); // 输出 "e" (索引从 0 开始) -
toCharArray()：将字符串转换为字符数组。String str = "Hello"; char[] chars = str.toCharArray(); System.out.println(chars[0]); // 输出 'H'
-
-
比较两个字符串的长度
在 Java 中，比较字符串长度时，需要使用
length()方法。length()方法返回字符串的长度（即字符的数量），而不是equals()方法，后者是用来比较两个字符串的内容是否相等的。 -
String在 Java 中是 不可变的（immutable），这意味着一旦创建了一个String对象，它的内容不能被更改。如果你尝试修改字符串，实际上是创建了一个新的字符串对象。 -
import语句用于引入外部类库或包中的类，以便在程序中使用它们。可以引入整个包，或者只引入某个具体的类。import java.util.Scanner; // 引入 Scanner 类 import java.util.*; // 引入整个 java.util 包 -
int和Integer的转换：int转为Integer：使用Integer.valueOf()或自动装箱。Integer转为int：使用intValue()或自动拆箱。
-
Math类提供了许多常用的数学方法，包括求绝对值、平方根、最大值、最小值等。常用方法：
-
Math.abs()：返回绝对值。System.out.println(Math.abs(-10)); // 输出 10 -
Math.sqrt()：返回平方根。System.out.println(Math.sqrt(16)); // 输出 4.0 -
Math.max()和Math.min()：返回两个数中的最大值或最小值。System.out.println(Math.max(5, 10)); // 输出 10 -
Math.pow()：返回一个数的指数幂。System.out.println(Math.pow(2, 3)); // 输出 8.0
-
-
静态变量（Static Variables）
- 定义：静态变量是属于类的，而不是属于类的某个实例。无论创建多少对象，静态变量只有一个副本。
- 初始化：静态变量由 Java 自动初始化，默认值与实例变量相同。
- 访问方式：可以通过类名直接访问静态变量，也可以通过对象引用访问（不推荐）。
class MyClass { static int count = 0; // 静态变量，初始值为 0 } public class Main { public static void main(String[] args) { System.out.println(MyClass.count); // 通过类名访问静态变量 MyClass obj1 = new MyClass(); MyClass obj2 = new MyClass(); System.out.println(obj1.count); // 通过对象引用访问静态变量 obj1.count = 5; // 修改静态变量的值 System.out.println(obj2.count); // 由于静态变量是类共享的，obj2.count 会输出 5 } } -
方法中的参数：传值与传址
在 Java 中，方法的参数传递有两种方式：传值（Pass-by-Value） 和 传址（Pass-by-Reference）。
原型类型（基本类型）参数：传值
- 定义：原始类型（如
int,char,double等）传递的是值的副本，即在方法调用时，实参的值会复制给形参。方法内部对形参的修改不会影响到实参。 - 特点：Java 中基本类型变量是传值的，传递的是值的副本。
示例：
class Test { public static void changeValue(int x) { x = 100; // 仅修改了 x 的副本 } public static void main(String[] args) { int num = 10; changeValue(num); System.out.println(num); // 输出 10，原始变量没有改变 } }- 解释：在
changeValue方法中，x是num的副本。对x的修改不会影响原始的num。
对象参数：传址
- 定义：对于对象参数，Java 是通过传递对象的引用来实现的。这意味着方法中操作的是原始对象的引用，因此如果在方法内修改对象的字段（属性），这些更改会影响到原始对象。
- 特点：Java 传递的是对象引用的副本，即传址。但需要注意的是，传递的引用本身是传值的，不能在方法内修改引用指向的对象。
示例：
class Person { String name; Person(String name) { this.name = name; } } class Test { public static void changeName(Person p) { p.name = "John"; // 修改了 p 对象的属性 } public static void main(String[] args) { Person person = new Person("Alice"); changeName(person); System.out.println(person.name); // 输出 John，原始对象的属性被修改 } }- 解释：
p是person对象的引用副本。通过p修改了对象的属性，影响到了原始的person对象。
- 定义：原始类型（如
-
矩阵乘法（嵌套循环）
for (int i = 0; i < A行; i++) for (int j = 0; j < B列; j++) for (int k = 0; k < A列; k++) C[i][j] += A[i][k] * B[k][j]; -
满足条件的数筛选（如个位+十位和等于某值）
for (int i = 1000; i <= 1800; i++) { int ge = i % 10; int shi = (i / 10) % 10; if (ge + shi == 9) System.out.println(i); } -
重载（Overloading）
同一类中允许多个方法同名但参数不同；
参数不同指的是：数量不同、类型不同、顺序不同；
❌ 不能仅通过返回值不同来区分重载！
-
构造函数的访问修饰符不一定必须是
public，但一般这么写是为了让类可以被外部实例化。 -
选择排序：
public void selectionSort(int[] a) { for (int i = 0; i < a.length - 1; i++) { int minIndex = i; for (int j = i + 1; j < a.length; j++) { if (a[j] < a[minIndex]) { minIndex = j; } } int temp = a[i]; a[i] = a[minIndex]; a[minIndex] = temp; } } -
二分查找（数组需先排序）：
public int binarySearch(int[] number, int searchValue) { int low = 0, high = number.length - 1; while (low <= high) { int mid = (low + high) / 2; if (number[mid] == searchValue) return mid; else if (number[mid] < searchValue) low = mid + 1; else high = mid - 1; } return -1; } -
可以写递归形式的二分查找：
public int recursiveBinarySearch(int[] arr, int low, int high, int key) { if (low > high) return -1; int mid = (low + high) / 2; if (arr[mid] == key) return mid; else if (arr[mid] < key) return recursiveBinarySearch(arr, mid + 1, high, key); else return recursiveBinarySearch(arr, low, mid - 1, key); } -
static + final 的变量是否必须赋初值？
是的，必须。
final static int MAX = 100; // ✅ 必须立刻赋初值因为
static final相当于一个 常量（compile-time constant），一旦定义必须马上确定其值。 -
抽象类与抽象方法（abstract）
抽象方法：
- 仅包含方法签名（如：
abstract void draw();） - 不包含方法体
- 不能是 private、final 或 static（
static方法属于类本身，而不是类的实例。抽象方法需要被子类实例实现，因此不能是静态的。）
抽象类：
-
可以没有抽象方法
-
如果至少包含一个抽象方法，必须被声明为
abstract类 -
可以包含非抽象方法，即普通方法、构造方法、属性等
子类中必须实现所有抽象方法，否则该子类也必须声明为 abstract
abstract 可以修饰：
- 类
- 方法（不能修饰属性和构造方法）
- 仅包含方法签名（如：
-
在动态绑定和多态中，Java 运行时会根据对象的实际类型来决定调用哪个方法
示例代码：
class Z { void f(int x) { System.out.println("Z int"); } void f(double x) { System.out.println("Z double"); } } class P extends Z { void f(int x) { System.out.println("P int"); } // void f(double x) { System.out.println("P double"); } // 可能有也可能没有 } public class TestOverride { public static void main(String[] args) { P t = new P(); t.f(10); // P int t.f(10L); // 10L是long，会优先匹配 f(long) → 没有 → 看 f(double) t.f(2.5); // P 或 Z 的 f(double) } }- 正常情况下（
P t = new P()）
-
t.f(10)
10是int类型，所以会调用P中的f(int x)方法。输出：P int -
t.f(10L)
10L是long类型，会先检查P类中是否有f(long x)，但是没有找到该方法，所以会去查找Z类中的f(double x)。由于long可以隐式转换为double，会调用Z中的f(double x)。输出：Z double -
t.f(2.5)
2.5是double类型，会首先调用P类中的f(double x)，如果P中没有这个方法，则会调用Z中的f(double x)。在当前代码中，P类没有f(double x)，所以会调用Z中的f(double x)。输出：Z double
- 删除
P中的f(double x)方法后
如果删除
P中的f(double x)方法，则调用t.f(10L)和t.f(2.5)时都会调用Z中的f(double x)，因为P类没有匹配的方法，且long和double可以互相隐式转换。-
t.f(10L)
long类型会隐式转换为double，所以调用Z中的f(double x)方法。输出：Z double -
t.f(2.5)
直接调用Z中的f(double x)方法。输出：Z double
- 修改
main方法为Z t = new P();
在这种情况下，变量
t是Z类型的引用，指向一个P类型的对象。此时，方法调用仍然是根据实际对象的类型来决定的（即P类型的对象），但是Z类中的方法是最先被查找的。-
t.f(10L)
由于t的类型是Z，它会首先查找Z类中的方法。如果Z中没有f(long x)，就会向上查找f(double x)。由于Z中有f(double x)，它会调用Z中的f(double x)。输出：Z double -
t.f(2.5)
同样地，t会首先查找Z中的f(double x)，然后调用它。输出：Z double
- 如果
Z中没有f(double x)方法
如果
Z中删除了f(double x)方法，且P中也没有f(double x)方法，那么编译时会报错，因为没有找到匹配的方法。-
t.f(10L)和t.f(2.5)
如果Z和P都没有f(double x)，则会发生编译错误，因为 Java 无法找到一个合适的方法来匹配long或double类型的参数。编译错误：方法 f(double) 在类 Z 中不存在
- 如果
Z中添加了f(long x)方法
如果在
Z中添加了f(long x)方法，则当调用t.f(10L)时会调用Z中的f(long x)方法。-
t.f(10L)
会执行Z.f(long x)，因为long类型会直接匹配Z中的f(long x)。输出：Z long -
t.f(2.5)
仍然会调用Z.f(double x)，因为double类型直接匹配Z中的f(double x)方法。输出：Z double
- 正常情况下（
-
Java支持单继承 + 多接口实现
class Parent {} interface A {} interface B {} class Child extends Parent implements A, B {} -
即使
try和catch中return了，也会先执行 finally 再返回值 -
Java 中的异常处理有两种主要方式：
一种是捕获并处理异常（try-catch-finally）：
这是最常见的方式，如果你知道如何处理某种异常，就在方法中使用
try-catch：try { int a = 10 / 0; // 可能抛出 ArithmeticException } catch (ArithmeticException e) { System.out.println("发生算术异常：" + e.getMessage()); } finally { System.out.println("无论是否发生异常，我都会执行"); }
另一种是声明异常并抛出（throws / throw）：
如果你不打算在当前方法中处理异常，就使用
throws把异常交给调用者去处理（声明），或用throw主动抛出异常对象：声明异常：
public void readFile(String path) throws IOException { FileReader reader = new FileReader(path); // 可能抛出IOException }主动抛出异常：
public void checkAge(int age) { if (age < 18) { throw new IllegalArgumentException("未满18岁不允许注册"); } }
❗注意：
- try/catch 是处理异常：你知道这个异常可能发生，并且你有办法应对。
- throws 是把异常交给别人处理：你暂时无能为力，就把锅甩给上层调用者。
- 两者可以结合使用：一个方法内部
try/catch处理部分异常，剩下的用throws向外声明。
-
链表基本结构回顾
-
ListNode 类（结点类）
public class ListNode { private String data; private ListNode link; public ListNode(String data, ListNode link) { this.data = data; this.link = link; } public String getData() { return data; } public ListNode getLink() { return link; } public void setData(String data) { this.data = data; } public void setLink(ListNode link) { this.link = link; } } -
StringLinkedList 类中的常用方法实现
length()
public int length() { int count = 0; ListNode position = head; while (position != null) { count++; position = position.getLink(); } return count; }addANodeToStart(String addData)
public void addANodeToStart(String addData) { head = new ListNode(addData, head); }deleteHeadNode()
public void deleteHeadNode() { if (head != null) head = head.getLink(); }find(String target)
public boolean find(String target) { ListNode position = head; while (position != null) { if (position.getData().equals(target)) return true; position = position.getLink(); } return false; }showList()
public void showList() { ListNode position = head; while (position != null) { System.out.println(position.getData()); position = position.getLink(); } } -
将链表所有数据转入
ArrayList：ArrayList<String> list = new ArrayList<>(); ListNode position = head; while (position != null) { list.add(position.getData()); position = position.getLink(); } -
插入新节点：
public void insertAfter(String target, String newData) { ListNode position = head; while (position != null) { if (position.getData().equals(target)) { ListNode newNode = new ListNode(newData, position.getLink()); position.setLink(newNode); return; } position = position.getLink(); } } -
删除目标节点后面的节点：
public void deleteAfter(String target) { ListNode position = head; while (position != null) { if (position.getData().equals(target) && position.getLink() != null) { position.setLink(position.getLink().getLink()); return; } position = position.getLink(); } }
-
-
基类方法为public int a(int x, int y); 派生类方法为public void a(int x, int y); 可以这样实现 覆盖方法吗?
答: 不可以. 编译将报错,因为这既不是方法的重载(译文版教材: 无法根据返回值的类型来实现重载), 也不是方法的覆盖(方法名之前的修饰符要完全一致, 方法名之后的参数数目, 类型要完全一样 )
-
若在派生类中自己编写缺省构造函数, 而在里面又只初始化了部分的实例变量, 那么另外的实例变量的值是否还被自动初始化?
答: 现在版本的java仍将对缺省构造函数中未能涉及到的实例变量进行初始化
-
构造函数与一般的方法有何区别?
- 专门用来在创建对象时进行初始化.
- 构造函数与所属的类同名.
- 没有返回值类型, 函数头不带关键字void.
- 构造函数不可以有继承关系.
-
表达式“i=4; i+++i+++i++; ”的值是多少 ?
答:结果为15; 上式可以理解为(i++)+(i++)+(i++), 即: 4+5+6=15; 因为++的优先级比+高,java编译器将首先组织优先级较高的运算符组成表达式.
2021-2022学年一学期高级程序设计课程试卷A
-
Java源文件命名时大小写不敏感
-
一个Java程序可以编译成多个class文件
-
抽象类不一定**非得有抽象方法，例如为了防止创建对象，也可定义成 abstract。
-
Java 不允许在类型声明中 指定数组的大小。也就是说：
int[3] a = {1, 2, 3}; // ❌ 错误：不能写 int[3]-
正确的 Java 数组声明方式是：
方式 1：自动推断长度
int[] a = {1, 2, 3}; // 正确，长度自动为 3方式 2：使用 new 显式声明并初始化
int[] a = new int[]{1, 2, 3}; // 正确方式 3：只声明长度，稍后赋值
int[] a = new int[3]; // 创建长度为 3 的数组，初始值全为 0 a[0] = 1; a[1] = 2; a[2] = 3;
-
-
重写（override）时，返回类型必须相同（或协变返回类型）重载是通过参数列表的不同（个数、顺序或类型）来区分的，返回值类型不同不能作为重载的唯一依据。
-
输出结果是什么？
public class Test { int a[] = new int[10]; public static void main ( String arg[] ) { System.out.println ( a[6] ); } }正确答案：C. 会出现编译错误
解析：
-
变量
a是一个非静态成员变量，但main方法是static的。 -
在静态方法中不能直接访问非静态成员，所以
a[6]会导致编译错误。 -
正确写法应该是：
public static void main(String[] args) { Test t = new Test(); System.out.println(t.a[6]); // 输出 0 }
-
-
this表示当前对象的引用。this只能在 非 static 方法或构造方法中使用，不能在 static 方法中使用。this是和具体对象绑定的，不是和类绑定。 -
关于 throws 和 throw 的说法错误的是？
选项：
- A. 可以使用 throw 抛出自定义异常
- B. throw 用于方法中手动抛异常，throws 用于声明可能发生的异常
- C. throw 抛出的异常，可以不进行处理
- D. 用 throw 时是说明知道方法中可能有异常但不想马上处理，而希望抛出给上级处理
原因分析：
- A ✅ 正确：你可以定义一个异常类，比如
MyException extends Exception，然后用throw new MyException();抛出。 - B ✅ 正确：这是基本定义，没问题。
- C ❌ 错误：如果你用
throw抛出的是受检异常（checked exception），必须处理（try-catch）或声明（throws）。否则编译报错。这条语句是不准确的。 - D ❌ 错误：因为：
throw是用来“抛出”异常的，它不能“声明”你不想处理，而是你“现在就要抛”！- 如果你想表达“我不想处理这个异常，扔给别人”，那应该用的是
throws，而不是throw。
深入解析 Java 中的 throw 和 throws：异常处理机制的核心_java throw-CSDN博客
-
public class T22A { public static void main(String\[] args) { String\[] codes = { "2021", "202b","202" }; try { for (int i = 0; i <= codes.length; i++) { try { System.out.println("Analyzing: " + codes\[i]); analyzeCode(codes\[i]); } catch (NumberFormatException e) { System.out.println("Not a Number: " + codes\[i]); } finally{ System.out.println("\*\*\*\*\*\*\*\*"); } } } catch (Exception e) { System.out.println("Unknown Exception "); } System.out.println("Analyze Completed "); } public static void analyzeCode(String code) throws Exception { if (code.length() != 4) throw new Exception(); System.out.println("successful : " + Integer.parseInt(code)); } }运行结果：
Analyzing: 2021 successful : 2021 ******** Analyzing: 202b Not a Number: 202b ******** Analyzing: 202 Unknown Exception Analyze Completed- 第一次循环 (i=0)：
- 处理
codes[0] = "2021"。 analyzeCode检查长度合法（4），并成功解析为整数，输出successful : 2021。finally块执行，输出*********。
- 处理
- 第二次循环 (i=1)：
- 处理
codes[1] = "202b"。 analyzeCode检查长度合法（4），但解析时遇到非数字字符b，抛出NumberFormatException。- 内部
catch捕获异常，输出Not a Number: 202b。 finally块执行，输出*********。
- 处理
- 第三次循环 (i=2)：
- 处理
codes[2] = "202"。 analyzeCode检查长度不合法（3），直接抛出Exception。- 内部
try块没有匹配的catch，异常传递到外层。 - 执行
finally块，输出*********。 - 外层
catch捕获通用Exception，输出Unknown Exception。
- 处理
- 循环终止与后续流程：
- 外层异常处理后，循环提前终止（不会执行
i=3，避免数组越界）。 - 最后输出
Analyze Completed。
- 外层异常处理后，循环提前终止（不会执行
第三次循环（i=2）发生了什么？
- 处理
codes[2] = "202"，调用analyzeCode("202")。 analyzeCode检查code.length() != 4，发现长度为 3，直接抛出Exception。- 内部
try-catch没有捕获Exception（它只捕获NumberFormatException），所以异常会向外层传播。 - 异常传播到外层的
try-catch（main方法的try块），被catch (Exception e)捕获，输出Unknown Exception。 - 此时，整个外层
try块会立即终止，包括其中的for循环。（因为try只按顺序执行一次，外面的try执行完了，里面的for循环自然就不执行了）
- 第一次循环 (i=0)：
山东大学 2021-2022 学年 一 学期 高级程序设计语言 课程试卷B
-
在一个 Java 源文件中，只能有一个
public class。如果尝试在一个源文件中定义多个public class，编译器会报错。因为 Java 的设计规范规定，每个源文件最多只能有一个公共类，并且源文件的名称必须与该公共类的名称完全相同。不过，可以在一个源文件中定义多个非public class，这些类可以用private、protected或默认的访问修饰符。 -
stu&sdu- 标识符中不能包含
&这样的符号。&用于位运算或表示参数化类型的交界类型等，不是用于组成标识符的有效字符。
- 标识符中不能包含
-
在 Java 中，字符串的长度是通过
length()方法来获取的，而数组的长度是通过直接访问length属性（而不是方法）来获取的。例如，对于字符串String str = "hello";，可以用str.length()获取长度；对于数组int[] arr = new int[5];，则通过arr.length获取长度 -
在 Java 中，二维数组的声明格式为
int a[][]或int[] a[]或int[][] a。正确的初始化方式是int a[][] = { {1,2}, {3,4}, {5,6} };或者int a[][] = new int[3][2];然后给数组元素赋值。选项 A 中的[3][2]放在数组名后面是不正确的，应该将new关键字放在数组声明前面，例如int a[][] = new int[3][2];或者直接初始化为具体的值。 -
static不能用于修饰局部变量（即在方法内部定义的变量）。 -
public class T23B { public static void main(String[] args){ new B().m(2022); new A(2021).m(2020); } } class B{ public B(){ System.out.println("Init B: "); } public void m(int x){ f(g(x)); } public void f(int x){ System.out.println("\tf() in B"); g(x); } private int g(int x){ System.out.println("\tg(int) in B");return x; } } class A extends B { public A(int x){ System.out.println("Init A: " + x); } public void f(int x){ System.out.println("\tf() in A"); g(x); } public int g(int d){ System.out.println("\tg(int) in A"); return (int)d; } }运行结果
Init B: g(int) in B f() in B g(int) in B Init B: Init A: 2021 g(int) in B//这个很奇怪 f() in A g(int) in A- new A(2021).m(2020)。这里创建了一个A类的实例，构造函数的参数是2021。A类继承自B类，所以首先要调用父类B的构造函数。B的构造函数会打印"Init B: “。然后执行A类的构造函数，打印"Init A: 2021”。接着，调用m方法，参数是2020。注意，A类并没有覆盖m方法，所以调用的是从B类继承来的m方法。在m方法中，同样执行f(g(x))。这里的x是2020，先调用g(x)。但是，在A类中是否存在g方法？因为B类的g方法是private的，A类中的g方法是public的，并且参数类型是int，所以这是一个新的方法，而不是覆盖。但是，在B类的m方法中调用g(x)，由于m方法是定义在B类中的，而g是private的，所以即使是在A类中调用m方法，这里的g(x)仍然是指B类的g方法吗？或者因为A类继承了B类的m方法，而在m方法中的g(x)调用是否会被动态绑定到A类的g方法？
- 这里可能存在理解上的误区。因为B类的g方法是private的，所以它只能在B类内部访问，子类A是无法继承或覆盖这个方法的。因此，在A类中定义的g方法是一个全新的方法，与B类的g方法无关。当在B类的m方法中调用g(x)时，由于m方法属于B类，所以这里的g(x)指的是B类的private方法，而不是A类的g方法。因此，当执行new A(2021).m(2020)时，m方法中的g(x)仍然是调用B类的g方法，而之后调用的f方法则是根据实际对象类型来决定的，因为f方法是public的，且A类覆盖了f方法。
-
如果一个数等于它的因子之和，则称该数为“完数”（或“完全数”)。例如，28的因子为1、2、4、7、14，而 28=1+2+4+7+14，因此28是“完数”。写一个程序输出10000以内的所有完数。（8分）
public class PerfectNumber { public static void main(String[] args) { // 输出10000以内的完数 for (int i = 1; i <= 10000; i++) { if (isPerfect(i)) { System.out.println(i); } } } // 判断一个数是否为完数 public static boolean isPerfect(int number) { int sumOfDivisors = 0; // 计算该数的所有真因子之和 for (int i = 1; i <= number / 2; i++) { if (number % i == 0) { sumOfDivisors += i; } } // 如果真因子之和等于该数，则返回true return sumOfDivisors == number; } } -
输入两个小于1~1000位的超大整数，输出它们的和（注意：因为位数很大，会超过java的整数范围，直接用整数输入是不合适的）。（10分）样例： 输入： 917654321454365454445435 87654321987654321987654321 输出：87746087419799758532099756（以上两数相加）
import java.math.BigInteger; import java.util.Scanner; public class LargeNumberAddition { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); // 读取两个大整数 System.out.println("请输入第一个超大整数："); BigInteger num1 = new BigInteger(scanner.nextLine()); // 读取第一个数字 System.out.println("请输入第二个超大整数："); BigInteger num2 = new BigInteger(scanner.nextLine()); // 读取第二个数字 // 计算它们的和 BigInteger sum = num1.add(num2); // 输出结果 System.out.println("它们的和是：" + sum); } } -
返回链表中最大值出现的次数
public int maxCount() { if (head == null) return 0; // 如果链表为空，直接返回 0 int count = 1; // 初始化计数器，最大值出现次数 ListNode maxNode = head; // 设置最大节点为头节点 int maxValue = maxNode.data; // 获取头节点的数据作为初始最大值 maxNode = head.link; // 移动到下一个节点 // 遍历链表 while (maxNode != null) { if (maxNode.data > maxValue) { // 如果发现更大的值 maxValue = maxNode.data; // 更新最大值 count = 1; // 重置计数器为 1，因为找到了新的最大值 } else if (maxNode.data == maxValue) { // 如果找到了相等的最大值 count++; // 计数器加 1 } maxNode = maxNode.link; // 继续遍历下一个节点 } return count; // 返回最大值出现的次数 } -
返回链表倒数第
k个节点public ListNode findKthToTail(int k) { // 快慢指针法 ListNode fast = head; ListNode slow = head; // 移动 fast 指针，前进 k 步 for (int i = 0; i < k; i++) { if (fast == null) { return null; // 如果 k 大于链表长度，返回 null } fast = fast.link; } // 快指针和慢指针同时移动，直到快指针到达末尾 while (fast != null) { fast = fast.link; slow = slow.link; } return slow; // slow 即为倒数第 k 个节点 }
山东大学 2023-2024 学年 一 学期 高级程序设计语言 课程试卷A
-
方法的返回值可以是基本数据类型，也可以是对象类型，包括自定义类的实例。
-
int是基本数据类型，不能直接调用equals()方法 -
continue语句用于终止当前循环的迭代，跳过本次循环中剩余的代码，然后继续下一次循环迭代。 -
并非程序中所有可能出现的异常都必须在
catch块中捕获。非检查异常（如RuntimeException及其子类）不需要显式捕获，而检查异常需要要么被捕获，要么用throws声明。 -
在方法定义中使用
throws关键字声明可能出现的异常，即使在方法调用时异常没有实际抛出，也不会影响代码的编译。throws声明用于告知调用者该方法可能会抛出的异常类型。 -
class Animal{ public String name; public Animal(String s){ name = s; } public void move(){ System.out.println(this + "在运动"); } public String toString(){ return "动物" + name; } } class Bird extends Animal{ public Bird(String s){ super(s); } public void move(){ System.out.println(this + "在飞行"); } public boolean equals(Object other){ System.out.print(name + " Object 判断相等 "); return super.equals(other); } public boolean equals(Bird other){ System.out.print(name + " Bird 判断相等 "); return true; } public String toString(){ return "小鸟" + name; } } public class T24A { public static void main(String\[] args){ Bird\[] blist = {new Bird("麻雀"),new Bird("鸿鹄")}; Animal\[] alist = {new Animal("大黄"), blist\[0],blist\[1]}; for (Animal a : alist) a.move(); System.out.println(alist\[0].equals(alist\[2]));; System.out.println(alist\[1].equals(blist\[0])); System.out.println(blist\[1].equals(blist\[0])); } }答案： 动物大黄在运动 小鸟麻雀在飞行 小鸟鸿鹄在飞行 false 麻雀 Object 判断相等 true 鸿鹄 Bird 判断相等 true编译时，根据引用类型，去对应的类中找参数列表符合的方法，锁定该方法；运行时，根据实际类型，去对应的子类中找刚刚锁定的方法的重写方法，没有就用刚刚的。
-
n个猴子围成一圈选大王，依次1-7循环报数，报到7的猴子被淘汰，直到最后一只猴子称为大王，写一个方法public static int monkeyKing(int n)，返回第几只猴子会成为大王?（10分）
public static int monkeyKing(int n) { boolean[] b=new boolean[n]; for(int i=0;i<b.length;i++){ b[i]=true; } int num=0; int monkeyLeft=n; int index=0; while(monkeyLeft>1){ if(b[index]){ num++; if(num==7){ b[index]=false; monkeyLeft--; num=0; } } index++; if(index==n){ index=0; } } //遍历数组,找到最后活着的那个猴子王 for(int i=0;i<b.length;i++){ if(b[i]){ return i+1; } } return 0; } -
public void removeRep ( ){ // 删除链表中值重复出现的节点 // 如假设当前链表为1->2->4->4->3->3->2->1->1， // 删除值重复的节点之后为1->2->4->3 }public void removeRep ( ){ ListNode cur=head; ListNode pre=null,next=null; while(cur!=null){ pre=cur; next=cur.link; while(next!=null){ if (cur.data==next.data) pre.link=next.link; else pre=next; next=next.link; } cur=cur.link; } }public void removeRep() { Set<Integer> seen = new HashSet<>(); // 用于记录已经遇到过的值 ListNode current = head; ListNode previous = null; while (current != null) { if (seen.contains(current.data)) { // 如果值已出现过，删除节点 previous.link = current.link; // 跳过当前节点 } else { seen.add(current.data); // 记录当前节点的值 previous = current; // 继续前进 } current = current.link; // 移动到下一个节点 } } -
public void reversePart ( int from , int to ) { //在链表中把第from个节点到第to个节点这一部分进行反转，假设 02->3->4->5->null，from=2，to=4 // 调整结果为1->4->3->2->5 //注意不使用额外的链表、堆栈等结构，不能填写到数组中，操作后再创建链表 public void reversePart(int from, int to) { if (from >= to) return; // 输入参数非法（from < to） ListNode dummy = new ListNode(); // 创建一个虚拟头节点，简化边界情况的处理 dummy.link = head; ListNode preFrom = dummy; // preFrom 指向 from 前一个节点 // 找到 from 的前一个节点 for (int i = 0; i < from - 1; i++) { preFrom = preFrom.link; } ListNode fromNode = preFrom.link; // 从第 from 个节点开始 ListNode toNode = fromNode; for (int i = from; i < to; i++) { toNode = toNode.link; } // 保存 toNode 后面的节点 ListNode nextToNode = toNode.link; // 将从 from 到 to 的部分反转 ListNode prev = null; ListNode current = fromNode; while (current != nextToNode) { ListNode next = current.link; current.link = prev; prev = current; current = next; } // 将反转后的链表重新连接 preFrom.link = prev; fromNode.link = nextToNode; if (from == 1) { head = prev; // 如果反转的是从头开始的部分，更新头节点 } }
山东大学 2023-2024 学年 一 学期 高级程序设计语言 课程试卷B
-
package语句定义的包名必须与文件的目录结构一致。例如，如果代码中使用package com.example;，那么该文件必须位于com/example目录下。 -
this关键字只能在实例方法中使用，因为它指向当前对象。而main方法是静态的，静态方法是与类相关的，而不是与某个特定的对象相关，因此不能在main方法中使用this。 -
abstract方法不能被声明为static，因为abstract方法需要被子类实现，而static方法属于类本身，不能被子类重写。 -
static方法不能直接访问非static属性。因为static方法属于类而不是对象，非static属性属于对象实例，static方法无法直接访问对象实例的非静态属性。 -
Object类定义了许多通用方法，如toString()、equals()等。继承自Object的类不需要强制重写toString()和equals()方法，但通常建议重写以提供更有用的实现。 -
使用
final定义的变量必须在声明时或者在构造方法中初始化 -
abstract class QAnimal{ public int distance = 0; int id; static int total = 0; public QAnimal(){ id = total++; } public void move(int d){ System.out.println(this + "方式：运动"); } public String toString(){ return "运动距离" + distance+","; } } class QBird extends QAnimal{ public void move(int d){ distance = d; System.out.println(this + "方式：飞行"); } public String toString(){ return id + "号小鸟" + super.toString(); } } class QTurtle extends QAnimal{ public void move(double s){ distance += (int)s; System.out.println(this); } public String toString(){ return id + "号海龟" + super.toString(); } } public class T24B { public static void main(String[] args){ QBird[] blist = {new QBird(),new QBird()}; QTurtle t = new QTurtle(); QAnimal[] alist = {blist[0],t,blist[1]}; for (QAnimal a : alist) a.move(100); t.move(15.0); } }答案：(打印this会调用tostring)
0号小鸟运动距离100,方式：飞行 2号海龟运动距离0,方式：运动 1号小鸟运动距离100,方式：飞行 2号海龟运动距离15,- 循环中每个元素调用move(100)。这里要注意，QAnimal的move方法参数是int，而QTurtle的move方法参数是double，所以在多态调用时，如果实际类型是QTurtle，会调用哪个方法？
- 因为QAnimal的move是public void move(int d)，而QTurtle有一个public void move(double s)，这并没有覆盖父类的方法，而是重载。因此，当通过QAnimal引用调用move(100)时，由于编译时类型是QAnimal，会调用QAnimal的move方法，而不是QTurtle的move(double)。因此，当处理到alist中的t（QTurtle实例）时，实际上调用的是QAnimal中的move方法，即打印“运动方式”，而distance没有被修改，保持0。而QBird实例覆盖了move(int)，所以它们的distance被设置为100，并打印飞行方式。
- 接下来，执行t.move(15.0)，这里参数是double，所以调用的是QTurtle自己的move方法，distance增加15，变成15，并调用toString打印。
山东大学 2024-2025 学年 一 学期 高级程序设计语言 课程试卷A
递归的某些读程序题关键点在于读懂方法的作用，层层递归太多的话很容易弄错，也容易弄不完
-
public static和static public是等价的，但通常习惯写成public static。 -
main方法必须声明为public static void main，并且接受一个字符串数组作为参数。 -
接口不继承
Object类，但实现接口的类继承Object类。 -
如果类没有重写
toString()方法，则使用Object类的toString()方法，默认返回对象的内存地址。 -
写一个高精度减法，方法头如下：public static String sub(String a, String b) ，其中a,b分别为被减数和减数，要求返回一个字符串表示的结果。如：sub(“123456789”,“1”) 返回为“123456788”；sub(“123456788”,“123456789”)返回为“-1”。需要注意：数字位数可能比较多。不能使用现成的如BigInteger、BigDecimal类实现（10分）
public class HighPrecisionSubtraction { public static String sub(String a, String b) { // 判断a, b哪个大，若a < b, 结果为负数 boolean isNegative = false; if (compare(a, b) < 0) { // 交换a和b，保证a >= b String temp = a; a = b; b = temp; isNegative = true; } // 将a和b填充至相同的长度 int lenA = a.length(); int lenB = b.length(); int maxLen = Math.max(lenA, lenB); a = padLeft(a, maxLen); b = padLeft(b, maxLen); // 结果的存储，最大可能需要lenA+1位 StringBuilder result = new StringBuilder(); int borrow = 0; // 从低位到高位进行逐位减法 for (int i = maxLen - 1; i >= 0; i--) { int digitA = a.charAt(i) - '0'; // 被减数的当前位 int digitB = b.charAt(i) - '0'; // 减数的当前位 // 进行减法，考虑借位 int diff = digitA - digitB - borrow; if (diff < 0) { diff += 10; borrow = 1; // 发生借位 } else { borrow = 0; } result.append(diff); } // 反转结果，去掉前导零 result.reverse(); // 去掉可能出现的前导零 while (result.length() > 1 && result.charAt(0) == '0') { result.deleteCharAt(0); } // 如果结果是负数，添加负号 if (isNegative) { result.insert(0, '-'); } return result.toString(); } // 比较两个字符串表示的数字，返回负数（a < b）、零（a == b）或正数（a > b） private static int compare(String a, String b) { // 先比较长度，长度较大的数字较大 if (a.length() > b.length()) return 1; if (a.length() < b.length()) return -1; // 长度相同，逐位比较 for (int i = 0; i < a.length(); i++) { if (a.charAt(i) > b.charAt(i)) return 1; if (a.charAt(i) < b.charAt(i)) return -1; } return 0; // 相等 } // 将数字字符串填充至指定长度，前面补0 private static String padLeft(String str, int length) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < length - str.length(); i++) { sb.append('0'); } sb.append(str); return sb.toString(); } // 测试 public static void main(String[] args) { System.out.println(sub("123456789", "1")); // 123456788 System.out.println(sub("123456788", "123456789")); // -1 System.out.println(sub("500", "200")); // 300 System.out.println(sub("1000", "999")); // 1 System.out.println(sub("5000", "10000")); // -5000 } } -
deleteDuplicates方法此方法删除链表中所有重复的节点，使得每个节点的值只出现一次。
public ListNode deleteDuplicates(ListNode head) { if (head == null) { return null; // 如果链表为空，直接返回 } ListNode current = head; while (current != null) { ListNode runner = current; // 删除当前节点之后所有重复的节点 while (runner.next != null) { if (runner.next.data == current.data) { runner.next = runner.next.next; // 删除重复节点 } else { runner = runner.next; // 继续查找 } } current = current.next; // 继续处理下一个节点 } return head; } -
hasCycle方法此方法判断链表中是否存在环。如果链表中存在环，返回
true；否则，返回false。public boolean hasCycle(ListNode head) { if (head == null || head.next == null) { return false; // 链表为空或只有一个节点，肯定没有环 } ListNode slow = head; ListNode fast = head; while (fast != null && fast.next != null) { slow = slow.next; // 慢指针每次走一步 fast = fast.next.next; // 快指针每次走两步 if (slow == fast) { return true; // 快慢指针相遇，说明链表有环 } } return false; // 快指针走到链表末尾，没有环 }
山东大学 2024-2025 学年 一 学期 高级程序设计语言 课程试卷B
class Element {
private String s;
public Element(String text) { s = text; }
public String toString() { return s; }
}
class B extends Element {
protected final Element sub;
public B(Element e) { super(""); sub = e; }
public String toString() {
return "" + sub.toString() + "";
}
}
class I extends B {
public I(Element e) { super(e); }
public String toString() {
return "" + sub.toString() + "";
}
}
public class T24 {
public static void main(String[] args) {
Element e = new Element("OK"), i = new I(e), b = new B(i);
System.out.println( e +"\n" + i +"\n" + b +"\n" + new I(b)); }
}
答案：
OK
OK
OK
OK
- 注意看，把前面的对象放进去了，别粗心
山东大学 2018-2019 学年 一 学期 高级程序设计语言 课程试卷
- 在 Java 中，小数默认是
double类型而不是float类型 - “r” 是字符串（String），而 char 类型应该用单引号，如
char ca = 'r';