企业官网建设流程全解析

1. 从标题说起：一个被搜索引擎玩坏的语法问题

“spite用法 java_despite 和in spite of 用法”——这个标题本身就挺有意思。前半截是英语语法问题，后半截突然蹦出个“java”，中间用下划线连着，一看就是搜索引擎自动拼接的结果。大概率是有人搜“despite 和 in spite of 用法”的时候，输入法或者搜索框联想出了“java”相关的内容，然后被爬虫抓下来生成了这么个四不像的标题。

但既然这个标题被抛到我面前，我就按从业者的思路把它拆开看。这里面其实藏着两条线：一条是英语中despite和in spite of的用法辨析，另一条是 Java 技术栈里那些跟“spite”长得像、或者容易被混淆的概念。两条线单独看都不复杂，但放在一起就很有意思了——因为它们背后反映的是同一个问题：面对看起来相似的东西，怎么快速抓住本质区别，而不是被表面形式带偏。

我在带新人的时候经常遇到这种情况。有人拿着一个报错信息来问，说“这个spite相关的异常怎么处理”，我一看，其实是spite拼错了，应该是split。还有人把despite和in spite of的用法搞混，写技术文档的时候用错了介词，导致整句话的意思完全反了。这些都不是什么高深的技术问题，但确实会浪费很多时间。

所以这篇内容我打算这么写：先把despite和in spite of的用法彻底讲清楚，包括它们和although、though、even though这些词的区别，然后延伸到 Java 技术场景里那些容易混淆的概念——比如split和spite的拼写陷阱、despite在代码注释里的常见误用、以及 Java 面试中那些看起来像语法题实际上是逻辑题的坑。最后再聊聊怎么建立一套自己的“易混淆概念排查方法”，这套方法不光能用在英语语法上，也能用在 Java 学习和日常开发中。

适合谁来读？如果你是 Java 初学者，正在被各种相似概念搞得头晕，这篇能帮你理清思路。如果你是有经验的开发者，想看看别人是怎么处理“看起来差不多但实际不一样”的问题，这篇也能给你一些参考。如果你只是碰巧搜到了这个标题，想搞清楚despite和in spite of到底怎么用，那更没问题，第一部分就是为你准备的。

2. despite 和 in spite of 到底怎么用：从词性到语感的完整拆解

2.1 先记住一个核心结论：它俩意思一样，但用法有细微差别

despite和in spite of在绝大多数情况下可以互换，意思都是“尽管、虽然”，表示让步关系。但如果你仔细抠，会发现几个关键区别。

第一个区别是词性来源。despite本身是一个介词，后面直接跟名词、代词或者动名词。in spite of是一个介词短语，功能上等同于一个介词，后面也是跟名词、代词或者动名词。从语法功能上说，两者完全一致。

第二个区别是正式程度。despite更正式一些，在学术写作、技术文档、商务邮件里更常见。in spite of稍微口语化一点，但也不算随便，日常交流、邮件、报告里都能用。如果你在写 Java 技术文档或者 API 说明，用despite会显得更专业。

第三个区别是音节节奏。despite是两个音节，读起来干脆利落。in spite of是三个音节，读起来稍微拖沓一点。在口语里，如果句子本身已经很长了，用despite会更顺口。比如 “Despite the complexity of the Java memory model, the garbage collector handles most cases automatically.” 这句话如果换成 “In spite of the complexity...”，读起来就有点喘不过气。

第四个区别是搭配习惯。有些固定搭配里用despite更自然，比如despite the fact that、despite oneself。而in spite of后面如果跟the fact that，虽然语法上没问题，但实际使用频率远低于despite the fact that。这个不是硬性规则，但你在写东西的时候可以留意一下。

2.2 后面跟什么：名词、代词、动名词，一个都不能少

这是最容易出错的地方。很多人知道despite和in spite of表示“尽管”，但一到写句子就写成despite he is tired这种错误形式。记住一个铁律：这两个词后面绝对不能直接跟完整的句子（主语+谓语）。

正确的用法是后面跟：

• 名词：Despite the rain, we went out.（尽管下雨，我们还是出去了。）
• 代词：In spite of that, he continued working.（尽管如此，他继续工作。）
• 动名词（-ing形式）：Despite being tired, she finished the task.（尽管很累，她还是完成了任务。）
• what 从句：Despite what you think, this approach works.（不管你怎么想，这个方法有效。）

