企业官网建设流程全解析

简介：《Java基础知识笔试题及答案》是一份面向Java初学者、课程复习与笔试备考人群的练习资料，聚焦基础概念、语法要点与常见题型，帮助读者通过做题查漏补缺。内容以单选题、程序阅读题和编程题为主，覆盖包装类、equals与Calendar、List/Set/Map集合差异、LinkedList操作异常、String与数组处理、封装、泛型以及字符串连接替换、日期计算、堆栈实现等知识点，并附参考答案与示例代码。资料包共1个docx文件，约25KB，结构集中便于打印或按章节练习。目前已有1308人学习，适合用于期末复习、面试前基础巩固和课堂配套训练，也可对照题目理解常见陷阱与代码运行结果。

1. 基础笔试题型拆解：20 道选择题背后藏着的命题套路

Java 基础知识笔试，栽跟头的人往往不是不会写代码，而是"看着都会、一做就错"。这份题单里 20 道选择题加 8 道编程题，分值布局很有代表性：选择题吃的是语法细节和 API 记忆，编程题吃的是集合、字符串、日期的动手能力。命题人最喜欢在 String 的==与equals、Calendar 的实例获取、集合能否存重复元素、try-finally 的返回值这几处挖坑，几乎每套卷子都会换个马甲再考一遍。适合正在准备校招笔试、Java 基础认证或课程结课考试的人，把每道题"为什么选这个"想透，比刷十套押题卷都管用。下面按考点模块拆开讲，先讲高频考点，再逐题演练，最后把最容易丢分的细节单独拎出来。

2. 基础语法与 API 高频考点：包装类、String、Calendar 的必考细节

基础语法部分看起来散，其实命题有明确的收口：包装类对应基本类型、equals对应对象比较、Calendar对应日期计算、String.valueOf对应类型转换。这四类在各家笔试卷子里反复出现，换汤不换药。

2.1 包装类与 String：equals、== 和 valueOf 的三个坑

Java 为八种基本类型各配了一个包装类，Integer包int、Character包char、Boolean包boolean，而String本身就是引用类型，不是"包装原始字符串"的类——这是第一道题最容易读错的地方，题干问"包装原始字符串类型"的类，其实是在考你有没有把"包装类"和"字符串类"两个概念分清，答案自然是String。

equals的考点集中在"比较两个对象是否相等"这句话上。java.lang.Object提供的equals方法默认按引用比较，子类覆写后才有按内容比较的语义，String就覆写了它。笔试里常见的组合是：字面量String a = "It is"; String b = "It is";，a == b可能为true（同在字符串常量池），a.equals(b)一定为true；一旦换成new String("It is")，==立刻变false，equals仍然true。这组对比几乎每套卷子都会换个变量名再出现一次。

String.valueOf是类型转换的万金油，重载版本非常多，笔试常考三个：String.valueOf(10D)得到"10.0"，因为是double入参；String.valueOf(3 > 2)得到"true"，布尔值直接转字符串；String.valueOf(char[] data, 1, 3)从下标 1 开始取 3 个字符，得到"bcd"。第三个参数容易记反：第二个参数是起始偏移，第三个参数是长度，不是结束下标。

char[] data = {'a', 'b', 'c', 'd'}; System.out.println(String.valueOf(10D)); // 10.0 System.out.println(String.valueOf(3 > 2)); // true System.out.println(String.valueOf(data, 1, 3)); // bcd

这段代码对应题单第 7 题。第一行输出10.0而不是10，是因为入参字面量10D被编译器判定为double；第二行输出true，因为3 > 2的布尔结果有对应的String.valueOf(boolean)重载；第三行输出bcd，offset=1从b开始，count=3取b、c、d三个字符。答这类题时如果拿不准，先看实参的静态类型，再对应重载签名，比凭记忆猜稳。

提示：String.valueOf(null)在重载选择上有坑，char[]版本和Object版本的可选性不同，笔试里如果写出String.valueOf(null)又没给类型，通常判为编译歧义。

2.2 Calendar 与日期计算：getInstance 背后的设计

Calendar是抽象类，不能直接new，获得实例的唯一官方入口是Calendar.getInstance()。这一条几乎成了送分题，但答错的人不少——getTime()返回的是Date，get()返回的是某个字段的值，equals()比较对象，都不是"获取实例"。

