Initial commit

data/1.面向对象程序设计初阶/1.面向对象的核心概念/1.面向对象的特点/charac.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "charac.md",
+  "notebook_enable": false,
+  "exercise_id": "c2f6aa1cf9794d3a8a1c43b7c5375151"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/1.面向对象的核心概念/1.面向对象的特点/charac.md

+# 面向对象特点
+
+以下哪些不是面向对象的特点？
+
+
+## 答案
+
+```
+程序由函数组成
+```
+
+## 选项
+
+### A
+
+```
+强调数据封装
+```
+
+### B
+
+```
+行时由方法调用栈+对象表示
+
+```
+
+### C
+
+```
+共享数据由对象进行保护
+```
+### D
+
+```
+逻辑聚合的方法与数据物理上也聚合
+```

data/1.面向对象程序设计初阶/1.面向对象的核心概念/1.面向对象的特点/config.json

+{
+  "node_id": "oo-8c8081f4890b4480b0cd293dcedf4d90",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "charac.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/1.面向对象的核心概念/2.面向对象的基本特征/config.json

+{
+  "node_id": "oo-56e5e0ceb3ac4e159ea67e4f9127d3dd",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "feature.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/1.面向对象的核心概念/2.面向对象的基本特征/feature.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "feature.md",
+  "notebook_enable": false,
+  "exercise_id": "d2541f9f1c344043882ebbe75a98b71f"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/1.面向对象的核心概念/2.面向对象的基本特征/feature.md

+# 面向对象基本特征
+
+以下哪个不是面向对象的基本特征？
+
+
+## 答案
+
+```
+实现
+```
+
+## 选项
+
+### A
+
+```
+封装
+```
+
+### B
+
+```
+继承
+
+```
+
+### C
+
+```
+多态
+```

data/1.面向对象程序设计初阶/1.面向对象程序设计基础/config.json → data/1.面向对象程序设计初阶/1.面向对象的核心概念/config.json

 {
-  "node_id": "oo-4641f4c858b543558421e5108b3ebd6b",
+  "node_id": "oo-a5d3b2d581584a93ac09f0ca548747c1",
   "keywords": [],
   "keywords_must": [],
-  "keywords_forbid": []
+  "keywords_forbid": [],
+  "group": 0
 }
\ No newline at end of file

data/1.面向对象程序设计初阶/1.面向对象程序设计基础/1.HelloOO/helloworld.md

-# Hello OO
-
-以下哪个是面向对象程序代码
-
-## 答案
-
-```cpp
-// C++
-class Object{
-    Object(){}
-    ~Object(){}
-    void test(){
-        std::cout<<"hello"<<std::endle;
-    }
-}
-
-int main(){
-    Object* o = new Object();
-    delete o;
-    return 0;
-}
-```
-
-## 选项
-
-### A
-
-```javascript
-var foo = function(){
-    return {
-
-    }
-}
-```
-
-### B
-
-```python
-def object():
-    return {}
-
-o = object()
-```
-
-### C
-
-```c
-int test(){
-    
-}
-
-int main(){
-    test();
-    return 0;
-}
-```

data/1.面向对象程序设计初阶/2.对象与类的关系/1.基本概念/concept.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "concept.md",
+  "notebook_enable": false,
+  "exercise_id": "b3d0d1b514ee409b9e2924ee20a16407"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/2.对象与类的关系/1.基本概念/concept.md

+# 基本概念
+
+以下表述错误的是：
+
+
+## 答案
+
+```
+类的属性可以随着它自己的行为而发生改变。
+```
+
+## 选项
+
+### A
+
+```
+一个类可以提供多个构造器，构造具有不同初始状态的对象。
+```
+
+### B
+
+```
+对象是一个管理着具体数据并可执行计算行为的实体
+
+```
+
+### C
+
+```
+类提供了构造对象的模板
+```
+### D
+
+```
+类通过提供构造器来规范对象的实例化
+```

data/1.面向对象程序设计初阶/2.对象与类的关系/1.基本概念/config.json

+{
+  "node_id": "oo-c07068899e7e4e6da746eedd5ada15fc",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "concept.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/2.对象与类的关系/2.对象名和类名/config.json

+{
+  "node_id": "oo-8cb2a4c13d914787ac942eae0cb6546e",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "names.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/2.对象与类的关系/2.对象名和类名/names.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "names.md",
+  "notebook_enable": false,
+  "exercise_id": "2fb5e237ed284e599eaa5203c538d449"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/2.对象与类的关系/2.对象名和类名/names.md

+# 对象名和类名
+
+```java
+class Person {
+	private int id;
+  private String name;
+  
+  Person(int id, String name) {
+    this.id = id;
+    this.name = name;
+  }
+}
+
+...
+  
+Person person1 = new Person(1, "buaaer");
+```
+
+在上述代码中，类名是\_\_\_\_，对象名是\_\_\_\_
+
+
+
+## 答案
+
+```
+Person
+person1 
+
+```
+## 选项

data/1.面向对象程序设计初阶/2.对象与类的关系/3.对象的创建/config.json

+{
+  "node_id": "oo-fa83ae6ace6c4e29921627231542d894",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "instance.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/2.对象与类的关系/3.对象的创建/instance.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "instance.md",
+  "notebook_enable": false,
+  "exercise_id": "6355a3c2bf00436f854f34094c9e33b6"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/2.对象与类的关系/3.对象的创建/instance.md

+# 实例化
+
+```java
+class Person {
+	private int id;
+  private String name;
+  
+  Person(int id, String name) {
+    this.id = id;
+    this.name = name;
+  }
+}
+
+```
+
+如果生成一个名为person2，id为2，name为"ooer"的对象，请写出代码\_\_\_\_
+
+## 答案
+
+```
+Person person2 = new Person(2, "ooer")
+
+```
+## 选项

data/1.面向对象程序设计初阶/2.对象与类的关系/config.json

+{
+  "node_id": "oo-63aadcc559b84ddabe270b0d4e51cf39",
+  "keywords": [],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/3.数据封装与访问/1.数据封装/config.json

+{
+  "node_id": "oo-4ca06b80de06429d92651b73c5f5c580",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "encapsulation.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/3.数据封装与访问/1.数据封装/encapsulation.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "encapsulation.md",
+  "notebook_enable": false,
+  "exercise_id": "d2c7dabb04e54f0d9863e2b4bdd67339"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/3.数据封装与访问/1.数据封装/encapsulation.md

+# 数据封装
+
+以下哪一项不是封装的好处？
+
+
+## 答案
+
+```
+封装可以有助于用户知道对象内部的细节
+```
+
+## 选项
+
+### A
+
+``` 
+良好的封装能够减少耦合
+```
+
+### B
+
+``` 
+类内部的结构可以自由修改
+```
+
+### C
+
+``` 
+可以对成员进行更精确的控制
+```
+### D
+
+``` 
+隐藏信息，实现细节
+```
+
+

data/1.面向对象程序设计初阶/3.数据封装与访问/2.访问控制/access.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "access.md",
+  "notebook_enable": false,
+  "exercise_id": "0fadf6ba49ce4b828b2481168592359a"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/3.数据封装与访问/2.访问控制/access.md

+# 数据访问
+
+Java中，有以下几种对权限的控制：public、protected、（不加修饰符）、\____
+其中，protected关键字\_\_\_\_（可以/不可以）被包中其他类访问，\_\_\_\_（可以/不可以）被子类访问，\_\_\_\_（可以/不可以）被所有类访问
+
+## 答案
+
+```
+private
+不可以 不可以 可以
+
+```
+## 选项
+

data/1.面向对象程序设计初阶/3.数据封装与访问/2.访问控制/config.json

+{
+  "node_id": "oo-75e9753efb1547a7af5fdf16731cd54e",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "access.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/3.数据封装与访问/config.json

+{
+  "node_id": "oo-0b40cae9c71e4835aa34baf6dd2d3127",
+  "keywords": [],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/4.基于容器的对象管理与访问/1.容器的选择/choice.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "choice.md",
+  "notebook_enable": false,
+  "exercise_id": "795a27d3a46b4975baee3103fd2952d8"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/4.基于容器的对象管理与访问/1.容器的选择/choice.md

+# 容器的选择
+
+在一个班级中，同学们的学号不会重复，这时使用什么容器记录学号会比较好？
+
+
+## 答案
+
+```
+HashSet
+```
+
+## 选项
+
+### A
+
+```
+ArrayList
+```
+
+### B
+
+```
+Vector
+```
+
+### C
+
+```
+HashMap
+```
+

data/1.面向对象程序设计初阶/4.基于容器的对象管理与访问/1.容器的选择/config.json

+{
+  "node_id": "oo-9a8f508ada45470ba62498d043ac9d4e",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "choice.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/4.基于容器的对象管理与访问/2.容器的使用/config.json

+{
+  "node_id": "oo-d0394e0485be4da9bc647faa2ffd4bd3",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "using.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/4.基于容器的对象管理与访问/2.容器的使用/using.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "using.md",
+  "notebook_enable": false,
+  "exercise_id": "feeb96d62e6a4970b46fb4891c886f71"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/4.基于容器的对象管理与访问/2.容器的使用/using.md

+# 容器的使用
+
+```java
+private int add {
+  ArrayList<Integer> bookshelf = new ArrayList();
+  Book book = new Book("oobook");
+  // TODO(1) 将book加入bookshelf中
+ 	// TODO(2) 从bookshelf中取出第一个对象，命名为bookInShelf
+  System.out.println(bookInShelf.name);
+  // TODO(3) 删除bookShelf中的第一个对象
+  // TDOO(4) 返回bookshelf的长度
+}
+```
+
+## 答案
+
+```java
+bookshelf.add(book);
+Book bookInShelf = bookshelf.get(0);
+bookshelf.remove(0);
+return bookshelf.size();
+```
+## 选项
+

data/1.面向对象程序设计初阶/4.基于容器的对象管理与访问/config.json

+{
+  "node_id": "oo-5720e0a7232845f59ba38646ab05cb15",
+  "keywords": [],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/5.类的识别与设计/1.类型识别/config.json

+{
+  "node_id": "oo-5f8bdfd5c84f4bdb8ab928d5c08cdc69",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "identify.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/5.类的识别与设计/1.类型识别/identify.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "identify.md",
+  "notebook_enable": false,
+  "exercise_id": "4f751c7e9f604a15bfa3a7956039e42e"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/5.类的识别与设计/1.类型识别/identify.md

+# 类型识别
+
+```java
+private void printObject(Object object) {
+	if(object instanceof Cat) {
+  	System.out.println("cat");
+	} else if(object instanceof Dog) {
+  	System.out.println("dog");
+	} else {
+    System.out.println("some other");
+  }
+}
+
+Cat cat = new Cat();
+Fish fish = new Fish();
+printObject(cat);
+printObject(fish);
+```
+输出上述代码的结果
+
+## 答案
+
+```
+cat
+some other
+
+```
+## 选项

data/1.面向对象程序设计初阶/5.类的识别与设计/2.运行时类对象获取/config.json

+{
+  "node_id": "oo-33a9e8175e2b4a1c8cdcbf66b07c6785",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "getcls.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/5.类的识别与设计/2.运行时类对象获取/getcls.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "getcls.md",
+  "notebook_enable": false,
+  "exercise_id": "65dad5a0812341f7affad7a7d8f2cfc5"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/5.类的识别与设计/2.运行时类对象获取/getcls.md

+# 运行时类对象获取
+
+
+获取类名还可以通过先获取类，再打印名字的方法，已知一个文件树如下
+
+```
+src
+| - oo
+| - | - Computer.java
+| - | - Desktop.java
+```
+
+已有一个Computer类对象computer，想得到"Computer"需要调用
+```
+
+## 答案
+
+```java
+computer.getClass.getSimpleName()
+
+```
+## 选项
+
+### A
+
+```java
+computer.getClass.getName()
+```
+
+### B
+
+```
+computer.getClassName()
+```
+
+### C
+
+```
+getClassName(computer)
+```
+

data/1.面向对象程序设计初阶/5.类的识别与设计/config.json

+{
+  "node_id": "oo-8fa98e1506594a1ca45a65fc2731ae6e",
+  "keywords": [],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/1.面向对象程序设计基础/1.HelloOO/config.json → data/1.面向对象程序设计初阶/6.属性与方法的设计/1.属性的读取和修改/config.json

 {
-  "node_id": "oo-4068a4025df34a929c33dd95cffd28b4",
+  "node_id": "oo-3b81807bd46848de829a24cf9ed734a2",
   "keywords": [],
   "children": [],
   "export": [
-    "helloworld.json"
+    "rm.json"
   ],
   "keywords_must": [],
-  "keywords_forbid": []
+  "keywords_forbid": [],
+  "group": 0
 }
\ No newline at end of file

data/1.面向对象程序设计初阶/1.面向对象程序设计基础/1.HelloOO/helloworld.json → data/1.面向对象程序设计初阶/6.属性与方法的设计/1.属性的读取和修改/rm.json

 {
   "type": "code_options",
-  "author": "",
-  "source": "hello.md",
+  "author": null,
+  "source": "rm.md",
   "notebook_enable": false,
-  "exercise_id": "d4e2302f452541b99f140996252d91a8"
+  "exercise_id": "e72f3c5991444fb784caba8f2859e8ab"
 }
\ No newline at end of file

data/1.面向对象程序设计初阶/6.属性与方法的设计/1.属性的读取和修改/rm.md

+# 属性的读取和修改
+
+通常，类中会有自己的getter和setter方法，getter方法用于读取类中的属性，setter方法用于修改类中的属性
+
+```java
+class Student {
+  private int id = 1;
+  
+  public int getId() {
+    return this.id;
+  }
+  
+  public void setId(int id) {
+    this.id = id;
+  }
+}
+
+...
+  
+Student stu = new Student();
+System.out.println(stu.getId());
+stu.setId(2);
+System.out.println(stu.getId());
+```
+
+请输出结果：
+
+## 答案
+
+```
+0
+2
+
+```
+## 选项
+

data/1.面向对象程序设计初阶/6.属性与方法的设计/2.方法的设计/config.json

+{
+  "node_id": "oo-89364dd84054450380684cdaa90bc51a",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "method.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/6.属性与方法的设计/2.方法的设计/method.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "method.md",
+  "notebook_enable": false,
+  "exercise_id": "45e7f995c1184a51881a7d263ad13bc8"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/6.属性与方法的设计/2.方法的设计/method.md

+# 方法的设计
+
+以下关于Java中方法的设计描述正确的是：
+
+1. 一般而言，方法可归纳为构造方法、对象生成方法、状态查询方法、状态改变方法四种
+2. 构造方法设置属性的初始值，即设置对象初始状态
+3. 状态改变方法针对功能要求改变内部状态
+4. 无参数构造方法，按需构造对象的初始状态
+5. 对象生产方法使用当前对象(this)所管理的数据和参数传递的数据
+6. 类中的每一个属性均应该添加get和set方法
+
+## 答案
+
+1, 2, 3, 5
+
+## 选项
+
+### A
+
+所有都对
+
+### B
+
+1, 2, 5
+
+### C
+
+1, 3, 5
+
+### D
+
+1, 2, 3, 4
+
+### E
+
+2, 3, 4
+
+### F
+
+3, 5

data/1.面向对象程序设计初阶/6.属性与方法的设计/config.json

+{
+  "node_id": "oo-df0308e7111643b0b9e50723f09327d5",
+  "keywords": [],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/7.对象的运行时特性/1.可变性/config.json

+{
+  "node_id": "oo-6a96bc5142914f69b8d8f7d87afa6305",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "variability.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/7.对象的运行时特性/1.可变性/variability.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "variability.md",
+  "notebook_enable": false,
+  "exercise_id": "6e798fb4d3084e069b89031c74fdd525"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/7.对象的运行时特性/1.可变性/variability.md

+# 可变性
+
+请问如下代码哪一行会报错？
+```java
+class Person {
+  private final int id = 1;
+  private int age;
+  
+  ...
+    
+  public void modify() {
+    this.id = 2;
+    this.age = 18;
+  }
+}
+```
+
+
+
+## 答案
+
+```
+8
+
+```
+## 选项

data/1.面向对象程序设计初阶/7.对象的运行时特性/2.可观察性/config.json

+{
+  "node_id": "oo-9044ee5ba2954885b66b21aa4c9fb1a7",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "observability.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/7.对象的运行时特性/2.可观察性/observability.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "observability.md",
+  "notebook_enable": false,
+  "exercise_id": "42bda5aa3190433a85d3ef55988c6cd5"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/7.对象的运行时特性/2.可观察性/observability.md

+# 可观察性
+
+在Java中，可以使用断言Assert来判断某些条件，如果不符合条件则会立刻报错
+
+```java
+public void loop() {
+  for(int i=0; i <5; i++) {
+    System.out.print(i);
+    Assert i<3;
+  }
+}
+```
+
+在报错前，loop方法的输出是
+
+## 答案
+
+```
+012
+
+```
+## 选项

data/1.面向对象程序设计初阶/7.对象的运行时特性/3.容错性/config.json

+{
+  "node_id": "oo-96e4a5b714c34e4e8c89a3f0c5d879bc",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "tolerance.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/7.对象的运行时特性/3.容错性/tolerance.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "tolerance.md",
+  "notebook_enable": false,
+  "exercise_id": "a31e656b0e94482296aeb7daa08b0803"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/7.对象的运行时特性/3.容错性/tolerance.md

+# 容错性
+
+
+在代码中，时常会出现传递给函数的参数值为null的情况，如果不加以处理，函数会报错，为了避免这种情况，增加函数的容错性，可以在以下代码的空中填什么内容？
+
+```java
+public void test(String str) {
+  if () { // TODO
+   	System.out.println("Oh, it is null string");
+  } else {
+    System.out.println(str);
+  }
+}
+```
+
+## 答案
+
+```
+str == null
+
+```
+或者
+```
+!str
+
+```
+## 选项

data/1.面向对象程序设计初阶/7.对象的运行时特性/config.json

+{
+  "node_id": "oo-737c60ba256c4cee86ca171ffaefae53",
+  "keywords": [],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/8.设计模式初探/1.设计模式基本原则/config.json

+{
+  "node_id": "oo-d9e657d4c4d2414d9213fe5ce439a088",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "principle.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/8.设计模式初探/1.设计模式基本原则/principle.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "principle.md",
+  "notebook_enable": false,
+  "exercise_id": "0eed98f392134f78ac8895009a5a6d14"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/8.设计模式初探/1.设计模式基本原则/principle.md

+# 正则表达式
+
+以下哪一个不是面向对象设计模式的基本原则：
+
+
+## 答案
+
+```
+低内聚原则
+```
+
+## 选项
+
+### A
+
+```
+单一职责原则
+```
+
+### B
+
+```
+开闭原则
+```
+
+### C
+
+```
+里氏替换原则
+```
+
+### D
+
+```
+依赖倒置原则
+```
+
+### E
+
+```
+接口隔离原则
+```
+### F
+```
+迪米特法则
+```
+### G
+```
+组合/聚合复用原则
+```
+
+

data/1.面向对象程序设计初阶/8.设计模式初探/2.单例模式/config.json

+{
+  "node_id": "oo-37cec87bd59246719076fbf531cde613",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "singleton.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/8.设计模式初探/2.单例模式/singleton.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "singleton.md",
+  "notebook_enable": false,
+  "exercise_id": "d569e6c196d645b5830df66b3e073ab1"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/8.设计模式初探/2.单例模式/singleton.md

+# 单例模式
+
+以下是一个单例模式的代码，请问TODO处应该填写什么内容？
+
+```java
+public class Singleton {  
+    private static Singleton instance;  
+    private Singleton (){}  
+  
+    public static Singleton getInstance() {  
+        if (instance == null) {  
+        	// TODO
+        }  
+        return instance;  
+    }  
+}
+```
+
+## 答案
+
+```java
+instance = new Singleton();  
+```
+## 选项
+

data/1.面向对象程序设计初阶/8.设计模式初探/3.原型模式/config.json

+{
+  "node_id": "oo-4ff3f88c10524ae1b91ff234c8a7e6bf",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "prototype.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/8.设计模式初探/3.原型模式/prototype.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "prototype.md",
+  "notebook_enable": false,
+  "exercise_id": "4741d847840e4133a6306dc3ff5fc004"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/8.设计模式初探/3.原型模式/prototype.md

+# 原型模式
+
+
+```java
+class Student implements Cloneable {
+  public Student() {
+    System.out.println("创建成功！");
+  }
+
+  @Override
+  protected Object clone() throws CloneNotSupportedException {
+    System.out.println("复制成功！");
+    return super.clone();
+  }
+}
+
+public void test() throws CloneNotSupportedException {
+  Student stu1 = new Student();
+  Student stu2 = (Student) stu1.clone();
+  System.out.println(stu1.equals(stu2));
+  System.out.println(stu1 == stu2);
+}
+```
+
+执行test()方法，打印的结果是
+
+```
+创建成功！
+复制成功！
+（1）
+（2）
+```
+
+请问（1）和（2）中的内容是？
+
+## 答案
+```
+false
+false
+```
+## 选项
+

data/1.面向对象程序设计初阶/8.设计模式初探/config.json

+{
+  "node_id": "oo-97c27d3fa7c9475a9b3b6f30f340ba93",
+  "keywords": [],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/9.程序输入输出和字符串处理/1.字符串拼接/config.json

+{
+  "node_id": "oo-81d93dfd3025466ba1b3e8827f7f9c66",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "conn.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/9.程序输入输出和字符串处理/1.字符串拼接/conn.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "conn.md",
+  "notebook_enable": false,
+  "exercise_id": "ea16c59ff6bb442f8f60ac817c416c9b"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/9.程序输入输出和字符串处理/1.字符串拼接/conn.md

+# 字符串拼接
+
+有两个字符串str1和str2，请问怎么实现字符串的拼接？
+
+
+## 答案
+
+```java
+str1 + str2
+```
+
+## 选项
+
+### A
+
+```java
+str1.append(str2)
+```
+
+### B
+
+```java
+str1.add(str2)
+```
+
+### C
+
+```java
+str1.push_back(str2)
+```

data/1.面向对象程序设计初阶/9.程序输入输出和字符串处理/2.正则表达式/config.json

+{
+  "node_id": "oo-b4351657eee84678ac75452eb3d7aba8",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "regular.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/9.程序输入输出和字符串处理/2.正则表达式/regular.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "regular.md",
+  "notebook_enable": false,
+  "exercise_id": "2b732ec63d934143964a669adfd239d0"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/9.程序输入输出和字符串处理/2.正则表达式/regular.md

+# 正则表达式
+
+以下哪个是匹配`Beijing2022`整句的正则表达式？
+
+
+## 答案
+
+```
+\w{1,8}[02]{4}
+```
+
+## 选项
+
+### A
+
+```
+[a-z]{1,9}[0-9]{4}
+```
+
+### B
+
+```
+\d{11}
+```
+
+### C
+
+```
+[A-Za-z]{2,6}\d{1,4}
+```

data/1.面向对象程序设计初阶/9.程序输入输出和字符串处理/3.字符串比较/compare1.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "compare1.md",
+  "notebook_enable": false,
+  "exercise_id": "a54c8f131d9f4e80893ae9badecb6fe6"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/9.程序输入输出和字符串处理/3.字符串比较/compare1.md

+# 字符串比较
+
+
+请输出以下代码结果
+
+```java
+String str1 = new String("1");
+String str2 = "1";
+System.out.println(str1 == str2);
+System.out.println(str1.equals(str2));
+```
+
+## 答案
+
+```
+false
+true
+
+```
+## 选项

data/1.面向对象程序设计初阶/9.程序输入输出和字符串处理/3.字符串比较/compare2.json

+{
+  "type": "code_options",
+  "author": null,
+  "source": "compare2.md",
+  "notebook_enable": false,
+  "exercise_id": "fc3ca0907cb640d7bb5eb6cc88974a1c"
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/9.程序输入输出和字符串处理/3.字符串比较/compare2.md

+# 字符串比较
+
+
+
+请输出以下代码结果
+
+```java
+String str1 = "12";
+String str2 = "1" + "2";
+System.out.println(str1 == str2);
+System.out.println(str1.equals(str2));
+```
+
+## 答案
+
+```
+true
+true
+
+```
+## 选项

data/1.面向对象程序设计初阶/9.程序输入输出和字符串处理/3.字符串比较/config.json

+{
+  "node_id": "oo-ad99d1d0ef574991a859faf372e94dbd",
+  "keywords": [],
+  "children": [],
+  "export": [
+    "compare1.json",
+    "compare2.json"
+  ],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/1.面向对象程序设计初阶/9.程序输入输出和字符串处理/config.json

+{
+  "node_id": "oo-09b0b81ec88b4a7683c68a0c5cf3e5fb",
+  "keywords": [],
+  "keywords_must": [],
+  "keywords_forbid": [],
+  "group": 0
+}
\ No newline at end of file

data/tree.json

@@ -9,27 +9,328 @@
           "keywords": [],
           "children": [
             {
-              "OO初步": {
-                "node_id": "oo-4641f4c858b543558421e5108b3ebd6b",
+              "面向对象的核心概念": {
+                "node_id": "oo-a5d3b2d581584a93ac09f0ca548747c1",
                 "keywords": [],
                 "children": [
                   {
-                    "HelloOO": {
-                      "node_id": "oo-4068a4025df34a929c33dd95cffd28b4",
+                    "面向对象的特点": {
+                      "node_id": "oo-8c8081f4890b4480b0cd293dcedf4d90",
                       "keywords": [],
                       "children": [],
                       "keywords_must": [],
-                      "keywords_forbid": []
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "面向对象的基本特征": {
+                      "node_id": "oo-56e5e0ceb3ac4e159ea67e4f9127d3dd",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  }
+                ],
+                "keywords_must": [],
+                "keywords_forbid": [],
+                "group": 0
+              }
+            },
+            {
+              "对象与类的关系": {
+                "node_id": "oo-63aadcc559b84ddabe270b0d4e51cf39",
+                "keywords": [],
+                "children": [
+                  {
+                    "基本概念": {
+                      "node_id": "oo-c07068899e7e4e6da746eedd5ada15fc",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "对象名和类名": {
+                      "node_id": "oo-8cb2a4c13d914787ac942eae0cb6546e",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "对象的创建": {
+                      "node_id": "oo-fa83ae6ace6c4e29921627231542d894",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  }
+                ],
+                "keywords_must": [],
+                "keywords_forbid": [],
+                "group": 0
+              }
+            },
+            {
+              "数据封装与访问": {
+                "node_id": "oo-0b40cae9c71e4835aa34baf6dd2d3127",
+                "keywords": [],
+                "children": [
+                  {
+                    "数据封装": {
+                      "node_id": "oo-4ca06b80de06429d92651b73c5f5c580",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "访问控制": {
+                      "node_id": "oo-75e9753efb1547a7af5fdf16731cd54e",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  }
+                ],
+                "keywords_must": [],
+                "keywords_forbid": [],
+                "group": 0
+              }
+            },
+            {
+              "基于容器的对象管理与访问": {
+                "node_id": "oo-5720e0a7232845f59ba38646ab05cb15",
+                "keywords": [],
+                "children": [
+                  {
+                    "容器的选择": {
+                      "node_id": "oo-9a8f508ada45470ba62498d043ac9d4e",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "容器的使用": {
+                      "node_id": "oo-d0394e0485be4da9bc647faa2ffd4bd3",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  }
+                ],
+                "keywords_must": [],
+                "keywords_forbid": [],
+                "group": 0
+              }
+            },
+            {
+              "类的识别与设计": {
+                "node_id": "oo-8fa98e1506594a1ca45a65fc2731ae6e",
+                "keywords": [],
+                "children": [
+                  {
+                    "类型识别": {
+                      "node_id": "oo-5f8bdfd5c84f4bdb8ab928d5c08cdc69",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "运行时类对象获取": {
+                      "node_id": "oo-33a9e8175e2b4a1c8cdcbf66b07c6785",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  }
+                ],
+                "keywords_must": [],
+                "keywords_forbid": [],
+                "group": 0
+              }
+            },
+            {
+              "属性与方法的设计": {
+                "node_id": "oo-df0308e7111643b0b9e50723f09327d5",
+                "keywords": [],
+                "children": [
+                  {
+                    "属性的读取和修改": {
+                      "node_id": "oo-3b81807bd46848de829a24cf9ed734a2",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "方法的设计": {
+                      "node_id": "oo-89364dd84054450380684cdaa90bc51a",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  }
+                ],
+                "keywords_must": [],
+                "keywords_forbid": [],
+                "group": 0
+              }
+            },
+            {
+              "对象的运行时特性": {
+                "node_id": "oo-737c60ba256c4cee86ca171ffaefae53",
+                "keywords": [],
+                "children": [
+                  {
+                    "可变性": {
+                      "node_id": "oo-6a96bc5142914f69b8d8f7d87afa6305",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "可观察性": {
+                      "node_id": "oo-9044ee5ba2954885b66b21aa4c9fb1a7",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "容错性": {
+                      "node_id": "oo-96e4a5b714c34e4e8c89a3f0c5d879bc",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  }
+                ],
+                "keywords_must": [],
+                "keywords_forbid": [],
+                "group": 0
+              }
+            },
+            {
+              "设计模式初探": {
+                "node_id": "oo-97c27d3fa7c9475a9b3b6f30f340ba93",
+                "keywords": [],
+                "children": [
+                  {
+                    "设计模式基本原则": {
+                      "node_id": "oo-d9e657d4c4d2414d9213fe5ce439a088",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "单例模式": {
+                      "node_id": "oo-37cec87bd59246719076fbf531cde613",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "原型模式": {
+                      "node_id": "oo-4ff3f88c10524ae1b91ff234c8a7e6bf",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  }
+                ],
+                "keywords_must": [],
+                "keywords_forbid": [],
+                "group": 0
+              }
+            },
+            {
+              "程序输入输出和字符串处理": {
+                "node_id": "oo-09b0b81ec88b4a7683c68a0c5cf3e5fb",
+                "keywords": [],
+                "children": [
+                  {
+                    "字符串拼接": {
+                      "node_id": "oo-81d93dfd3025466ba1b3e8827f7f9c66",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "正则表达式": {
+                      "node_id": "oo-b4351657eee84678ac75452eb3d7aba8",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
+                    }
+                  },
+                  {
+                    "字符串比较": {
+                      "node_id": "oo-ad99d1d0ef574991a859faf372e94dbd",
+                      "keywords": [],
+                      "children": [],
+                      "keywords_must": [],
+                      "keywords_forbid": [],
+                      "group": 0
                     }
                   }
                 ],
                 "keywords_must": [],
-                "keywords_forbid": []
+                "keywords_forbid": [],
+                "group": 0
               }
             }
           ],
           "keywords_must": [],
-          "keywords_forbid": []
+          "keywords_forbid": [],
+          "group": 0
         }
       },
       {
@@ -38,7 +339,8 @@
           "keywords": [],
           "children": [],
           "keywords_must": [],
-          "keywords_forbid": []
+          "keywords_forbid": [],
+          "group": 0
         }
       },
       {
@@ -47,11 +349,13 @@
           "keywords": [],
           "children": [],
           "keywords_must": [],
-          "keywords_forbid": []
+          "keywords_forbid": [],
+          "group": 0
         }
       }
     ],
     "keywords_must": [],
-    "keywords_forbid": []
+    "keywords_forbid": [],
+    "group": 0
   }
 }
\ No newline at end of file