如果你非要跟一个完整的句子，那就必须加the fact that：Despite the fact that he was tired, he kept coding.但说实话，这种写法有点啰嗦，能简化就简化。比如上面那句可以改成Despite being tired, he kept coding.意思一样，但更干净。

我在审校技术文档的时候，经常看到有人写Despite the API returns an error, the program continues.这就是典型的错误，因为the API returns an error是一个完整句子。正确的写法是Despite the API returning an error, the program continues.或者Despite the fact that the API returns an error, the program continues.前者更简洁，推荐用前者。

2.3 和 although、though、even though 的区别：一个表格说清楚

很多人搞不清楚despite和although的区别，其实核心就一条：despite是介词，后面跟名词性成分；although是连词，后面跟完整句子。

从语气强度上说，even though最强，强调“即使在这种情况下也……”。although和though差不多，though更口语化。despite和in spite of的语气介于中间，但更偏向客观陈述。

还有一个容易混淆的点：despite和in spite of不能和but连用。比如你不能说Despite he was tired, but he kept working.这是双重让步，语法上错误。要么用Despite being tired, he kept working.，要么用He was tired, but he kept working.二选一。

2.4 在 Java 技术写作中的实际应用

写 Java 技术文档、代码注释、提交信息的时候，despite和in spite of出现的频率其实不低。我举几个实际场景。

场景一：描述异常处理逻辑

// Despite the null check, a NullPointerException can still occur // if the object is modified concurrently.

这里用Despite就很合适，因为后面跟的是名词短语the null check。如果你写成Although the null check exists, a NullPointerException can still occur.语法上没问题，但读起来不如Despite简洁。

场景二：解释为什么某个设计决策看起来不合理但实际有道理

// In spite of the performance overhead, we chose this approach // because it provides better readability and maintainability.

这里用In spite of也可以，但我会更倾向于用Despite，因为技术文档里Despite更常见，而且少一个音节，读起来更顺。

场景三：代码审查意见

Despite the fact that this method works, it violates the single responsibility principle. Consider refactoring.

这句话在代码审查里很常见。注意这里用了Despite the fact that，因为后面跟的是完整句子this method works。如果你想简化，可以改成Despite working correctly, this method violates the single responsibility principle.意思一样，但更紧凑。

一个常见的错误：有人在代码注释里写Despite the method returns null, the caller handles it.这是错的，因为the method returns null是完整句子。应该改成Despite the method returning null, the caller handles it.或者Despite the fact that the method returns null, the caller handles it.

3. Java 场景里那些“长得像 spite”的坑：拼写、概念与面试陷阱

3.1 split 和 spite：一个字母之差，结果天壤之别

spite和split只差一个字母，但在 Java 里完全是两码事。split是String类的一个常用方法，用来按正则表达式拆分字符串。spite在 Java 里根本不是一个关键字或者常用类名，它只出现在英语语法里。

我为什么要把这个拿出来说？因为我在实际工作中真的见过有人把split拼成spite，然后对着编译错误发呆。比如：

String[] parts = str.spite(","); // 编译错误：找不到符号

正确的写法是：

String[] parts = str.split(",");

这个错误看起来很低级，但在快速敲代码的时候确实容易发生。尤其是i和l在键盘上离得近，split打成spite或者splite都是常见手误。我的建议是：如果你用 IDE，开启拼写检查插件；如果你用命令行，编译报错的时候先检查方法名拼写，别急着怀疑逻辑。

还有一个相关的坑：split的参数是正则表达式，不是普通字符串。比如你想按点号.拆分，不能直接写str.split(".")，因为.在正则里表示任意字符。正确的写法是str.split("\\.")。这个坑我见过太多人踩了，包括一些工作两三年的开发者。

3.2 despite 在 Java 面试题里的变体：看起来考语法，实际考逻辑

Java 面试里有一类题，表面上是考英语语法或者拼写，实际上考的是你对 Java 基础概念的理解。我举几个例子。

例题一：以下代码的输出是什么？

String s = "a,b,c"; String[] arr = s.split(","); System.out.println(arr.length);

这道题看起来很简单，答案是 3。但如果我改成：

String s = "a,b,c,"; String[] arr = s.split(","); System.out.println(arr.length);