日期计算有两道典型题：一道是"当前时间加 10 天并按xxxx 年 xx 月 xx 日输出"，另一道是"计算任意两个日期之间间隔的天数"。前者考add与字段读取，后者考getTimeInMillis与毫秒换算。

import java.util.Calendar; public class DateAddDemo { public static void main(String[] args) { Calendar cal = Calendar.getInstance(); // 在当前时间基础上加 10 天 cal.add(Calendar.DAY_OF_YEAR, 10); // MONTH 字段从 0 开始，输出时要 +1 String strDate = cal.get(Calendar.YEAR) + "年" + (cal.get(Calendar.MONTH) + 1) + "月" + cal.get(Calendar.DATE) + "日"; System.out.println("10 天后的日期为：" + strDate); } }

这段代码对应题单第 12 题。Calendar.DAY_OF_YEAR是字段常量，add的第二个参数可以是负数，表示往前推；get(Calendar.MONTH)返回 0～11，所以拼字符串时一定要+1，这是血泪经验，很多人输出月份少 1 却查不出原因。get(Calendar.DATE)与get(Calendar.DAY_OF_MONTH)等价，前者更短。日期格式如果要求补零，光靠字符串拼接不够，得用String.format("%02d", month)或SimpleDateFormat，题单里没强制补零，但面试官问"如果要求 05 月怎么办"时，要能立刻答出这两种方案。

计算两个日期间隔天数的题，核心是把Calendar转成毫秒再除。

import java.util.Calendar; public class DaysBetweenDemo { public static void main(String[] args) { Calendar c1 = Calendar.getInstance(); c1.set(2010, 7, 1); // 注意：7 表示 8 月 Calendar c2 = Calendar.getInstance(); long ca1 = c1.getTimeInMillis(); long ca2 = c2.getTimeInMillis(); // 毫秒差除以一天的毫秒数 long days = (ca2 - ca1) / (24 * 60 * 60 * 1000); System.out.println(days); } }

题单第 14 题给的就是这段。set(2010, 7, 1)里的7是月份下标，实际是 8 月 1 日，这是Calendar月字段从 0 开始的第二次提醒。getTimeInMillis()返回自纪元起的毫秒数，两个long相减不会溢出，再除以24 * 60 * 60 * 1000得到天数。这里有个隐藏坑：如果只算日期不算时分秒，当前时刻的时分秒会带进差值，结果可能少一天，严谨做法是先把两个Calendar的HOUR_OF_DAY、MINUTE、SECOND、MILLISECOND都清零。

2.3 真题演练：从选择题到编程题的转化

题单一（选择题原型）：LinkedList list = new LinkedList(); list.add("A"); list.add(2, "B");编译运行结果是什么？选项给的是编译错误、运行时异常、输出 A、输出 B。

答题思路：先看 API 签名，LinkedList.add(int index, E element)在指定位置插入，插入前会做下标检查index >= 0 && index <= size。此时size是 1（已经add("A")），传index=2越界，运行期抛IndexOutOfBoundsException。所以答案是"运行时引发异常"。面试官如果追问"那list.add(1, "B")呢"，答案是正常插入，get(1)拿到"B"，因为index == size是允许的，相当于追加到末尾。

题单二（编程题原型）：比较两个字符串str1 = "It is"与str2 = "It is"是否相等，把" a book."接到str1上，再用m替换新串里的i。

public class StringOpDemo { public static void main(String[] args) { String str1 = "It is"; String str2 = "It is"; // 引用比较与内容比较的差异 System.out.println("str1 == str2 的结果：" + (str1 == str2)); System.out.println("str1.equals(str2) 的结果：" + str1.equals(str2)); // concat 返回新串，原串不变 String str3 = str1.concat(" a book."); System.out.println("连接后的字符串为：" + str3); // replace 返回新串 String str4 = str3.replace('i', 'm'); System.out.println("替换后的字符串为：" + str4); } }

这题对应题单第 11 题。==比引用，两个字面量都在常量池里指向同一个对象，所以打印true；equals比内容，也是true。concat和replace都返回新字符串，str1和str3本身不变，这是String不可变性的直接体现。面试官爱在这里追问"那StringBuilder呢"，答"可变、append返回自身、循环拼接优先用它"即可。答编程题时要注意：题目说"连接" a book."与str1"，concat的实参里那个前导空格不能省，少了空格输出就会变成It isa book.，判卷时按字符串精确匹配，一分不给。

3. 集合框架与泛型：List、Set、Map 的存储规则与泛型设计

集合是笔试里分值最高的模块之一，选择题爱考"谁能存重复、谁不能"，编程题爱考"用集合实现某个数据结构"和"写一个泛型方法"。把接口的存储规则和泛型的类型参数两条线抓住，这块钱基本就稳了。

3.1 集合接口存储规则：List、Set、Map 各自能不能存重复

先看题单里那道"下面的集合中，（）不可以存储重复元素"，选项给了Set、Collection、Map、List，参考答案是Map。这里要理解命题人的视角：Map存的是键值对，键唯一，put相同键会覆盖旧值，所以"存储重复元素"这件事在Map的键上不被允许。但严格说Set也不允许重复元素，List才允许。遇到这种题，判断依据是选项组合和题干措辞——如果同时给了Set和Map，要看题干强调"元素"还是"键值对"，很多题库把Map当答案，是因为它考察的是"键唯一"这一特性。

再看"关于Map和List说法正确的是"，参考答案是"Map的value可以是List或Map"。Map不继承List，两者是并列的集合接口；List里可以放Map或List，Map的值也可以是任意对象，包括另一个Map。这题考的是集合的嵌套能力，答"集合元素类型是Object，所以可以互相嵌套"就抓住了本质。

这张表建议直接背下来。面试官问"HashSet怎么保证不重复"时，答"底层是HashMap，元素当键存，值放一个固定的PRESENT对象"就到位了；问"TreeSet怎么排序"时，答"元素实现Comparable或构造时传Comparator"。

3.2 泛型方法与泛型集合：从通配到类型参数

泛型的定义题在题单里出现过两次：一次问"什么是泛型、有什么优点、泛型List和普通List有什么区别"，一次要求写泛型方法。标准答法是：泛型是对 Java 类型系统的扩展，用类型参数把类或方法参数化；优点是类型安全、消除强制转换、提高代码复用率；泛型List<String>只能存String，取出时不用强转，普通List什么都能存，取出要强转且容易ClassCastException。

泛型方法的关键在类型参数声明的位置：写在返回值之前。题单第 19 题要求"返回int数组和String数组的最大最小值"，标准写法是定义一个Pair<T>承载结果，再加一个<T extends Comparable>的静态方法。

class Pair<T> { private T min; private T max; public Pair(T min, T max) { this.min = min; this.max = max; } public T getMin() { return min; } public T getMax() { return max; } } class ArrayAlg { // T 必须可比较，才能调用 compareTo public static <T extends Comparable> Pair<T> minmax(T[] a) { if (a == null || a.length == 0) return null; T min = a[0]; T max = a[0]; for (int i = 1; i < a.length; i++) { if (min.compareTo(a[i]) > 0) min = a[i]; if (max.compareTo(a[i]) < 0) max = a[i]; } return new Pair<T>(min, max); } }

这段对应题单第 19 题。<T extends Comparable>是上界约束，保证T有compareTo方法，Integer和String都实现了Comparable，所以同一个方法能同时处理两种数组。compareTo返回负数表示前者小、正数表示前者大、0 表示相等，判断最小值用> 0、最大值用< 0，方向别写反。如果题目要求"按字典序"，String的compareTo默认就是字典序，不用额外处理。

题单第 20 题是另一个泛型方法：把数组元素塞进集合。

import java.util.*; public class ArrayToCollectionDemo { // T 由调用处推断，数组元素类型和集合元素类型必须兼容 static <T> void fromArrayToCollection(T[] a, Collection<T> c) { for (T o : a) { c.add(o); } } public static void main(String[] args) { Integer[] ia = new Integer[100]; Collection<Number> cn = new ArrayList<Number>(); // Integer[] 可以传给 T[]，Collection<Number> 使 T 推断为 Number fromArrayToCollection(ia, cn); System.out.println(cn); } }

这题的难点是类型推断：ia是Integer[]，cn是Collection<Number>，两者共同约束出T = Number，Integer[]是Number[]的子类型，所以能传。如果写成Collection<Integer>也成立，T就是Integer。面试官追问"能不能把Collection<Object>传给Collection<Number>"，答案是不能，泛型不支持协变，除非用? extends Number通配符。

3.3 真题演练：泛型 Map 与自定义 Stack

题单一：用泛型Map存 10 个英文单词和中文释义，输入单词返回翻译。

import java.util.*; public class DictDemo { public static void main(String[] args) { String[] eng = {"Apple", "Orange", "Green"}; String[] chs = {"苹果", "桔子", "绿色"}; Map<String, String> map = new HashMap<String, String>(); for (int i = 0; i < eng.length; i++) { map.put(eng[i], chs[i]); } String test = "Orange"; System.out.println(test + " 翻译：" + map.get(test)); } }

对应题单第 22 题。Map<String, String>把键和值都限定为字符串，put时如果类型不对编译期就报错，这是泛型相对普通Map最直接的优势。get传入不存在的键返回null，如果业务上不允许null，要先用containsKey判断。

题单二：实现一个后进先出的Stack类，提供add、get、delete三个方法。

import java.util.LinkedList; class Stack { private LinkedList<Object> list; public Stack() { list = new LinkedList<Object>(); } public void add(Object obj) { list.addFirst(obj); // 每次插到头部 } public Object get() { return list.getFirst(); // 取头部即栈顶 } public void delete() { list.removeFirst(); // 删除栈顶 } } public class StackDemo { public static void main(String[] args) { Stack stack = new Stack(); stack.add("1"); stack.add("2"); stack.add("3"); System.out.println(stack.get()); // 3 stack.delete(); System.out.println(stack.get()); // 2 } }

对应题单第 13 题。LinkedList的addFirst、getFirst、removeFirst三个方法配合，天然就是栈的操作。如果面试官要求用数组实现，思路是维护一个int top指针，add时top++，get时返回arr[top-1]，delete时top--，扩容策略可以在追问里再展开。注意题单原始代码里list是包级可见字段，实际写的时候建议用private加泛型，面试官看到private会加分。

4. 异常处理与流程控制：try-catch-finally 的执行顺序与自定义异常

异常模块的题量在题单里占了一半，从"什么是异常"到"自定义异常捕获输入"，覆盖了概念、分类、try-catch-finally执行顺序、返回值、自定义异常五个层次。这块钱的关键不是背定义，而是能在脑子里把执行流程走一遍。

4.1 异常体系与分类：Throwable 下面的两条分支

题单第一题问"什么是异常、什么是异常处理机制"，标准答法是：异常是程序运行过程中产生的错误，异常处理机制是预先提供处理方法、在异常发生时代码按预定逻辑处理、处理完继续运行的能力。第二题问分类，答案分两类：内部错误（Error，致命，如硬件故障）和运行时异常（RuntimeException，如除零、数组越界）。

第三题问"所有异常的父类"，选项有Error、Throwable、RuntimeException、Exception，答案是Throwable。Throwable往下分两支：Error和Exception，Exception再分RuntimeException（非受检）和其他受检异常。这棵树的形状要能当场画出来，面试官经常在画到RuntimeException时打断问"哪些是受检的"。

第四题"下列操作不会抛出异常"问的四个选项分别对应除零、负索引、打开不存在的文件，答案给的是"以上都会抛出异常"。除零抛ArithmeticException，负索引抛ArrayIndexOutOfBoundsException，打开不存在的文件抛FileNotFoundException。这题不需要绕，直接对着异常类型说。

4.2 try-catch-finally 的执行顺序与返回值

这是异常模块最容易翻车的地方。题单里有两道经典题。

第一道：try里打印"try，"然后return，catch打印"catch，"，finally打印"finally"，问输出。答案是try，finally。try里return之后catch不执行（因为没异常），但finally一定执行，哪怕前面已经return。

第二道：try里return 5/0，catch里return 2*3，finally里return 3，问返回值。答案是3。

public class FinallyReturnDemo { public static int count() { try { return 5 / 0; // 抛 ArithmeticException } catch (Exception e) { return 2 * 3; // 6，但会被 finally 覆盖 } finally { return 3; // 最终返回 3 } } public static void main(String[] args) { System.out.println(count()); // 3 } }

这段对应题单第 9 题。执行顺序是：try中5 / 0抛ArithmeticException，控制流转到catch，return 2 * 3先算出6并暂存，然后finally执行，return 3把暂存的6覆盖掉，最终返回3。面试官追问"如果finally里没有return呢"，答案是返回6；再追问"如果try里没有抛异常、finally里有return呢"，答案依然是finally的返回值生效。结论只有一条：finally里写return会覆盖try和catch的返回值，实际开发中禁止这么写。

finally的另一个高频问题是"什么情况下不执行"。答案是：System.exit()被调用、JVM 崩溃、try之前就抛了异常、或者线程被杀。多数笔试只考System.exit()这一个。

4.3 真题演练：自定义异常与输入校验

题单一：从键盘读字符串，如果是"abc"就抛自定义异常，否则不抛。

import java.util.Scanner; class MyException extends Exception { private String errorMsg; public MyException(String errorMsg) { this.errorMsg = errorMsg; } @Override public String toString() { return errorMsg; } } public class CustomExceptionDemo { public static void main(String[] args) { Scanner scan = new Scanner(System.in); String input = scan.nextLine(); try { if ("abc".equals(input)) { throw new MyException("输入的字符串不正确！"); } System.out.println("输入正常：" + input); } catch (MyException e) { System.out.println(e); } } }

对应题单第 11 题。自定义异常三要素：继承Exception（或RuntimeException）、提供带消息的构造方法、覆写toString或getMessage。判断字符串相等时用"abc".equals(input)而不是input.equals("abc")，把常量放前面可以避免input为null时的空指针。

题单二：产生并捕获ArrayIndexOutOfBoundsException，输出异常信息。

public class ArrayExceptionDemo { public static void main(String[] args) { int[] arr = new int[2]; try { System.out.println(arr[2]); // 下标 2 越界 } catch (ArrayIndexOutOfBoundsException e) { e.printStackTrace(); } } }

new int[2]合法下标是 0 和 1，访问 2 抛ArrayIndexOutOfBoundsException，catch里printStackTrace打印调用栈，实际项目里更推荐用日志框架。

题单三：从键盘读两个数做减法，输入含非数字时通过异常处理让程序正常运行。思路是用Integer.parseInt包在try里，捕获NumberFormatException，提示用户重新输入。这题在题单里被截断了，但答题框架完整：Scanner读两行、try里parseInt、catch (NumberFormatException e)输出提示、外层用while循环直到输入合法。

多重catch的顺序也是考点，题单第 6 题问"哪个异常类应该最后列出"，答案是Exception。子类异常必须写在父类前面，否则子类的catch块永远进不去，编译器会直接报错。

5. 易错点清单：5 个最容易在考场上丢分的细节

5.1 把add(index, element)的越界当成编译错误

错在哪：看到LinkedList未加泛型、直接add(2, "B")，第一反应是"类型不安全，编译不过"，选了"编译时发生错误"。

为什么错：LinkedList的add(int, E)接受Object，传"B"没问题，编译器不报错；真正的问题在运行期，index=2超过了当前size=1，抛IndexOutOfBoundsException。

怎么答对：先看方法签名，再看下标边界0 <= index <= size。题干里只要出现"指定位置插入"，把size和index比一下，越界就是运行时异常，不越界就正常执行。

5.2 分不清数组元素默认值和局部变量必须初始化

错在哪：题单第 8 题输出0 0 null，有人答成"编译错误，局部变量未初始化"。

为什么错：new int[5]创建的是数组对象，对象里的元素有默认值——int默认0、引用类型默认null。只有方法内的局部基本类型变量（如int x;）才要求显式初始化。数组元素属于对象字段，不受这条规则约束。

怎么答对：先判断"这个变量是局部变量还是对象成员/数组元素"。数组元素、成员变量有默认值，局部变量没有。答这类输出题时按代码顺序逐个执行，amethod()里的K[3]也是0，obj[2]是null，顺序不能乱。

5.3 以为catch里的return一定生效

错在哪：try抛异常、catch里return 6、finally里return 3，答成6。

为什么错：finally的执行优先级高于try和catch的return，catch里的6只是暂存，finally的return 3会把它覆盖。

怎么答对：看到finally里有return，直接以finally的返回值为准，同时提醒自己"实际开发禁止这么写"。如果finally里只是打印没有return，才回到catch的返回值。

5.4Calendar.MONTH从 0 开始，忘了+1

错在哪：加 10 天后输出"2024 年 11 月 15 日"，实际应该是 12 月。

为什么错：Calendar.MONTH的取值是 0～11，get(Calendar.MONTH)拿到的是 11 表示 12 月，拼字符串时忘了+1。

怎么答对：凡是get(Calendar.MONTH)后面跟字符串拼接，强制+1；set(year, month, day)里的month同样从 0 开始。不确定的时候就在草稿纸上写"MONTH 0-based"提醒自己。

5.5 多重catch里父类写在了子类前面

错在哪：先catch (Exception e)再catch (ArrayIndexOutOfBoundsException e)，以为能精确匹配。

为什么错：Exception是所有受检异常的父类，写在前面会先接住所有异常，后面的子类catch块变成不可达代码，编译器直接报错。

怎么答对：按"子类在前、父类在后"排，ArrayIndexOutOfBoundsException、NumberFormatException这类具体异常先写，Exception收尾兜底。题单第 6 题就是把这条规则做成了选择题。

6. 编程题答题模板：从"能跑"到"能拿满分"的收尾习惯

编程题和选择题的评分逻辑完全不同。选择题看结果，编程题看过程——同样跑出正确输出，有的卷子给满分，有的扣一半，差别就在几个收尾动作上。带过几轮笔试复盘之后，我总结出一套固定流程，每道编程题都强制走一遍。

第一步，先写"输入—处理—输出"三段式骨架，不要一上来就抠细节。题单里茶叶销售那道题，输入是"3-100-2.1"一行三值、用-分隔，处理是单价 * 包数 * 每包克数，输出是销售总额。骨架先立住，再填Scanner的useDelimiter("-")，最后检查nextInt和nextFloat的调用顺序是否与输入顺序一致。

第二步，异常和边界单独留一行注释。题单里"两个数相减、输入含非数字"那题，核心不是减法，是NumberFormatException的捕获。答题时在try上方写一行// 捕获非数字输入，提示重试，阅卷人一眼能看出你知道考点在哪。

第三步，返回值和副作用分开检查。String.concat、String.replace、Calendar.add都是返回新对象或修改自身，String系列不改原串、Calendar系列改自身，写完后回头看一眼有没有把返回值丢掉。

import java.util.Scanner; public class TeaSalesDemo { public static void main(String[] args) { Scanner scan = new Scanner(System.in); System.out.println("请依次输入重量、包数、价格，并以-分隔："); String line = scan.nextLine(); // 二级 Scanner 复用同一行输入，分隔符设为 - Scanner sc = new Scanner(line); sc.useDelimiter("-"); int weight = sc.nextInt(); int bags = sc.nextInt(); float price = sc.nextFloat(); double total = weight * bags * price; System.out.println("销售总额为：" + total); } }

这段对应题单第 18 题。useDelimiter("-")把分隔符从默认空白换成-，nextInt读重量、nextInt读包数、nextFloat读价格，顺序错一个就抛InputMismatchException。double total用double而不是float，避免3 * 100 * 2.1出现629.9999这类精度尾巴。这类题面试官常追问"如果输入格式不对怎么办"，答"捕获InputMismatchException并提示重新输入"就能接住。

第四步，进制转换这类"造轮子"题，先确认 JDK 有没有现成方法。题单第 17 题要求把十进制365转十六进制字符串，标准答案手写了一个DtoX循环取余，但实际有Integer.toHexString(365)一行搞定。笔试里如果题目明确要求"自己实现"，就按取余 + 倒序拼的模板写；没要求就用 JDK 方法，省下的时间检查别的题。手写版本的易错点在倒序：余数是从低位到高位产生的，拼字符串时必须从后往前，题单原始代码用了一个临时数组m存余数、最后倒着拼，这个套路可以背下来。

public class HexConvertDemo { public static void main(String[] args) { long num = 987654L; int i = 365; // long 转 String System.out.println("Long 类型转换为 String：" + String.valueOf(num)); // 十进制转十六进制，JDK 自带方法 System.out.println("365 的十六进制：" + Integer.toHexString(i)); } }

对应题单第 17 题的前半段。String.valueOf(long)有对应重载，不会走Object版本；Integer.toHexString返回小写十六进制，如果要大写就.toUpperCase()。注意题单里那句"用parseInt方法将字符串200由十六进制转换为十进制"，Integer.parseInt("200", 16)的第二个参数是基数，返回512，不是200——基数参数的位置和含义是这题最容易答反的地方。

第五步，收尾时把变量名和注释过一遍。str1、str2这种名字在草稿上无所谓，誊到答题卡上最好换成source、target之类能自解释的名字；每个try块上方加一行注释说明捕获什么异常。这些动作不花时间，但能让阅卷人在几秒钟内判断"这个人知道自己在写什么"。

从那以后我每次进考场，编程题都强制走一遍"骨架—异常—返回值—现成 API—命名注释"这五步，哪怕题目再简单也不跳。选择题靠知识点，编程题靠习惯，习惯稳了，分数才稳。希望帮到你。

本文还有配套的精品资源，点击获取