答案还是 3，不是 4。因为split方法默认会去掉末尾的空字符串。如果你想保留末尾的空字符串，需要传第二个参数-1：s.split(",", -1)。这个行为在 Java 文档里有写，但很多人没注意。

例题二：以下代码有什么问题？

// Despite the list is empty, the loop still executes once. List<String> list = new ArrayList<>(); for (String item : list) { System.out.println(item); }

这段代码的注释是错的。Despite the list is empty语法上就不对，应该是Despite the list being empty或者Although the list is empty。而且for-each循环在空列表上不会执行任何一次，注释说“still executes once”也是错的。这道题考的是你能否同时发现语法错误和逻辑错误。

例题三：以下代码的时间复杂度是多少？

public boolean hasDuplicate(String[] arr) { for (int i = 0; i < arr.length; i++) { for (int j = i + 1; j < arr.length; j++) { if (arr[i].equals(arr[j])) { return true; } } } return false; }

这是 O(n²) 的暴力解法。面试官可能会追问：你能优化吗？你可以用HashSet做到 O(n)。这道题本身不难，但如果你在解释的时候说 “Despite the nested loops, the actual performance is acceptable for small arrays.” 那就用对了Despite，因为后面跟的是名词短语the nested loops。

3.3 Java 八股文里的“相似概念”陷阱

Java 面试里有很多“看起来差不多但实际不一样”的概念，我整理了一个速查表：

这些概念在面试里经常被拿来对比。如果你能用Despite或者In spite of造一个句子来解释它们的区别，面试官会觉得你不仅懂技术，表达能力也不错。比如：

Despite both being used for string manipulation,StringandStringBuilderdiffer in mutability and performance characteristics.

这句话用Despite就很自然，因为后面跟的是名词短语both being used for string manipulation。

3.4 从“spite”到“split”：一个排查拼写错误的通用方法

我在带新人的时候，发现很多人遇到编译错误的第一反应是“我的逻辑是不是有问题”，而不是“我是不是拼错了”。其实 Java 编译器给出的错误信息已经很明显了，比如cannot find symbol通常就是拼写错误或者缺少导入。

我总结了一个排查拼写错误的四步法：

1. 看错误信息里的符号名：编译器会告诉你它找不到哪个符号。如果符号名看起来像你写的方法名，先检查拼写。
2. 用 IDE 的自动补全：如果你用 IntelliJ IDEA 或者 Eclipse，输入方法名的前几个字母，按Ctrl+Space，看看有没有你想要的。如果没有，说明你拼错了。
3. 搜索官方文档：去 Oracle 的 Java SE API 文档里搜一下，确认这个方法是否存在。比如你搜spite，会发现根本没有这个方法。
4. 检查大小写：Java 是大小写敏感的语言，Split和split是两个不同的东西。String类的split方法首字母是小写的。

这个方法不光适用于split和spite，也适用于其他容易混淆的方法名，比如length和length()、size和size()。数组用length属性，字符串用length()方法，集合用size()方法。这些细节在面试里经常被问到。

4. 实操：在 Java 项目里正确处理“尽管”逻辑与字符串拆分

4.1 一个完整的字符串拆分示例：从需求到实现

假设你有一个需求：从一段文本里提取所有的邮箱地址。文本格式是姓名<邮箱>,姓名<邮箱>,...，比如张三<zhangsan@example.com>,李四<lisi@example.com>。你需要把每个邮箱提取出来。

这个需求看起来简单，但里面有几个坑。第一个坑是分隔符不统一，可能用逗号，也可能用分号。第二个坑是邮箱里可能包含特殊字符。第三个坑是末尾可能有空字符串。

我先写一个基础版本：

public List<String> extractEmails(String input) { List<String> emails = new ArrayList<>(); if (input == null || input.isEmpty()) { return emails; } String[] parts = input.split("[,;]"); for (String part : parts) { int start = part.indexOf('<'); int end = part.indexOf('>'); if (start != -1 && end != -1 && start < end) { emails.add(part.substring(start + 1, end)); } } return emails; }

这段代码能处理大部分情况，但有几个问题。第一，split("[,;]")用的是正则表达式，[,;]表示逗号或分号，这个没问题。第二，如果输入是张三<zhangsan@example.com>,，末尾有个逗号，split会去掉末尾的空字符串，所以不会产生空元素。第三，如果邮箱里包含<或>，这个逻辑会出错，但实际邮箱地址不会包含这两个字符，所以可以接受。

现在考虑一个边界情况：如果输入是张三<zhangsan@example.com>;李四<lisi@example.com>;，末尾有分号，split同样会去掉末尾的空字符串。但如果你用的是split("[,;]", -1)，就会保留末尾的空字符串，然后part.indexOf('<')会返回 -1，不会添加空邮箱。所以两种写法都能工作，但-1版本更明确地表达了“我要保留所有部分”的意图。

我在实际项目里会加一个日志，记录拆分后的数组长度和每个部分的原始内容，方便排查问题：

String[] parts = input.split("[,;]", -1); logger.debug("Split input into {} parts: {}", parts.length, Arrays.toString(parts));

这个日志在调试的时候非常有用。有一次线上出现了一个奇怪的 bug，用户输入的文本里包含了一个特殊的分隔符，导致拆分结果不对。有了这个日志，我很快就定位到了问题。

4.2 用 despite 写清晰的代码注释：一个实际案例

代码注释是技术写作的一部分，用对despite和in spite of能让注释更专业。我拿一个实际的方法来举例。

假设你有一个方法，用来计算订单的总价，但有一些特殊情况需要处理：

/** * Calculates the total price of an order. * * Despite the complexity of the pricing rules, this method * guarantees that the final price is never negative. * * @param order the order to calculate * @return the total price, always >= 0 */ public BigDecimal calculateTotal(Order order) { BigDecimal total = BigDecimal.ZERO; for (OrderItem item : order.getItems()) { total = total.add(item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity()))); } // Apply discount, but ensure the result is not negative total = total.subtract(order.getDiscount()); if (total.compareTo(BigDecimal.ZERO) < 0) { total = BigDecimal.ZERO; } return total; }

这里的注释用了Despite the complexity of the pricing rules，后面跟的是名词短语the complexity of the pricing rules，语法正确，读起来也自然。如果你写成Despite the pricing rules are complex，那就错了，因为后面跟的是完整句子。

再举一个例子，这次用In spite of：

/** * In spite of the fact that this method is called frequently, * it does not cache the result because the input changes every time. */ public String generateId(String prefix) { return prefix + "-" + UUID.randomUUID().toString(); }

这里用了In spite of the fact that，因为后面跟的是完整句子this method is called frequently。如果你想简化，可以改成Despite being called frequently, this method does not cache the result...意思一样，但更简洁。

我的经验是：在代码注释里，能用Despite + 动名词就不要用Despite the fact that + 句子。前者更短，读起来更快，而且不容易出错。比如Despite being called frequently比Despite the fact that it is called frequently好得多。

4.3 参数计算：split 的 limit 参数到底怎么选

String.split方法有两个重载版本：

public String[] split(String regex) public String[] split(String regex, int limit)

limit参数控制拆分后的数组长度，具体规则如下：

我举几个例子来说明：

String s = "a,b,c,,"; // limit = 0（默认行为） System.out.println(Arrays.toString(s.split(","))); // 输出：[a, b, c] // limit = 2 System.out.println(Arrays.toString(s.split(",", 2))); // 输出：[a, b,c,,] // limit = -1 System.out.println(Arrays.toString(s.split(",", -1))); // 输出：[a, b, c, , ]

这个规则在实际开发中很重要。比如你解析 CSV 文件的时候，如果某一行的末尾有空字段，用默认的split会丢掉这些空字段，导致列数对不上。这时候就需要用split(",", -1)来保留所有字段。

我在一个数据导入功能里踩过这个坑。用户上传的 CSV 文件里，有些行的末尾有逗号，表示最后一个字段是空字符串。我用默认的split解析，结果这些行的字段数比其他行少一个，导致后续处理逻辑出错。后来改成split(",", -1)就正常了。

4.4 一个完整的工具类：StringUtils 的拆分方法

基于上面的经验，我写了一个简单的工具类，封装了常用的字符串拆分逻辑：

public final class StringSplitUtils { private StringSplitUtils() { // 工具类不允许实例化 } /** * Splits a string by the given delimiter, preserving all empty tokens. * * Despite the simplicity of this method, it handles several edge cases: * null input, empty input, and trailing delimiters. * * @param input the string to split, may be null * @param delimiter the delimiter, must not be null * @return an array of tokens, never null */ public static String[] splitPreserveAll(String input, String delimiter) { if (input == null || input.isEmpty()) { return new String[0]; } if (delimiter == null || delimiter.isEmpty()) { return new String[]{input}; } return input.split(Pattern.quote(delimiter), -1); } /** * Splits a string by the given delimiter, trimming each token. * * In spite of the trimming, empty tokens are preserved if * the preserveEmpty flag is true. * * @param input the string to split * @param delimiter the delimiter * @param preserveEmpty whether to keep empty tokens * @return an array of trimmed tokens */ public static String[] splitAndTrim(String input, String delimiter, boolean preserveEmpty) { String[] tokens = splitPreserveAll(input, delimiter); List<String> result = new ArrayList<>(); for (String token : tokens) { String trimmed = token.trim(); if (preserveEmpty || !trimmed.isEmpty()) { result.add(trimmed); } } return result.toArray(new String[0]); } }

这个工具类里有两个方法。splitPreserveAll用Pattern.quote(delimiter)来转义分隔符，这样即使分隔符包含正则特殊字符（比如.、|、*），也能正确拆分。splitAndTrim在拆分的基础上做了 trim，并且可以选择是否保留空字符串。

我在注释里用了Despite和In spite of，都是正确的用法。Despite the simplicity of this method后面跟的是名词短语，In spite of the trimming后面跟的是动名词。这两个例子可以直接抄到你的项目里。

5. 常见问题与排查技巧实录

5.1 英语语法部分的常见问题

问题一：Despite 后面能不能跟句子？

不能直接跟。如果你想跟句子，必须加the fact that。比如Despite the fact that he is tired是对的，Despite he is tired是错的。

问题二：Despite 和 in spite of 能不能互换？

绝大多数情况下可以。但在despite the fact that这个固定搭配里，用despite更自然。另外，在非常正式的学术写作里，despite比in spite of更常见。

问题三：Despite 和 although 能不能互换？

不能直接互换，因为词性不同。Despite是介词，后面跟名词性成分；although是连词，后面跟完整句子。如果你想互换，需要调整句子结构。比如Despite being tired, he worked.可以改成Although he was tired, he worked.

问题四：Despite 能不能放在句首？

可以。Despite和in spite of都可以放在句首或者句中。放在句首的时候，后面通常跟逗号。比如Despite the rain, we went out.放在句中的时候，前后通常都有逗号。比如We went out, despite the rain.

5.2 Java 字符串拆分的常见问题

问题一：split 方法返回的数组长度和预期不符

最常见的原因是末尾的空字符串被去掉了。解决办法是用split(regex, -1)。

问题二：split 方法报 PatternSyntaxException

原因是分隔符里包含了正则表达式的特殊字符，比如.、|、*、+、?、(、)、[、]、{、}、^、$。解决办法是用Pattern.quote(delimiter)转义，或者手动加反斜杠。

问题三：split 方法性能不好

split方法每次调用都会编译正则表达式，如果在一个循环里频繁调用，性能会受影响。解决办法是预编译Pattern对象：

private static final Pattern COMMA_PATTERN = Pattern.compile(","); public String[] splitByComma(String input) { return COMMA_PATTERN.split(input, -1); }

问题四：split 方法处理中文乱码

这个通常不是split的问题，而是字符串编码的问题。确保你的源文件、编译参数、运行环境都用的是同一种编码（推荐 UTF-8）。

5.3 一个排查问题的通用思路

不管是英语语法问题还是 Java 技术问题，排查的思路其实差不多。我总结了一个四步法：

1. 确认现象：到底发生了什么？错误信息是什么？预期结果是什么？
2. 缩小范围：把问题隔离到一个最小的可复现示例。比如英语语法问题，就造一个最简单的句子；Java 问题，就写一个最小的测试类。
3. 对比验证：找几个相似的、正确的例子，对比一下有什么区别。比如Despite being tired是对的，Despite he is tired是错的，区别就在于后面跟的是动名词还是句子。
4. 记录总结：把问题和解决办法记下来，下次遇到类似情况就能快速处理。

这个方法我在带新人的时候反复强调。很多人遇到问题就卡住了，其实只要按这个思路走一遍，大部分问题都能自己解决。

5.4 常见问题速查表

6. 从语法到代码：建立你自己的“易混淆概念”处理流程

6.1 为什么我们总是搞混相似的东西

心理学上有个概念叫“干扰效应”，说的是当两个东西长得很像的时候，大脑在提取信息时会互相干扰。despite和in spite of长得像，split和spite长得像，==和equals()功能上像，这些都是干扰效应的典型例子。

我在学习 Java 的初期，经常把ArrayList和LinkedList搞混。后来我发现，光靠死记硬背没用，必须理解它们底层的区别。ArrayList底层是数组，所以随机访问快，但插入删除慢；LinkedList底层是链表，所以插入删除快，但随机访问慢。理解了这一点，就再也不会搞混了。

同样的道理，despite和in spite of的区别不在于意思，而在于词性和正式程度。despite是介词，更正式；in spite of是介词短语，稍微口语化。理解了这一点，用的时候就不会犹豫了。

6.2 一个实用的记忆方法：对比表格 + 造句练习

我推荐一个方法：先做对比表格，然后每个概念造三个句子。对比表格帮你理清区别，造句练习帮你形成语感。

比如对于despite和although，你可以做这样一个表格：

然后每个例句读三遍，最好能背下来。下次写句子的时候，大脑会自动匹配正确的结构。

对于 Java 概念，比如==和equals()，你也可以做类似的表格：

这个表格里的第三个示例特别容易出错。Integer在 -128 到 127 之间会使用缓存，所以i1 == i2为 true。超出这个范围就是 false。这个知识点在面试里经常考。

6.3 在团队里推广这套方法

我在现在的团队里推行了一个做法：每次代码审查发现拼写错误或者概念混淆，就把这个错误记到一个共享文档里，附上正确的写法和解释。一个月下来，这个文档积累了三十多条，成了新人的必读材料。

比如有一条是这么写的：

错误：Despite the list is empty, the loop executes.正确：Despite the list being empty, the loop does not execute.解释：Despite后面不能跟完整句子，要用动名词。另外，空列表的for-each循环不会执行。

还有一条：

错误：String[] parts = str.spite(",");正确：String[] parts = str.split(",");解释：spite不是 Java 方法，split才是。注意split的参数是正则表达式。

这个文档的好处是，它不光记录了错误，还解释了原因。新人看了之后，不仅知道错了，还知道为什么错，下次就不容易再犯。

6.4 一个练习：用 despite 和 split 写一段技术说明

最后给你一个练习。假设你要写一段技术说明，解释为什么在解析 CSV 文件时要用split(",", -1)而不是split(",")。要求用上despite或者in spite of。

我写一个示例：

When parsing CSV files, usingsplit(",")may seem sufficient. However, despite its simplicity, this approach drops trailing empty fields, which can lead to column misalignment. In spite of the fact that most CSV files do not have trailing commas, production data often contains such edge cases. Therefore, we recommend usingsplit(",", -1)to preserve all fields, even empty ones.

这段话用了despite its simplicity（介词 + 名词短语）和In spite of the fact that（介词短语 + 完整句子），两个用法都是正确的。你可以试着写一段类似的说明，把despite和split结合起来。写完之后读一遍，看看是否通顺，语法是否正确。

这个练习看起来简单，但能同时锻炼英语表达和 Java 技术理解。我在学习新技术的时候经常用这个方法：用英语写一段技术说明，然后检查语法和逻辑。时间长了，英语和技术都能提升。

6.5 最后的经验分享

我在实际工作中发现，很多技术问题归根结底是表达问题。你心里知道split和spite的区别，但手一快就打错了；你知道despite后面要跟名词，但写的时候就是忘了。这些都不是什么大问题，但确实会影响效率。

我的建议是：把容易混淆的东西放在一起对比，然后反复练习。不要指望看一遍就记住，那是不可能的。我到现在有时候还会把length和length()搞混，但这不影响我写代码，因为我知道怎么快速排查。

另外，不要害怕犯错。我见过很多新人因为怕写错，就不敢写注释、不敢写文档。其实写错了改过来就行，关键是你要有这个意识去检查。每次提交代码之前，花两分钟检查一下拼写和语法，时间长了就形成习惯了。

这个内容后续还可以这样扩展：你可以把despite和in spite of的用法做成一个卡片，贴在显示器旁边；也可以把 Java 里容易混淆的方法名整理成一个列表，放在 IDE 的代码模板里。方法很多，关键是找到适合你的那一种。