java基础教程

2026-02-03 02:23:31 +08:00 · 2022-07-23 09:57:26 +08:00
parent 4aff8d5f09
commit 31e7db40d3
55 changed files with 1143 additions and 2075 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,4 @@
 *.pyc
 __pycache__
 *.class
+target
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -4,6 +4,12 @@
    // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
+    {
+        "type": "java",
+        "name": "Launch Java Program",
+        "request": "launch",
+        "mainClass": ""
+    },
        {
            "type": "java",
            "name": "Launch Java01HelloWorld",
--- a/版本回退.md
+++ b/版本回退.md
@@ -62,7 +62,7 @@ git reset --hard HEAD^  # 回到最新的一次提交
 git reset HEAD^  # 此时代码保留，回到 git add 之前
 ```

-### it push把修改提交到远程仓库
+### git push把修改提交到远程仓库
 1. 通过git reset是直接删除指定的commit
 ```
 git log # 得到你需要回退一次提交的commit id
--- a/Git/github.md
+++ b/Git/github.md
@@ -14,7 +14,7 @@
 * Github主页仓库主页——仓库相关的信息和相关操作

 ## 2 pull request
-## 2 fork syncize
+## 3 fork syncize

 > 参考文献
 > * [https://blog.csdn.net/qq_22918243/article/details/89642445](https://blog.csdn.net/qq_22918243/article/details/89642445)
--- a/Java云计算和微服务/云计算和微服务简介.md
+++ b/Java云计算和微服务/云计算和微服务简介.md
--- a/Java基础教程/Java语言基础/04
+++ b/Java基础教程/Java语言基础/04
@@ -106,4 +106,22 @@ s[0][1] = new String("Luck");
 s[1][0] = new String("to");
 s[1][1] = new String("you");
 s[1][2] = new String("!");
-```
+```
+
+
+### Arrays类
+
+* 给数组赋值：通过 fill 方法。
+* 对数组排序：通过 sort 方法,按升序。
+* 比较数组：通过 equals 方法比较数组中元素值是否相等。
+* 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
+
+
+* public static int binarySearch(Object[] a, Object key)
+用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
+* public static boolean equals(long[] a, long[] a2)
+如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
+* public static void fill(int[] a, int val)
+将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
+* public static void sort(Object[] a)
+对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。
--- a/Java基础教程/Java语言基础/06
+++ b/Java基础教程/Java语言基础/06
@@ -36,16 +36,16 @@ public class AbstractExtendClassExample extends AbstractClassExample {


 implements关键字
-使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）
+* 使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）


-接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。
+* 接口是抽象类的延伸，在 Java 8 之前，它可以看成是一个完全抽象的类，也就是说它不能有任何的方法实现。

-从 Java 8 开始，**接口也可以拥有默认的方法实现**，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类，让它们都实现新增的方法。
+* 从 Java 8 开始，**接口也可以拥有默认的方法实现**，这是因为不支持默认方法的接口的维护成本太高了。在 Java 8 之前，如果一个接口想要添加新的方法，那么要修改所有实现了该接口的类，让它们都实现新增的方法。

-接口的成员（字段 + 方法）默认都是 public 的，并且不允许定义为 private 或者 protected。从 Java 9 开始，**允许将方法定义为 private**，这样就能定义某些复用的代码又不会把方法暴露出去。
+* 接口的成员（字段 + 方法）默认都是 **public abstract**的，并且不允许定义为 private 或者 protected。从 Java 9 开始，**允许将方法定义为 private**，这样就能定义某些复用的代码又不会把方法暴露出去。

-接口的字段默认都是 static 和 final 的。
+* 接口的字段默认都是 **static 和 final** 的。

 ```java
 public interface InterfaceExample {
--- a/Java基础教程/Java语言基础/10
+++ b/Java基础教程/Java语言基础/10
@@ -1,5 +1,312 @@
-## 10 注解
+* [Java注解是怎么实现的](https://www.zhihu.com/question/24401191)
+* [注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
+* [Java注解](https://blog.csdn.net/D1842501760/article/details/124042500)
+
+## 1 注解概述
+
+### 格式
+
+```java
+public @interface 注解名称{
+    属性列表;
+}
+```
+
+### 分类
+根据其定义者的角色可以分为以下三种：
+1. 标准注解：JDK内置的注解
+2. 自定义注解：用户自定义的注解
+3. 第三方框架提供的注解
+
+
+> 还可以根据其出现的位置分为类、方法、变量和形参的注解。也可以其作用范围分为标准注解、元注解、自定义注解。
+### 作用
+
+* 出现位置：注解常常出现在类、方法、成员变量、形参位置。
+* 注解级别：注解和类、接口、枚举是同一级别的。
+1. 如果说注释是写给人看的，那么注解就是写给程序看的。它更像一个标签，贴在一个类、一个方法或者字段上。它的目的是为当前读取该注解的程序提供判断依据及少量附加信息。
+   1. 程序只要读到加了@Test的方法，就知道该方法是待测试方法，
+   2. @Before注解，程序看到这个注解，就知道该方法要放在@Test方法之前执行。
+   3. 有时我们还可以通过注解属性，为将来读取这个注解的程序提供必要的附加信息，比如@RequestMapping("/user/info")提供了Controller某个接口的URL路径。
+
+2. Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。
+
+> java中的注解和自己想像中的作用不太一样。以前一直以为与python中的方法类似，提供一种包装功能、横向扩展功能，在执行该方法前，会额外执行一系列函数，完成逻辑处理。但是现在看来，他只是提供了一种信息的配置方式，注解本身不执行逻辑，而是由能够解析他的对象实现对注解的解析。
+
+
+### 原理
+
+注解只有被解析之后才会生效，常见的解析方法有两种：
+* 编译期间直接扫描：编译器在编译Java代码的时候扫描对于的注解并处理，比如某个方法使用了@Override，编译器在编译的时候就会检测当前的方法是否重写了父类对于的方法。
+* 运行期间通过反射处理：这个经常在Spring框架中看到，例如Spring的@Value注解，就是通过反射来进行处理的。
+## 2 注解使用
+### 注解的实现原理
+* 注解代码
+```java
+public @interface MyAnnotation{
+
+}
+```
+
+* 反编译后的代码
+```java
+pbulic interface MyAnnotation extends Annotation{
+
+}
+```
+
+* @interface变成了interface，而且自动继承了Annotation
+
+
+```java
+public @interface MyAnnotation{
+    public abstract String getValue();
+}
+//由于interface默认的方法是public abstract的所以可以写成如下格式。
+public @interface MyAnnotation{
+    String getValue();
+}
+```
+* getValue()被称为Info注解的属性。可以在使用的时候被赋值。表示给该方法传递参数。
+
+```java
+/**
+ * @author qiyu
+ */
+@MyAnnotation(getValue = "annotation on class")
+public class Demo {
+
+    @MyAnnotation(getValue = "annotation on field")
+    public String name;
+
+    @MyAnnotation(getValue = "annotation on method")
+    public void hello() {}
+
+}
+```
+* 注解中可以指定默认的属性
+
+```java
+public @interface MyAnnotation{
+    String getValue()default "default value";
+}
+```
+
+
+
+### 元注解
+
+加在注解上的注解。
+
+* @Documented：用于制作文档
+* @Target：加在注解上，限定该注解的使用位置。`@Target(ElementType.Field,ElementType.Method)`。它指明了它所修饰的注解使用的范围 如果自定义的注解为含有@Target元注解修饰，那么默认可以是在（除类型参数之外的）任何项之上使用，若有@Target元注解修饰那么根据Value（ElementType枚举常量）的指定的目标进行规定。
+* @Retention：注解的保留策略`@Retention(RetentionPolicy.CLASS/RetentionPolicy.RUNTIME/RetentionPolicy.SOURCE)`。分别对应java编译执行过程的三个阶段。源代码阶段.java-->编译后的字节码阶段.class-->JVM运行时阶段.
+  * 一般来说，普通开发者使用注解的时机都是运行时，比如反射读取注解（也有类似Lombok这类编译期注解）。既然反射是运行时调用，那就要求注解的信息必须保留到虚拟机将.class文件加载到内存为止。如果你需要反射读取注解，却把保留策略设置为RetentionPolicy.SOURCE、RetentionPolicy.CLASS
+* @Inherited：被该元注解修饰的自定义注解再使用后会自动继承，如果使用了该自定义注解去修饰一个class那么这个注解也会作用于该class的子类。就是说如果某个类使用了被@Inherited修饰的注解，则其子类将会自动具有该注释。@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。
+
+
+### 注解的使用步骤
+
+注解的使用包括三个步骤。
+1. 定义注解
+
+```java
+/**
+ * @author qiyu
+ */
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MyAnnotation {
+    String getValue() default "no description";
+}
+```
+
+2. 使用注解
+
+```java
+/**
+ * @author qiyu
+ */
+@MyAnnotation(getValue = "annotation on class")
+public class Demo {
+
+    @MyAnnotation(getValue = "annotation on field")
+    public String name;
+
+    @MyAnnotation(getValue = "annotation on method")
+    public void hello() {}
+
+    @MyAnnotation() // 故意不指定getValue
+    public void defaultMethod() {}
+}
+```
+3. 读取注解
+
+
+```java
+public class AnnotationTest {
+    public static void main(String[] args) throws Exception {
+        // 获取类上的注解
+        Class<Demo> clazz = Demo.class;
+        MyAnnotation annotationOnClass = clazz.getAnnotation(MyAnnotation.class);
+        System.out.println(annotationOnClass.getValue());
+
+        // 获取成员变量上的注解
+        Field name = clazz.getField("name");
+        MyAnnotation annotationOnField = name.getAnnotation(MyAnnotation.class);
+        System.out.println(annotationOnField.getValue());
+
+        // 获取hello方法上的注解
+        Method hello = clazz.getMethod("hello", (Class<?>[]) null);
+        MyAnnotation annotationOnMethod = hello.getAnnotation(MyAnnotation.class);
+        System.out.println(annotationOnMethod.getValue());
+
+        // 获取defaultMethod方法上的注解
+        Method defaultMethod = clazz.getMethod("defaultMethod", (Class<?>[]) null);
+        MyAnnotation annotationOnDefaultMethod = defaultMethod.getAnnotation(MyAnnotation.class);
+        System.out.println(annotationOnDefaultMethod.getValue());
+
+    }
+}
+```
+
+> 注解的读取并不只有反射一种途径.比如@Override，它由编译器读取（你写完代码ctrl+s时就编译了），而编译器只是检查语法错误，此时程序尚未运行。保留策略为SOURCE，仅仅是源码阶段，编译成.class文件后就消失
+
+### 属性的数据类型及特别的属性：value和数组
+
+
+属性的数据类型
+
+* 八种基本数据类型
+* String
+* 枚举
+* Class
+* 注解类型
+* 以上类型的一维数组
+
+```java
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MyAnnotation {
+   // 8种基本数据类型
+    int intValue();
+    long longValue();
+    // ...其他类型省略
+
+    // String
+    String name();
+    // 枚举
+    CityEnum cityName();
+    // Class类型
+    Class<?> clazz();
+    // 注解类型
+    MyAnnotation2 annotation2();
+
+    // 以上几种类型的数组类型
+    int[] intValueArray();
+    String[] names();
+    // ...其他类型省略
+}
+@interface MyAnnotation2 {
+}
+
+enum CityEnum {
+    BEIJING,
+    HANGZHOU,
+    SHANGHAI;
+}
+
+
+@MyAnnotation(
+        // 8种基本类型
+        intValue = 1,
+        longValue = 0L,
+
+        // String
+        name = "annotation on class",
+        // 枚举
+        cityName = CityEnum.BEIJING,
+        // Class
+        clazz = Demo.class,
+        // 注解
+        annotation2 = @MyAnnotation2,
+        // 一维数组
+        intValueArray = {1, 2},
+        names = {"Are", "you", "OK?"}
+)
+public class Demo {
+    // 省略...
+}
+```
+
+* 如果注解的属性只有一个，且叫value，那么使用该注解时，可以不用指定属性名，因为默认就是给value赋值。
+* 数组属性。如果数组的元素只有一个，可以省略花括号{}
+* 用常量类为注解属性赋值。如果你希望为注解的属性提供统一的几个可选值，可以使用常量类。
+
+### 总结
+
+* 注解就像标签，是程序判断执行的依据。比如，程序读到@Test就知道这个方法是待测试方法，而@Before的方法要在测试方法之前执行注解需要三要素：定义、使用、读取并执行注解分为自定义注解、JDK内置注解和第三方注解（框架）。
+* 自定义注解一般要我们自己定义、使用、并写程序读取，而JDK内置注解和第三方注解我们只要使用，定义和读取都交给它们大多数情况下，三角关系中我们只负责使用注解，无需定义和执行，框架会将注解类和读取注解的程序隐藏起来，除非阅读源码，否则根本看不到。平时见不到定义和读取的过程，光顾着使用注解，久而久之很多人就忘了注解如何起作用了！
+
+![](image/2022-07-12-10-04-38.png)
+
+
+## 3 JDK中的标准注解
+
+### @Override
+
+指示方法声明旨在覆盖超类型中的方法声明。如果使用此注解类型对方法进行注解，则编译器需要生成错误消息，除非至少满足以下条件之一：
+* 该方法确实覆盖或实现了在超类型中声明的方法。
+* 该方法的签名与Object中声明的任何公共方法的签名等效。
+
+所以@Override的作用告诉编译器检查这个方法，保证父类要包含一个被该方法重写的方法，否者就会出错，这样可以帮助程序员避免一些低级错误。
+
+### @Deprecated 
+注释的程序元素是不鼓励程序员使用的程序元素，通常是因为它很危险，或者因为存在更好的替代方案。当在非弃用代码中使用或覆盖弃用的程序元素时，编译器会发出警告。
+
+
+### @SuppressWarnings
+
+指示应在带注释的元素（以及带注释的元素中包含的所有程序元素）中抑制命名的编译器警告。请注意，给定元素中抑制的警告集是所有包含元素中抑制的警告的超集。例如，如果您注释一个类以抑制一个警告并注释一个方法以抑制另一个警告，则两个警告都将在方法中被抑制。
+作为风格问题，程序员应该始终在最有效的嵌套元素上使用此注释。如果您想在特定方法中抑制警告，您应该注释该方法而不是它的类。
+
+* Java中的@SuppressWarnings 注解指示被该注解修饰的程序元素（以及该程序元素中的所有子元素）取消显示指定的编译器警告，且会一直作用于该程序元素的所有子元素。
+
+* 如果你对于代码的规范不做要求又对编译器的警告感到烦躁那么你可以使用@SuppressWarnings（仅仅只是取消显示，并没有消除），它可以让你免去这些烦恼，当然编译器报错他是无法帮你取消显示的。
+
+
+### @SafeVarargs
+
+程序员断言带注释的方法或构造函数的主体不会对其 varargs 参数执行潜在的不安全操作。将此注释应用于方法或构造函数会抑制有关不可具体化的变量 arity (vararg) 类型的未经检查的警告，并抑制有关在调用站点创建参数化数组的未经检查的警告。
+除了@Target元注解施加的使用限制外，编译器还需要对该注解类型实施额外的使用限制；如果使用@SafeVarargs注释对方法或构造函数声明进行注释，则这是编译时错误，并且：
+声明是一个固定的arity方法或构造函数
+声明是一个既不是static也不是final的变量 arity 方法。
+鼓励编译器在将此注释类型应用于方法或构造函数声明时发出警告，其中：
+变量 arity 参数具有可具体化的元素类型，包括原始类型、 Object和String 。 （对于可具体化的元素类型，此注释类型抑制的未经检查的警告已经不会出现。）
+方法或构造函数声明的主体执行潜在的不安全操作，例如对变量 arity 参数数组的元素的赋值会生成未经检查的警告。一些不安全的操作不会触发未经检查的警告。例如，别名在
+   @SafeVarargs // 实际上并不安全！
+   static void m(List<String>... stringLists) {
+     Object[] array = stringLists;
+     List<Integer> tmpList = Arrays.asList(42);
+     array[0] = tmpList; // 语义上无效，但可以编译
+     String s = stringLists[0].get(0); // 哦不，运行时的 ClassCastException！
+   }
+   
+在运行时导致ClassCastException 。
+该平台的未来版本可能会要求此类不安全操作出现编译器错误。
+
+
+### @FunctionalInterface
+
+一种信息性注解类型，用于指示接口类型声明旨在成为 Java 语言规范定义的功能接口。从概念上讲，函数式接口只有一个抽象方法。由于默认方法有一个实现，它们不是抽象的。如果接口声明了一个覆盖java.lang.Object的公共方法之一的抽象方法，这也不会计入接口的抽象方法计数，因为接口的任何实现都将具有来自java.lang.Object或其他地方的实现(接口的实现是类,所有类的父类都是Object)。
+请注意，函数式接口的实例可以使用 lambda 表达式、方法引用或构造函数引用来创建。
+如果使用此注解类型对类型进行注解，则编译器需要生成错误消息，除非：
+该类型是接口类型，而不是注解类型、枚举或类。
+带注解的类型满足功能接口的要求。
+但是，无论接口声明中是否存在FunctionalInterface注释，编译器都会将满足功能接口定义的任何接口视为功能接口。
+
+
+
+ 在学习Lambda表达式时，我们了解过函数式接口（接口中只有个一个抽象方法可以存在多个默认方法或多个static方法）。
+
+@FunctionalInterface作用就是用来指定某一个接口必须是函数式接口的，所以@FunctionalInterface只能修饰接口。

-Java 注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明、配置的功能。注解不会也不能影响代码的实际逻辑，仅仅起到辅助性的作用。

-[注解 Annotation 实现原理与自定义注解例子](https://www.cnblogs.com/acm-bingzi/p/javaAnnotation.html)
--- a/Java基础教程/Java语言基础/11
+++ b/Java基础教程/Java语言基础/11
@@ -5,25 +5,15 @@
 ```java

 public native int hashCode()
-
 public boolean equals(Object obj)
-
 protected native Object clone() throws CloneNotSupportedException
-
 public String toString()
-
 public final native Class<?> getClass()
-
 protected void finalize() throws Throwable {}
-
 public final native void notify()
-
 public final native void notifyAll()
-
 public final native void wait(long timeout) throws InterruptedException
-
 public final void wait(long timeout, int nanos) throws InterruptedException
-
 public final void wait() throws InterruptedException
 ```

--- a/Java基础教程/Java语言基础/12
+++ b/Java基础教程/Java语言基础/12
@@ -1,5 +1,12 @@
+* [StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123
+](https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123)
+
 ## 0 概述

+### Number类
+包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类
+![](image/2022-07-12-10-41-19.png)
+
 ### 包装器类
 Java为了能将8种基本类型当对象来处理，能够连接相关的方法，设置了包装器类。

@@ -40,8 +47,8 @@ Float.floatValue()
 Double.doubleValue()
 ```

-* 装箱: 将基本类型转化为包装器类型 包装器类.valueOf(基本数据类型变量或常量)。装箱共享内存。
-* 拆箱：将包装器类型转化为基本数据类型XX.XXXvalue();拆箱也共享内存
+* 装箱Boxing: 将基本类型转化为包装器类型 包装器类.valueOf(基本数据类型变量或常量)。装箱共享内存。
+* 拆箱unBoxing：将包装器类型转化为基本数据类型XX.XXXvalue();拆箱也共享内存

 ```java
 Integer i = Integer.valueOf(10);//10是基本数据类型，i是包装器类型
@@ -56,7 +63,7 @@ int n = i.intValue();//i是包装器类型，n是包装器类型



-##  数据缓存池
+###  数据缓存池

 new Integer(123) 与 Integer.valueOf(123) 的区别在于：

@@ -136,7 +143,36 @@ System.out.println(m == n); // true

 在 jdk 1.8 所有的数值类缓冲池中，Integer 的缓冲池 IntegerCache 很特殊，这个缓冲池的下界是 - 128，上界默认是 127，但是这个上界是可调的，在启动 jvm 的时候，通过 -XX:AutoBoxCacheMax=&lt;size&gt; 来指定这个缓冲池的大小，该选项在 JVM 初始化的时候会设定一个名为 java.lang.IntegerCache.high 系统属性，然后 IntegerCache 初始化的时候就会读取该系统属性来决定上界。

-[StackOverflow : Differences between new Integer(123), Integer.valueOf(123) and just 123
-](https://stackoverflow.com/questions/9030817/differences-between-new-integer123-integer-valueof123-and-just-123)


+## 1 Character包装器
+
+### 转义字符
+* `\t`	在文中该处插入一个tab键
+* `\b`	在文中该处插入一个后退键
+* `\n`	在文中该处换行
+* `\r`	在文中该处插入回车
+* `\f`	在文中该处插入换页符
+* `\'`	在文中该处插入单引号
+* `\"`	在文中该处插入双引号
+* `\\`	在文中该处插入反斜杠
+
+### 主要方法
+
+
+1.	isLetter()
+是否是一个字母
+2.	isDigit()
+是否是一个数字字符
+3.	isWhitespace()
+是否是一个空白字符
+4.	isUpperCase()
+是否是大写字母
+5.	isLowerCase()
+是否是小写字母
+6.	toUpperCase()
+指定字母的大写形式
+7.	toLowerCase()
+指定字母的小写形式
+8.	toString()
+返回字符的字符串形式，字符串的长度仅为1
--- a/String&StringBuffer&StringBuilder.md
+++ b/String&StringBuffer&StringBuilder.md
@@ -0,0 +1,345 @@
+
+
+## 1 String原理
+
+### 概览
+
+String 被声明为 final，因此它不可被继承。(Integer 等包装类也不能被继承）
+
+在 Java 8 中，String 内部使用 char 数组存储数据。
+
+```java
+public final class String
+    implements java.io.Serializable, Comparable<String>, CharSequence {
+    /** The value is used for character storage. */
+    private final char value[];
+}
+```
+
+在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 `coder` 来标识使用了哪种编码。
+
+```java
+public final class String
+    implements java.io.Serializable, Comparable<String>, CharSequence {
+    /** The value is used for character storage. */
+    private final byte[] value;
+
+    /** The identifier of the encoding used to encode the bytes in {@code value}. */
+    private final byte coder;
+}
+```
+
+value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。
+
+### 不可变的好处
+
+**1. 可以缓存 hash 值**  
+
+因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
+
+**2. String Pool 的需要**  
+
+如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
+
+<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/image-20191210004132894.png"/> </div><br>
+
+**3. 安全性**  
+
+String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 的那一方以为现在连接的是其它主机，而实际情况却不一定是。
+
+**4. 线程安全**  
+
+String 不可变性天生具备线程安全，可以在多个线程中安全地使用。
+
+[Program Creek : Why String is immutable in Java?](https://www.programcreek.com/2013/04/why-string-is-immutable-in-java/)
+
+### String, StringBuffer and StringBuilder	
+
+**1. 可变性**  
+
+- String 不可变
+- StringBuffer 和 StringBuilder 可变
+
+**2. 线程安全**  
+
+- String 不可变，因此是线程安全的
+- StringBuilder 不是线程安全的
+- StringBuffer 是线程安全的，内部使用 synchronized 进行同步
+
+[StackOverflow : String, StringBuffer, and StringBuilder](https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder)
+
+### String Pool
+
+字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程将字符串添加到 String Pool 中。
+
+当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。
+
+下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 和 s2.intern() 方法取得同一个字符串引用。intern() 首先把 "aaa" 放到 String Pool 中，然后返回这个字符串引用，因此 s3 和 s4 引用的是同一个字符串。
+
+```java
+String s1 = new String("aaa");
+String s2 = new String("aaa");
+System.out.println(s1 == s2);           // false
+String s3 = s1.intern();
+String s4 = s2.intern();
+System.out.println(s3 == s4);           // true
+```
+
+如果是采用 "bbb" 这种字面量的形式创建字符串，会自动地将字符串放入 String Pool 中。
+
+```java
+String s5 = "bbb";
+String s6 = "bbb";
+System.out.println(s5 == s6);  // true
+```
+
+在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
+
+- [StackOverflow : What is String interning?](https://stackoverflow.com/questions/10578984/what-is-string-interning)
+- [深入解析 String#intern](https://tech.meituan.com/in_depth_understanding_string_intern.html)
+
+### new String("abc")
+
+使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）。
+
+- "abc" 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
+- 而使用 new 的方式会在堆中创建一个字符串对象。
+
+创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。
+
+```java
+public class NewStringTest {
+    public static void main(String[] args) {
+        String s = new String("abc");
+    }
+}
+```
+
+使用 javap -verbose 进行反编译，得到以下内容：
+
+```java
+// ...
+Constant pool:
+// ...
+   #2 = Class              #18            // java/lang/String
+   #3 = String             #19            // abc
+// ...
+  #18 = Utf8               java/lang/String
+  #19 = Utf8               abc
+// ...
+
+  public static void main(java.lang.String[]);
+    descriptor: ([Ljava/lang/String;)V
+    flags: ACC_PUBLIC, ACC_STATIC
+    Code:
+      stack=3, locals=2, args_size=1
+         0: new           #2                  // class java/lang/String
+         3: dup
+         4: ldc           #3                  // String abc
+         6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
+         9: astore_1
+// ...
+```
+
+在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
+
+以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
+
+```java
+public String(String original) {
+    this.value = original.value;
+    this.hash = original.hash;
+}
+```
+
+
+```java
+String sa = new String("hello");
+String sb = new String("hello");
+System.out.println(sa==sb);
+//False
+
+String sc = "hello";
+String sd = "hello";
+System.out.println(sc==sd);
+//True
+```
+
+
+## 2 字符串使用
+
+### 创建方法
+
+* 直接等于字符串返回的是字面常量的引用。intern创建的字面常量的引用。所以s1==s2
+* 使用new创建字符串相当于在堆上创建了字符串。其引用不相等。所以s4!=s5
+```java
+String str = "Runoob";
+String str2=new String("Runoob");
+String s1 = "Runoob";              // String 直接创建
+String s2 = "Runoob";              // String 直
+// s1==s2 true
+String s3 = s1;                    // 相同引用
+
+String s4 = new String("Runoob");   // String 对象创建
+String s5 = new String("Runoob");   // String 对象创建
+//s4==s5 false
+```
+![](image/2022-07-12-10-56-21.png)
+
+
+
+常见的构造方法
+
+* String s = “xxx”	最常用
+* String(String original)	String(“xxx”)
+* String(char数组)	
+* String(char数组,起始下标,长度)	
+* String(byte数组)	
+* String(byte数组,起始下标,长度)	
+* String(StringBuffer buffer)	
+* String(StringBuilder builder)
+### 关键方法
+
+
+* 字符串链接concat和+号的功能类似。
+```java
+"我的名字是 ".concat("Runoob");
+"Hello," + " runoob" + "!"
+```
+
+* 创建格式化字符串printf和format两个方法
+
+```java
+System.out.printf("浮点型变量的值为 " +
+                  "%f, 整型变量的值为 " +
+                  " %d, 字符串变量的值为 " +
+                  "is %s", floatVar, intVar, stringVar);
+```
+
+```
+String fs;
+fs = String.format("浮点型变量的值为 " +
+                   "%f, 整型变量的值为 " +
+                   " %d, 字符串变量的值为 " +
+                   " %s", floatVar, intVar, stringVar);
+```
+
+### 其他方法
+* char charAt(int index)返回指定索引处的 char 值。
+* int compareTo(Object o)把这个字符串和另一个对象比较。
+* int compareTo(String anotherString)按字典顺序比较两个字符串。
+* int compareToIgnoreCase(String str)按字典顺序比较两个字符串，不考虑大小写。
+* String concat(String str)将指定字符串连接到此字符串的结尾。
+* boolean contentEquals(StringBuffer sb)当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。
+* static String copyValueOf(char[] data)返回指定数组中表示该字符序列的 String。
+* static String copyValueOf(char[] data, int offset, int count)返回指定数组中表示该字符序列的 String。
+* boolean endsWith(String suffix)测试此字符串是否以指定的后缀结束。
+* boolean equals(Object anObject)将此字符串与指定的对象比较。
+* boolean equalsIgnoreCase(String anotherString)将此 String 与另一个 String 比较，不考虑大小写。
+* byte[] getBytes()&nbsp;使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
+* byte[] getBytes(String charsetName)使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
+* void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)将字符从此字符串复制到目标字符数组。
+* int hashCode()返回此字符串的哈希码。
+* int indexOf(int ch)返回指定字符在此字符串中第一次出现处的索引。
+* int indexOf(int ch, int fromIndex)返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
+* int indexOf(String str)&nbsp;返回指定子字符串在此字符串中第一次出现处的索引。
+* int indexOf(String str, int fromIndex)返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。
+* String intern()&nbsp;返回字符串对象的规范化表示形式。
+* int lastIndexOf(int ch)&nbsp;返回指定字符在此字符串中最后一次出现处的索引。
+* int lastIndexOf(int ch, int fromIndex)返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。
+* int lastIndexOf(String str)返回指定子字符串在此字符串中最右边出现处的索引。
+* int lastIndexOf(String str, int fromIndex)&nbsp;返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
+* int length()返回此字符串的长度。
+* boolean matches(String regex)告知此字符串是否匹配给定的正则表达式。
+* boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)测试两个字符串区域是否相等。
+* boolean regionMatches(int toffset, String other, int ooffset, int len)测试两个字符串区域是否相等。
+* String replace(char oldChar, char newChar)返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
+* String replaceAll(String regex, String replacement)使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
+* String replaceFirst(String regex, String replacement)&nbsp;使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
+* String[] split(String regex)根据给定正则表达式的匹配拆分此字符串。
+* String[] split(String regex, int limit)根据匹配给定的正则表达式来拆分此字符串。
+* boolean startsWith(String prefix)测试此字符串是否以指定的前缀开始。
+* boolean startsWith(String prefix, int toffset)测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
+* CharSequence subSequence(int beginIndex, int endIndex)&nbsp;返回一个新的字符序列，它是此序列的一个子序列。
+* String substring(int beginIndex)返回一个新的字符串，它是此字符串的一个子字符串。
+* String substring(int beginIndex, int endIndex)返回一个新字符串，它是此字符串的一个子字符串。
+* char[] toCharArray()将此字符串转换为一个新的字符数组。
+* String toLowerCase()使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
+* String toLowerCase(Locale locale)&nbsp;使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
+* String toString()&nbsp;返回此对象本身（它已经是一个字符串！）。
+* String toUpperCase()使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
+* String toUpperCase(Locale locale)使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
+* String trim()返回字符串的副本，忽略前导空白和尾部空白。
+* static String valueOf(primitive data type x)返回给定data type类型x参数的字符串表示形式。
+* contains(CharSequence chars)判断是否包含指定的字符系列。
+* isEmpty()判断字符串是否为空。
+
+
+
+## 3 StringBuffer&StringBuilder
+
+![](image/2022-07-12-11-07-56.png)
+
+### 简介
+
+StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
+* 使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用 StringBuffer。
+
+* StringBuilder 的方法不是线程安全的（不能同步访问）。StringBuffer是线程安全的。
+
+* 由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。
+
+
+### 使用
+
+```java
+public class RunoobTest{
+    public static void main(String args[]){
+        StringBuilder sb = new StringBuilder(10);
+        sb.append("Runoob..");
+        System.out.println(sb);  
+        sb.append("!");
+        System.out.println(sb); 
+        sb.insert(8, "Java");
+        System.out.println(sb); 
+        sb.delete(5,8);
+        System.out.println(sb);  
+    }
+}
+```
+
+### StringBuffer常用方法
+
+常用方法
+* public StringBuffer append(String s)
+将指定的字符串追加到此字符序列。
+* public StringBuffer reverse()
+ 将此字符序列用其反转形式取代。
+* public delete(int start, int end)
+移除此序列的子字符串中的字符。
+* public insert(int offset, int i)
+将 int 参数的字符串表示形式插入此序列中。
+* insert(int offset, String str)
+将 str 参数的字符串插入此序列中。
+* replace(int start, int end, String str)
+使用给定 String 中的字符替换此序列的子字符串中的字符。
+
+其他方法
+
+* char charAt(int index)				返回此序列中指定索引处的 char 值。
+* void ensureCapacity(int minimumCapacity)				确保容量至少等于指定的最小值。
+* void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)				将字符从此序列复制到目标字符数组 dst。
+* int indexOf(String str)				返回第一次出现的指定子字符串在该字符串中的索引。
+* int indexOf(String str, int fromIndex)				从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
+* int lastIndexOf(String str)				返回最右边出现的指定子字符串在此字符串中的索引。
+* int lastIndexOf(String str, int fromIndex)返回 String 对象中子字符串最后出现的位置。
+* int length()				&nbsp;返回长度（字符数）。
+* void setCharAt(int index, char ch)				将给定索引处的字符设置为 ch。
+* void setLength(int newLength)				设置字符序列的长度。
+* CharSequence subSequence(int start, int end)				返回一个新的字符序列，该字符序列是此序列的子序列。
+* String substring(int start)				返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
+* String substring(int start, int end)				返回一个新的 String，它包含此序列当前所包含的字符子序列。
+* String toString()				返回此序列中数据的字符串表示形式。
+
+
+
--- a/Java基础教程/Java语言基础/13
+++ b/Java基础教程/Java语言基础/13
@@ -1,166 +0,0 @@
-
-
-## 2.3 String
-
-### 概览
-
-String 被声明为 final，因此它不可被继承。(Integer 等包装类也不能被继承）
-
-在 Java 8 中，String 内部使用 char 数组存储数据。
-
-```java
-public final class String
-    implements java.io.Serializable, Comparable<String>, CharSequence {
-    /** The value is used for character storage. */
-    private final char value[];
-}
-```
-
-在 Java 9 之后，String 类的实现改用 byte 数组存储字符串，同时使用 `coder` 来标识使用了哪种编码。
-
-```java
-public final class String
-    implements java.io.Serializable, Comparable<String>, CharSequence {
-    /** The value is used for character storage. */
-    private final byte[] value;
-
-    /** The identifier of the encoding used to encode the bytes in {@code value}. */
-    private final byte coder;
-}
-```
-
-value 数组被声明为 final，这意味着 value 数组初始化之后就不能再引用其它数组。并且 String 内部没有改变 value 数组的方法，因此可以保证 String 不可变。
-
-### 不可变的好处
-
-**1. 可以缓存 hash 值**  
-
-因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
-
-**2. String Pool 的需要**  
-
-如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
-
-<div align="center"> <img src="https://cs-notes-1256109796.cos.ap-guangzhou.myqcloud.com/image-20191210004132894.png"/> </div><br>
-
-**3. 安全性**  
-
-String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 的那一方以为现在连接的是其它主机，而实际情况却不一定是。
-
-**4. 线程安全**  
-
-String 不可变性天生具备线程安全，可以在多个线程中安全地使用。
-
-[Program Creek : Why String is immutable in Java?](https://www.programcreek.com/2013/04/why-string-is-immutable-in-java/)
-
-### String, StringBuffer and StringBuilder	
-
-**1. 可变性**  
-
- String 不可变
- StringBuffer 和 StringBuilder 可变
-
-**2. 线程安全**  
-
- String 不可变，因此是线程安全的
- StringBuilder 不是线程安全的
- StringBuffer 是线程安全的，内部使用 synchronized 进行同步
-
-[StackOverflow : String, StringBuffer, and StringBuilder](https://stackoverflow.com/questions/2971315/string-stringbuffer-and-stringbuilder)
-
-### String Pool
-
-字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程将字符串添加到 String Pool 中。
-
-当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。
-
-下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 和 s2.intern() 方法取得同一个字符串引用。intern() 首先把 "aaa" 放到 String Pool 中，然后返回这个字符串引用，因此 s3 和 s4 引用的是同一个字符串。
-
-```java
-String s1 = new String("aaa");
-String s2 = new String("aaa");
-System.out.println(s1 == s2);           // false
-String s3 = s1.intern();
-String s4 = s2.intern();
-System.out.println(s3 == s4);           // true
-```
-
-如果是采用 "bbb" 这种字面量的形式创建字符串，会自动地将字符串放入 String Pool 中。
-
-```java
-String s5 = "bbb";
-String s6 = "bbb";
-System.out.println(s5 == s6);  // true
-```
-
-在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。
-
- [StackOverflow : What is String interning?](https://stackoverflow.com/questions/10578984/what-is-string-interning)
- [深入解析 String#intern](https://tech.meituan.com/in_depth_understanding_string_intern.html)
-
-### new String("abc")
-
-使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 "abc" 字符串对象）。
-
- "abc" 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 "abc" 字符串字面量；
- 而使用 new 的方式会在堆中创建一个字符串对象。
-
-创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。
-
-```java
-public class NewStringTest {
-    public static void main(String[] args) {
-        String s = new String("abc");
-    }
-}
-```
-
-使用 javap -verbose 进行反编译，得到以下内容：
-
-```java
-// ...
-Constant pool:
-// ...
-   #2 = Class              #18            // java/lang/String
-   #3 = String             #19            // abc
-// ...
-  #18 = Utf8               java/lang/String
-  #19 = Utf8               abc
-// ...
-
-  public static void main(java.lang.String[]);
-    descriptor: ([Ljava/lang/String;)V
-    flags: ACC_PUBLIC, ACC_STATIC
-    Code:
-      stack=3, locals=2, args_size=1
-         0: new           #2                  // class java/lang/String
-         3: dup
-         4: ldc           #3                  // String abc
-         6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
-         9: astore_1
-// ...
-```
-
-在 Constant Pool 中，#19 存储这字符串字面量 "abc"，#3 是 String Pool 的字符串对象，它指向 #19 这个字符串字面量。在 main 方法中，0: 行使用 new #2 在堆中创建一个字符串对象，并且使用 ldc #3 将 String Pool 中的字符串对象作为 String 构造函数的参数。
-
-以下是 String 构造函数的源码，可以看到，在将一个字符串对象作为另一个字符串对象的构造函数参数时，并不会完全复制 value 数组内容，而是都会指向同一个 value 数组。
-
-```java
-public String(String original) {
-    this.value = original.value;
-    this.hash = original.hash;
-}
-```
-
-
-```java
-String sa = new String("hello");
-String sb = new String("hello");
-System.out.println(sa==sb);
-//False
-
-String sc = "hello";
-String sd = "hello";
-System.out.println(sc==sd);
-//True
-```
--- a/Java基础教程/Java语言基础/14
+++ b/Java基础教程/Java语言基础/14
@@ -0,0 +1,28 @@
+## 1 概述
+
+### Math类
+Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
+
+### Math中的常量
+* Math.PI 记录的圆周率
+* Math.E 记录e的常量
+
+### Math中的函数
+* Math.abs 求绝对值
+* Math.sin 正弦函数 Math.asin 反正弦函数
+* Math.cos 余弦函数 Math.acos 反余弦函数
+* Math.tan 正切函数 Math.atan 反正切函数 Math.atan2 商的反正切函数
+* Math.toDegrees 弧度转化为角度 Math.toRadians 角度转化为弧度
+* Math.ceil 得到不小于某数的最大整数
+* Math.floor 得到不大于某数的最大整数
+* Math.IEEEremainder 求余
+* Math.max 求两数中最大
+* Math.min 求两数中最小
+* Math.sqrt 求开方
+* Math.pow 求某数的任意次方, 抛出ArithmeticException处理溢出异常
+* Math.exp 求e的任意次方
+* Math.log10 以10为底的对数
+* Math.log 自然对数
+* Math.rint 求距离某数最近的整数（可能比某数大，也可能比它小）
+* Math.round 同上，返回int型或者long型（上一个函数返回double型）
+* Math.random 返回0，1之间的一个随机数
--- a/Java基础教程/Java语言基础/15
+++ b/Java基础教程/Java语言基础/15
@@ -0,0 +1,177 @@
+## 1 概述
+
+### 创建日期
+
+java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类提供两个构造函数来实例化 Date 对象。
+
+第一个构造函数使用当前日期和时间来初始化对象。
+```
+Date( )
+```
+第二个构造函数接收一个参数，该参数是从 1970 年 1 月 1 日起的毫秒数。
+```
+Date(long millisec)
+```
+
+### 日期操作
+
+* boolean after(Date date)
+若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
+* boolean before(Date date)
+若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
+* object clone( )
+返回此对象的副本。
+* int compareTo(Date date)
+比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
+* int compareTo(Object obj)
+若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
+* boolean equals(Object date)
+当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
+* long getTime( )
+返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
+* int hashCode( )
+ 返回此对象的哈希码值。
+* void setTime(long time)用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
+* String toString( )
+把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。
+
+
+### 日期比较
+
+Java使用以下三种方法来比较两个日期：
+
+* 使用 getTime() 方法获取两个日期（自1970年1月1日经历的毫秒数值），然后比较这两个值。
+* 使用方法 before()，after() 和 equals()。例如，一个月的12号比18号早，则 new Date(99, 2, 12).before(new Date (99, 2, 18)) 返回true。
+* 使用 compareTo() 方法，它是由 Comparable 接口定义的，Date 类实现了这个接口。
+
+
+## 2 日期格式化SimpleDateFormat
+
+### 格式化的方法
+SimpleDateFormat 是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat 允许你选择任何用户自定义日期时间格式来运行。
+
+```java
+import  java.util.*;
+import java.text.*;
+ 
+public class DateDemo {
+   public static void main(String[] args) {
+ 
+      Date dNow = new Date( );
+      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
+ 
+      System.out.println("当前时间为: " + ft.format(dNow));
+   }
+}
+```
+
+### 格式化编码
+
+| 字母 | 描述 | 示例 |
+|---|---|---|
+| G | 纪元标记 | AD |
+| y | 四位年份 | 2001 |
+| M | 月份 | July or 07 |
+| d | 一个月的日期 | 10 |
+| h | &nbsp;A.M./P.M. (1~12)格式小时 | 12 |
+| H | 一天中的小时 (0~23) | 22 |
+| m | 分钟数 | 30 |
+| s | 秒数 | 55 |
+| S | 毫秒数 | 234 |
+| E | 星期几 | Tuesday |
+| D | 一年中的日子 | 360 |
+| F | 一个月中第几周的周几 | 2 (second Wed. in July) |
+| w | 一年中第几周 | 40 |
+| W | 一个月中第几周 | 1 |
+| a | A.M./P.M. 标记 | PM |
+| k | 一天中的小时(1~24) | 24 |
+| K | &nbsp;A.M./P.M. (0~11)格式小时 | 10 |
+| z | 时区 | Eastern Standard Time |
+| ' | 文字定界符 | Delimiter |
+| " | 单引号 | ` |
+
+### printf格式化日期
+
+printf 方法可以很轻松地格式化时间和日期。使用两个字母格式，它以 %t 开头并且以下面表格中的一个字母结尾。
+
+
+| 转&nbsp; 换&nbsp; 符 | 说&nbsp;&nbsp;&nbsp; 明 | 示&nbsp;&nbsp;&nbsp; 例 |
+|---|---|---|
+| c | 包括全部日期和时间信息 | 星期六 十月 27 14:21:20 CST 2007 |
+| F | "年-月-日"格式 | 2007-10-27 |
+| D | "月/日/年"格式 | 10/27/07 |
+| r | "HH:MM:SS PM"格式（12时制） | 02:25:51 下午 |
+| T | "HH:MM:SS"格式（24时制） | 14:28:16 |
+| R | "HH:MM"格式（24时制） | 14:28 |
+
+```java
+import java.util.Date;
+ 
+public class DateDemo {
+ 
+  public static void main(String[] args) {
+     // 初始化 Date 对象
+     Date date = new Date();
+ 
+     //c的使用  
+    System.out.printf("全部日期和时间信息：%tc%n",date);          
+    //f的使用  
+    System.out.printf("年-月-日格式：%tF%n",date);  
+    //d的使用  
+    System.out.printf("月/日/年格式：%tD%n",date);  
+    //r的使用  
+    System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",date);  
+    //t的使用  
+    System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date);  
+    //R的使用  
+    System.out.printf("HH:MM格式（24时制）：%tR",date);  
+  }
+}
+```
+
+
+## 3 系统运行时间
+
+
+### sleep
+sleep()使当前线程进入停滞状态（阻塞当前线程），让出CPU的使用、目的是不让当前线程独自霸占该进程所获的CPU资源，以留一定时间给其他线程执行的机会。
+```java
+import java.util.*;
+  
+public class SleepDemo {
+   public static void main(String[] args) {
+      try { 
+         System.out.println(new Date( ) + "\n"); 
+         Thread.sleep(1000*3);   // 休眠3秒
+         System.out.println(new Date( ) + "\n"); 
+      } catch (Exception e) { 
+          System.out.println("Got an exception!"); 
+      }
+   }
+}
+```
+### System.currentTimeMillis( )
+```java
+import java.util.*;
+  
+public class DiffDemo {
+ 
+   public static void main(String[] args) {
+      try {
+         long start = System.currentTimeMillis( );
+         System.out.println(new Date( ) + "\n");
+         Thread.sleep(5*60*10);
+         System.out.println(new Date( ) + "\n");
+         long end = System.currentTimeMillis( );
+         long diff = end - start;
+         System.out.println("Difference is : " + diff);
+      } catch (Exception e) {
+         System.out.println("Got an exception!");
+      }
+   }
+}
+```
+
+
+## 4 Calendar类
+> 日后补充把
--- a/Java基础教程/Java语言基础/16
+++ b/Java基础教程/Java语言基础/16
@@ -1,5 +1,6 @@
 ## Scanner

+### 基本使用方法
 ```java
 Scanner s = new Scanner(System.in);

@@ -14,6 +15,12 @@ s.close();
 ```


+### 读取不同类型的数据
+
+* 读取会阻塞，但是读取错误的数据会返回false
+  * 没有数据——阻塞
+  * 有数据，类型正确——true
+  * 有数据，类型错误——false
 ```java

 package com.ykl;
@@ -26,21 +33,21 @@ public class ScannerTest {

        System.out.println("使用不同的方式读取数据");

-//        // hasNext会一直阻塞，直到由新的内容。
-//        while(s.hasNext()){
-//            System.out.println("读取前的环节");
-//            String str = s.next();
-//            System.out.println("读取到的内容位："+str);
-//        }
-//
-//
-//        // hasNextLine会一直阻塞，直到由新的内容。测试一下next()是否会阻塞
-//        while(s.hasNextLine()){
-//            System.out.println("读取前的环节");
-//            String str = s.nextLine();
-//            System.out.println("读取到的内容位："+str);
-//        }
-//
+       // hasNext会一直阻塞，直到由新的内容。
+       while(s.hasNext()){
+           System.out.println("读取前的环节");
+           String str = s.next();
+           System.out.println("读取到的内容位："+str);
+       }
+
+
+       // hasNextLine会一直阻塞，直到由新的内容。测试一下next()是否会阻塞
+       while(s.hasNextLine()){
+           System.out.println("读取前的环节");
+           String str = s.nextLine();
+           System.out.println("读取到的内容位："+str);
+       }
+

        //hasNextInt方法会阻塞，如果不是整数会返回False
        if(s.hasNextInt()){
--- a/Java基础教程/Java语言基础/17
+++ b/Java基础教程/Java语言基础/17
@@ -0,0 +1,2 @@
+## Java 正则表达式
+
--- a/Java基础教程/Java语言基础/21
+++ b/Java基础教程/Java语言基础/21
@@ -1,39 +1,47 @@
 # Java IO
 <!-- GFM-TOC -->
-* [Java IO](#java-io)
-    * [一、概览](#一概览)
-    * [二、磁盘操作](#二磁盘操作)
-    * [三、字节操作](#三字节操作)
-        * [实现文件复制](#实现文件复制)
-        * [装饰者模式](#装饰者模式)
-    * [四、字符操作](#四字符操作)
-        * [编码与解码](#编码与解码)
-        * [String 的编码方式](#string-的编码方式)
-        * [Reader 与 Writer](#reader-与-writer)
-        * [实现逐行输出文本文件的内容](#实现逐行输出文本文件的内容)
-    * [五、对象操作](#五对象操作)
-        * [序列化](#序列化)
-        * [Serializable](#serializable)
-        * [transient](#transient)
-    * [六、网络操作](#六网络操作)
-        * [InetAddress](#inetaddress)
-        * [URL](#url)
-        * [Sockets](#sockets)
-        * [Datagram](#datagram)
-    * [七、NIO](#七nio)
-        * [流与块](#流与块)
-        * [通道与缓冲区](#通道与缓冲区)
-        * [缓冲区状态变量](#缓冲区状态变量)
-        * [文件 NIO 实例](#文件-nio-实例)
-        * [选择器](#选择器)
-        * [套接字 NIO 实例](#套接字-nio-实例)
-        * [内存映射文件](#内存映射文件)
-        * [对比](#对比)
-    * [八、参考资料](#八参考资料)
+- [Java IO](#java-io)
+  - [一、概览](#一概览)
+  - [二、磁盘操作](#二磁盘操作)
+  - [三、字节操作](#三字节操作)
+    - [实现文件复制](#实现文件复制)
+    - [装饰者模式](#装饰者模式)
+  - [四、字符操作](#四字符操作)
+    - [编码与解码](#编码与解码)
+    - [String 的编码方式](#string-的编码方式)
+    - [Reader 与 Writer](#reader-与-writer)
+    - [实现逐行输出文本文件的内容](#实现逐行输出文本文件的内容)
+  - [五、对象操作](#五对象操作)
+    - [序列化](#序列化)
+    - [Serializable](#serializable)
+    - [transient](#transient)
+  - [六、网络操作](#六网络操作)
+    - [InetAddress](#inetaddress)
+    - [URL](#url)
+    - [Sockets](#sockets)
+    - [Datagram](#datagram)
+  - [七、NIO](#七nio)
+    - [流与块](#流与块)
+    - [通道与缓冲区](#通道与缓冲区)
+      - [1. 通道](#1-通道)
+      - [2. 缓冲区](#2-缓冲区)
+    - [缓冲区状态变量](#缓冲区状态变量)
+    - [文件 NIO 实例](#文件-nio-实例)
+    - [选择器](#选择器)
+      - [1. 创建选择器](#1-创建选择器)
+      - [2. 将通道注册到选择器上](#2-将通道注册到选择器上)
+      - [3. 监听事件](#3-监听事件)
+      - [4. 获取到达的事件](#4-获取到达的事件)
+      - [5. 事件循环](#5-事件循环)
+    - [套接字 NIO 实例](#套接字-nio-实例)
+    - [内存映射文件](#内存映射文件)
+    - [对比](#对比)
+  - [八、参考资料](#八参考资料)
 <!-- GFM-TOC -->


 ## 一、概览
+![](image/2022-07-12-11-35-43.png)

 Java 的 I/O 大概可以分成以下几类：

--- a/Java基础教程/Java语言基础/Number&Math.md
+++ b/Java基础教程/Java语言基础/Number&Math.md
--- a/Java基础教程/Java语言基础/23
+++ b/Java基础教程/Java语言基础/23
--- a/Java基础教程/Java语言基础/image/2022-07-12-10-04-38.png
+++ b/Java基础教程/Java语言基础/image/2022-07-12-10-04-38.png
--- a/Java基础教程/Java语言基础/image/2022-07-12-10-41-19.png
+++ b/Java基础教程/Java语言基础/image/2022-07-12-10-41-19.png
--- a/Java基础教程/Java语言基础/image/2022-07-12-10-56-21.png
+++ b/Java基础教程/Java语言基础/image/2022-07-12-10-56-21.png
--- a/Java基础教程/Java语言基础/image/2022-07-12-11-07-56.png
+++ b/Java基础教程/Java语言基础/image/2022-07-12-11-07-56.png
--- a/Java基础教程/Java语言基础/image/2022-07-12-11-35-43.png
+++ b/Java基础教程/Java语言基础/image/2022-07-12-11-35-43.png
--- a/Java性能优化/性能优化简介.md
+++ b/Java性能优化/性能优化简介.md
--- a/Java框架教程/SpringCloud/SpringCloud简介.md
+++ b/Java框架教程/SpringCloud/SpringCloud简介.md
--- a/Java框架教程/SpringMVC/SpringMVC简介.md
+++ b/Java框架教程/SpringMVC/SpringMVC简介.md
--- a/Java框架教程/Springframework/SpringFramework简介.md
+++ b/Java框架教程/Springframework/SpringFramework简介.md
--- a/Java源代码/.idea/.gitignore
+++ b/Java源代码/.idea/.gitignore
@@ -1,10 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml
-# Zeppelin ignored files
-/ZeppelinRemoteNotebooks/
--- a/Java源代码/.idea/ConfPoetryConfig.xml
+++ b/Java源代码/.idea/ConfPoetryConfig.xml
@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ConfPoetryConfig">
-    <option name="pathRules">
-      <list>
-        <option value=".*/config/[^/]+/[^/]+/((env)|(drm)|(log)|(meta)|(scheduler)|(serviceGroup)|(zdal)|(ci))/[^/]+" />
-        <option value=".*/config/[^/]+/dbSql/[^/]+" />
-        <option value=".*/conf/iac/[^/]+/((env)|(drm)|(log)|(meta)|(scheduler)|(serviceGroup)|(zdal)|(ci)|(sofamq)|(database))/[^/]+" />
-        <option value=".*/conf/iac/[^/]+/msg/(pub|sub)/[^/]+" />
-      </list>
-    </option>
-  </component>
-</project>
--- a/Java源代码/.idea/Java源代码.iml
+++ b/Java源代码/.idea/Java源代码.iml
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>
--- a/Java源代码/.idea/inspectionProfiles/Project_Default.xml
+++ b/Java源代码/.idea/inspectionProfiles/Project_Default.xml
@@ -1,33 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="IncorrectHttpHeaderInspection" enabled="true" level="WARNING" enabled_by_default="true">
-      <option name="customHeaders">
-        <set>
-          <option value="SOFA-Tenant" />
-          <option value="DRM-PushMode" />
-          <option value="DRM-DataFormat" />
-          <option value="DRM-Zones" />
-          <option value="DRM-Ips" />
-          <option value="DRM-Profiles" />
-          <option value="RPC-Url" />
-          <option value="RPC-UniqueId" />
-          <option value="RPC-SofaContext" />
-          <option value="RPC-SofaGroup" />
-          <option value="Scheduler-JobRunMode" />
-          <option value="Scheduler-Zone" />
-          <option value="Scheduler-JobAppName" />
-          <option value="MsgBroker-Type" />
-          <option value="MsgBroker-Zone" />
-          <option value="MsgBroker-PayloadClazz" />
-          <option value="MsgBroker-GroupId" />
-          <option value="MsgBroker-Dependencies" />
-          <option value="MsgBroker-Properties" />
-          <option value="MsgBroker-TargetNode" />
-          <option value="MsgBroker-ZoneUid" />
-          <option value="MsgBroker-DevGroup" />
-        </set>
-      </option>
-    </inspection_tool>
-  </profile>
-</component>
--- a/Java源代码/.idea/misc.xml
+++ b/Java源代码/.idea/misc.xml
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectRootManager">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>
--- a/Java源代码/.idea/modules.xml
+++ b/Java源代码/.idea/modules.xml
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/Java源代码.iml" filepath="$PROJECT_DIR$/Java源代码.iml" />
-      <module fileurl="file://$PROJECT_DIR$/Lesson02/Lesson02.iml" filepath="$PROJECT_DIR$/Lesson02/Lesson02.iml" />
-    </modules>
-  </component>
-</project>
--- a/Java源代码/.idea/vcs.xml
+++ b/Java源代码/.idea/vcs.xml
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
-  </component>
-</project>
--- a/Java源代码/Lesson03/.idea/compiler.xml
+++ b/Java源代码/Lesson03/.idea/compiler.xml
@@ -8,8 +8,10 @@
        <outputRelativeToContentRoot value="true" />
        <module name="web-project" />
        <module name="basicLesson" />
-        <module name="untitled" />
      </profile>
    </annotationProcessing>
+    <bytecodeTargetLevel>
+      <module name="untitled" target="1.5" />
+    </bytecodeTargetLevel>
  </component>
 </project>
--- a/Java源代码/Lesson03/.idea/misc.xml
+++ b/Java源代码/Lesson03/.idea/misc.xml
@@ -8,7 +8,6 @@
    <option name="originalFiles">
      <list>
        <option value="$PROJECT_DIR$/basicLesson/pom.xml" />
-        <option value="$PROJECT_DIR$/untitled/pom.xml" />
        <option value="$PROJECT_DIR$/web-project/pom.xml" />
      </list>
    </option>
--- a/Java源代码/Lesson03/basicLesson/src/main/java/com/ykl/Application.java
+++ b/Java源代码/Lesson03/basicLesson/src/main/java/com/ykl/Application.java
@@ -10,6 +10,13 @@ package com.ykl;
 */
 public class Application {
    public static void main(String[] args) {
+        String a = "test";
+        String b = "test";
+        String c = new String("test");
+        String d = new String("test");
+
+        System.out.println(a==b);
+        System.out.println(c==d);
        System.out.println("hello world");


--- a/Java源代码/Lesson03/basicLesson/src/main/java/com/ykl/annotationtest/AnnotationTest.java
+++ b/Java源代码/Lesson03/basicLesson/src/main/java/com/ykl/annotationtest/AnnotationTest.java
@@ -1,9 +1,38 @@
 /**
 * Alipay.com Inc.
 * Copyright (c) 2004-2022 All Rights Reserved.
- */package com.ykl.annotationtest;/**
- *
+ */
+package com.ykl.annotationtest;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+/**
 * @author yinkanglong
 * @version : AnnotationTest, v 0.1 2022-07-12 09:50 yinkanglong Exp $
- */public class AnnotationTest {
+ */
+public class AnnotationTest {
+
+    public static void main(String[] args) throws Exception {
+        // 获取类上的注解
+        Class<Demo> clazz = Demo.class;
+        MyAnnotation annotationOnClass = clazz.getAnnotation(MyAnnotation.class);
+        System.out.println(annotationOnClass.getValue());
+
+        // 获取成员变量上的注解
+        Field name = clazz.getField("name");
+        MyAnnotation annotationOnField = name.getAnnotation(MyAnnotation.class);
+        System.out.println(annotationOnField.getValue());
+
+        // 获取hello方法上的注解
+        Method hello = clazz.getMethod("hello", (Class<?>[]) null);
+        MyAnnotation annotationOnMethod = hello.getAnnotation(MyAnnotation.class);
+        System.out.println(annotationOnMethod.getValue());
+
+        // 获取defaultMethod方法上的注解
+        Method defaultMethod = clazz.getMethod("defaultMethod", (Class<?>[]) null);
+        MyAnnotation annotationOnDefaultMethod = defaultMethod.getAnnotation(MyAnnotation.class);
+        System.out.println(annotationOnDefaultMethod.getValue());
+
+    }
 }
--- a/Java源代码/Lesson03/basicLesson/src/main/java/com/ykl/annotationtest/Demo.java
+++ b/Java源代码/Lesson03/basicLesson/src/main/java/com/ykl/annotationtest/Demo.java
@@ -1,9 +1,25 @@
 /**
 * Alipay.com Inc.
 * Copyright (c) 2004-2022 All Rights Reserved.
- */package com.ykl.annotationtest;/**
- *
+ */
+package com.ykl.annotationtest;
+
+/**
 * @author yinkanglong
 * @version : Demo, v 0.1 2022-07-12 09:49 yinkanglong Exp $
- */public class Demo {
-}
+ */
+/**
+ * @author qiyu
+ */
+@MyAnnotation(getValue = "annotation on class")
+public class Demo {
+
+    @MyAnnotation(getValue = "annotation on field")
+    public String name;
+
+    @MyAnnotation(getValue = "annotation on method")
+    public void hello() {}
+
+    @MyAnnotation() // 故意不指定getValue
+    public void defaultMethod() {}
+}
--- a/Java源代码/Lesson03/basicLesson/src/main/java/com/ykl/annotationtest/MyAnnotation.java
+++ b/Java源代码/Lesson03/basicLesson/src/main/java/com/ykl/annotationtest/MyAnnotation.java
@@ -2,7 +2,7 @@
 * Alipay.com Inc.
 * Copyright (c) 2004-2022 All Rights Reserved.
 */
-package com.ykl;
+package com.ykl.annotationtest;

 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
@@ -15,5 +15,3 @@ import java.lang.annotation.RetentionPolicy;
 public @interface MyAnnotation {
    String getValue() default "no description";
 }
-public class MyAnnotation {
-}
--- a/Java源代码/Lesson03/basicLesson/src/main/java/com/ykl/eceptiontest/ExceptionTest.java
+++ b/Java源代码/Lesson03/basicLesson/src/main/java/com/ykl/eceptiontest/ExceptionTest.java
@@ -2,7 +2,7 @@
 * Alipay.com Inc.
 * Copyright (c) 2004-2022 All Rights Reserved.
 */
-package com.ykl;
+package com.ykl.eceptiontest;

 /**
 * @author yinkanglong
--- a/Java源代码/com/ykl/Demo5.html
+++ b/Java源代码/com/ykl/Demo5.html
@@ -1,282 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- NewPage -->
-<html lang="zh">
-<head>
-<!-- Generated by javadoc (1.8.0_333) on Sun Jul 10 18:03:14 CST 2022 -->
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>Demo5</title>
-<meta name="date" content="2022-07-10">
-<link rel="stylesheet" type="text/css" href="../../stylesheet.css" title="Style">
-<script type="text/javascript" src="../../script.js"></script>
-</head>
-<body>
-<script type="text/javascript"><!--
-    try {
-        if (location.href.indexOf('is-external=true') == -1) {
-            parent.document.title="Demo5";
-        }
-    }
-    catch(err) {
-    }
-//-->
-var methods = {"i0":9};
-var tabs = {65535:["t0","所有方法"],1:["t1","静态方法"],8:["t4","具体方法"]};
-var altColor = "altColor";
-var rowColor = "rowColor";
-var tableTab = "tableTab";
-var activeTableTab = "activeTableTab";
-</script>
-<noscript>
-<div>您的浏览器已禁用 JavaScript。</div>
-</noscript>
-<!-- ========= START OF TOP NAVBAR ======= -->
-<div class="topNav"><a name="navbar.top">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.top" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.top.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../com/ykl/package-summary.html">程序包</a></li>
-<li class="navBarCell1Rev">类</li>
-<li><a href="class-use/Demo5.html">使用</a></li>
-<li><a href="package-tree.html">树</a></li>
-<li><a href="../../deprecated-list.html">已过时</a></li>
-<li><a href="../../index-files/index-1.html">索引</a></li>
-<li><a href="../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个类</li>
-<li><a href="../../com/ykl/HelloWorld.html" title="com.ykl中的类"><span class="typeNameLink">下一个类</span></a></li>
-</ul>
-<ul class="navList">
-<li><a href="../../index.html?com/ykl/Demo5.html" target="_top">框架</a></li>
-<li><a href="Demo5.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_top">
-<li><a href="../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_top");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<div>
-<ul class="subNavList">
-<li>概要:&nbsp;</li>
-<li>嵌套&nbsp;|&nbsp;</li>
-<li>字段&nbsp;|&nbsp;</li>
-<li><a href="#constructor.summary">构造器</a>&nbsp;|&nbsp;</li>
-<li><a href="#method.summary">方法</a></li>
-</ul>
-<ul class="subNavList">
-<li>详细资料:&nbsp;</li>
-<li>字段&nbsp;|&nbsp;</li>
-<li><a href="#constructor.detail">构造器</a>&nbsp;|&nbsp;</li>
-<li><a href="#method.detail">方法</a></li>
-</ul>
-</div>
-<a name="skip.navbar.top">
-<!--   -->
-</a></div>
-<!-- ========= END OF TOP NAVBAR ========= -->
-<!-- ======== START OF CLASS DATA ======== -->
-<div class="header">
-<div class="subTitle">com.ykl</div>
-<h2 title="类 Demo5" class="title">类 Demo5</h2>
-</div>
-<div class="contentContainer">
-<ul class="inheritance">
-<li>java.lang.Object</li>
-<li>
-<ul class="inheritance">
-<li>com.ykl.Demo5</li>
-</ul>
-</li>
-</ul>
-<div class="description">
-<ul class="blockList">
-<li class="blockList">
-<hr>
-<br>
-<pre>public class <span class="typeNameLabel">Demo5</span>
-extends java.lang.Object</pre>
-<dl>
-<dt><span class="simpleTagLabel">从以下版本开始:</span></dt>
-<dd>2022</dd>
-<dt><span class="simpleTagLabel">版本:</span></dt>
-<dd>1.0</dd>
-<dt><span class="simpleTagLabel">作者:</span></dt>
-<dd>ykl</dd>
-</dl>
-</li>
-</ul>
-</div>
-<div class="summary">
-<ul class="blockList">
-<li class="blockList">
-<!-- ======== CONSTRUCTOR SUMMARY ======== -->
-<ul class="blockList">
-<li class="blockList"><a name="constructor.summary">
-<!--   -->
-</a>
-<h3>构造器概要</h3>
-<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="构造器概要表, 列表构造器和解释">
-<caption><span>构造器</span><span class="tabEnd">&nbsp;</span></caption>
-<tr>
-<th class="colOne" scope="col">构造器和说明</th>
-</tr>
-<tr class="altColor">
-<td class="colOne"><code><span class="memberNameLink"><a href="../../com/ykl/Demo5.html#Demo5--">Demo5</a></span>()</code>&nbsp;</td>
-</tr>
-</table>
-</li>
-</ul>
-<!-- ========== METHOD SUMMARY =========== -->
-<ul class="blockList">
-<li class="blockList"><a name="method.summary">
-<!--   -->
-</a>
-<h3>方法概要</h3>
-<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="方法概要表, 列表方法和解释">
-<caption><span id="t0" class="activeTableTab"><span>所有方法</span><span class="tabEnd">&nbsp;</span></span><span id="t1" class="tableTab"><span><a href="javascript:show(1);">静态方法</a></span><span class="tabEnd">&nbsp;</span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">具体方法</a></span><span class="tabEnd">&nbsp;</span></span></caption>
-<tr>
-<th class="colFirst" scope="col">限定符和类型</th>
-<th class="colLast" scope="col">方法和说明</th>
-</tr>
-<tr id="i0" class="altColor">
-<td class="colFirst"><code>static void</code></td>
-<td class="colLast"><code><span class="memberNameLink"><a href="../../com/ykl/Demo5.html#main-java.lang.String:A-">main</a></span>(java.lang.String[]&nbsp;args)</code>&nbsp;</td>
-</tr>
-</table>
-<ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.java.lang.Object">
-<!--   -->
-</a>
-<h3>从类继承的方法&nbsp;java.lang.Object</h3>
-<code>clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-</div>
-<div class="details">
-<ul class="blockList">
-<li class="blockList">
-<!-- ========= CONSTRUCTOR DETAIL ======== -->
-<ul class="blockList">
-<li class="blockList"><a name="constructor.detail">
-<!--   -->
-</a>
-<h3>构造器详细资料</h3>
-<a name="Demo5--">
-<!--   -->
-</a>
-<ul class="blockListLast">
-<li class="blockList">
-<h4>Demo5</h4>
-<pre>public&nbsp;Demo5()</pre>
-</li>
-</ul>
-</li>
-</ul>
-<!-- ============ METHOD DETAIL ========== -->
-<ul class="blockList">
-<li class="blockList"><a name="method.detail">
-<!--   -->
-</a>
-<h3>方法详细资料</h3>
-<a name="main-java.lang.String:A-">
-<!--   -->
-</a>
-<ul class="blockListLast">
-<li class="blockList">
-<h4>main</h4>
-<pre>public static&nbsp;void&nbsp;main(java.lang.String[]&nbsp;args)</pre>
-<dl>
-<dt><span class="paramLabel">参数:</span></dt>
-<dd><code>args</code> - canshu</dd>
-</dl>
-</li>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-</div>
-</div>
-<!-- ========= END OF CLASS DATA ========= -->
-<!-- ======= START OF BOTTOM NAVBAR ====== -->
-<div class="bottomNav"><a name="navbar.bottom">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.bottom" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.bottom.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../com/ykl/package-summary.html">程序包</a></li>
-<li class="navBarCell1Rev">类</li>
-<li><a href="class-use/Demo5.html">使用</a></li>
-<li><a href="package-tree.html">树</a></li>
-<li><a href="../../deprecated-list.html">已过时</a></li>
-<li><a href="../../index-files/index-1.html">索引</a></li>
-<li><a href="../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个类</li>
-<li><a href="../../com/ykl/HelloWorld.html" title="com.ykl中的类"><span class="typeNameLink">下一个类</span></a></li>
-</ul>
-<ul class="navList">
-<li><a href="../../index.html?com/ykl/Demo5.html" target="_top">框架</a></li>
-<li><a href="Demo5.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_bottom">
-<li><a href="../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_bottom");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<div>
-<ul class="subNavList">
-<li>概要:&nbsp;</li>
-<li>嵌套&nbsp;|&nbsp;</li>
-<li>字段&nbsp;|&nbsp;</li>
-<li><a href="#constructor.summary">构造器</a>&nbsp;|&nbsp;</li>
-<li><a href="#method.summary">方法</a></li>
-</ul>
-<ul class="subNavList">
-<li>详细资料:&nbsp;</li>
-<li>字段&nbsp;|&nbsp;</li>
-<li><a href="#constructor.detail">构造器</a>&nbsp;|&nbsp;</li>
-<li><a href="#method.detail">方法</a></li>
-</ul>
-</div>
-<a name="skip.navbar.bottom">
-<!--   -->
-</a></div>
-<!-- ======== END OF BOTTOM NAVBAR ======= -->
-</body>
-</html>
--- a/Java源代码/com/ykl/HelloWorld.html
+++ b/Java源代码/com/ykl/HelloWorld.html
@@ -1,270 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- NewPage -->
-<html lang="zh">
-<head>
-<!-- Generated by javadoc (1.8.0_333) on Sun Jul 10 18:03:14 CST 2022 -->
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>HelloWorld</title>
-<meta name="date" content="2022-07-10">
-<link rel="stylesheet" type="text/css" href="../../stylesheet.css" title="Style">
-<script type="text/javascript" src="../../script.js"></script>
-</head>
-<body>
-<script type="text/javascript"><!--
-    try {
-        if (location.href.indexOf('is-external=true') == -1) {
-            parent.document.title="HelloWorld";
-        }
-    }
-    catch(err) {
-    }
-//-->
-var methods = {"i0":9};
-var tabs = {65535:["t0","所有方法"],1:["t1","静态方法"],8:["t4","具体方法"]};
-var altColor = "altColor";
-var rowColor = "rowColor";
-var tableTab = "tableTab";
-var activeTableTab = "activeTableTab";
-</script>
-<noscript>
-<div>您的浏览器已禁用 JavaScript。</div>
-</noscript>
-<!-- ========= START OF TOP NAVBAR ======= -->
-<div class="topNav"><a name="navbar.top">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.top" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.top.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../com/ykl/package-summary.html">程序包</a></li>
-<li class="navBarCell1Rev">类</li>
-<li><a href="class-use/HelloWorld.html">使用</a></li>
-<li><a href="package-tree.html">树</a></li>
-<li><a href="../../deprecated-list.html">已过时</a></li>
-<li><a href="../../index-files/index-1.html">索引</a></li>
-<li><a href="../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li><a href="../../com/ykl/Demo5.html" title="com.ykl中的类"><span class="typeNameLink">上一个类</span></a></li>
-<li>下一个类</li>
-</ul>
-<ul class="navList">
-<li><a href="../../index.html?com/ykl/HelloWorld.html" target="_top">框架</a></li>
-<li><a href="HelloWorld.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_top">
-<li><a href="../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_top");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<div>
-<ul class="subNavList">
-<li>概要:&nbsp;</li>
-<li>嵌套&nbsp;|&nbsp;</li>
-<li>字段&nbsp;|&nbsp;</li>
-<li><a href="#constructor.summary">构造器</a>&nbsp;|&nbsp;</li>
-<li><a href="#method.summary">方法</a></li>
-</ul>
-<ul class="subNavList">
-<li>详细资料:&nbsp;</li>
-<li>字段&nbsp;|&nbsp;</li>
-<li><a href="#constructor.detail">构造器</a>&nbsp;|&nbsp;</li>
-<li><a href="#method.detail">方法</a></li>
-</ul>
-</div>
-<a name="skip.navbar.top">
-<!--   -->
-</a></div>
-<!-- ========= END OF TOP NAVBAR ========= -->
-<!-- ======== START OF CLASS DATA ======== -->
-<div class="header">
-<div class="subTitle">com.ykl</div>
-<h2 title="类 HelloWorld" class="title">类 HelloWorld</h2>
-</div>
-<div class="contentContainer">
-<ul class="inheritance">
-<li>java.lang.Object</li>
-<li>
-<ul class="inheritance">
-<li>com.ykl.HelloWorld</li>
-</ul>
-</li>
-</ul>
-<div class="description">
-<ul class="blockList">
-<li class="blockList">
-<hr>
-<br>
-<pre>public class <span class="typeNameLabel">HelloWorld</span>
-extends java.lang.Object</pre>
-</li>
-</ul>
-</div>
-<div class="summary">
-<ul class="blockList">
-<li class="blockList">
-<!-- ======== CONSTRUCTOR SUMMARY ======== -->
-<ul class="blockList">
-<li class="blockList"><a name="constructor.summary">
-<!--   -->
-</a>
-<h3>构造器概要</h3>
-<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="构造器概要表, 列表构造器和解释">
-<caption><span>构造器</span><span class="tabEnd">&nbsp;</span></caption>
-<tr>
-<th class="colOne" scope="col">构造器和说明</th>
-</tr>
-<tr class="altColor">
-<td class="colOne"><code><span class="memberNameLink"><a href="../../com/ykl/HelloWorld.html#HelloWorld--">HelloWorld</a></span>()</code>&nbsp;</td>
-</tr>
-</table>
-</li>
-</ul>
-<!-- ========== METHOD SUMMARY =========== -->
-<ul class="blockList">
-<li class="blockList"><a name="method.summary">
-<!--   -->
-</a>
-<h3>方法概要</h3>
-<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="方法概要表, 列表方法和解释">
-<caption><span id="t0" class="activeTableTab"><span>所有方法</span><span class="tabEnd">&nbsp;</span></span><span id="t1" class="tableTab"><span><a href="javascript:show(1);">静态方法</a></span><span class="tabEnd">&nbsp;</span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">具体方法</a></span><span class="tabEnd">&nbsp;</span></span></caption>
-<tr>
-<th class="colFirst" scope="col">限定符和类型</th>
-<th class="colLast" scope="col">方法和说明</th>
-</tr>
-<tr id="i0" class="altColor">
-<td class="colFirst"><code>static void</code></td>
-<td class="colLast"><code><span class="memberNameLink"><a href="../../com/ykl/HelloWorld.html#main-java.lang.String:A-">main</a></span>(java.lang.String[]&nbsp;args)</code>&nbsp;</td>
-</tr>
-</table>
-<ul class="blockList">
-<li class="blockList"><a name="methods.inherited.from.class.java.lang.Object">
-<!--   -->
-</a>
-<h3>从类继承的方法&nbsp;java.lang.Object</h3>
-<code>clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait</code></li>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-</div>
-<div class="details">
-<ul class="blockList">
-<li class="blockList">
-<!-- ========= CONSTRUCTOR DETAIL ======== -->
-<ul class="blockList">
-<li class="blockList"><a name="constructor.detail">
-<!--   -->
-</a>
-<h3>构造器详细资料</h3>
-<a name="HelloWorld--">
-<!--   -->
-</a>
-<ul class="blockListLast">
-<li class="blockList">
-<h4>HelloWorld</h4>
-<pre>public&nbsp;HelloWorld()</pre>
-</li>
-</ul>
-</li>
-</ul>
-<!-- ============ METHOD DETAIL ========== -->
-<ul class="blockList">
-<li class="blockList"><a name="method.detail">
-<!--   -->
-</a>
-<h3>方法详细资料</h3>
-<a name="main-java.lang.String:A-">
-<!--   -->
-</a>
-<ul class="blockListLast">
-<li class="blockList">
-<h4>main</h4>
-<pre>public static&nbsp;void&nbsp;main(java.lang.String[]&nbsp;args)</pre>
-</li>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-</div>
-</div>
-<!-- ========= END OF CLASS DATA ========= -->
-<!-- ======= START OF BOTTOM NAVBAR ====== -->
-<div class="bottomNav"><a name="navbar.bottom">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.bottom" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.bottom.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../com/ykl/package-summary.html">程序包</a></li>
-<li class="navBarCell1Rev">类</li>
-<li><a href="class-use/HelloWorld.html">使用</a></li>
-<li><a href="package-tree.html">树</a></li>
-<li><a href="../../deprecated-list.html">已过时</a></li>
-<li><a href="../../index-files/index-1.html">索引</a></li>
-<li><a href="../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li><a href="../../com/ykl/Demo5.html" title="com.ykl中的类"><span class="typeNameLink">上一个类</span></a></li>
-<li>下一个类</li>
-</ul>
-<ul class="navList">
-<li><a href="../../index.html?com/ykl/HelloWorld.html" target="_top">框架</a></li>
-<li><a href="HelloWorld.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_bottom">
-<li><a href="../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_bottom");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<div>
-<ul class="subNavList">
-<li>概要:&nbsp;</li>
-<li>嵌套&nbsp;|&nbsp;</li>
-<li>字段&nbsp;|&nbsp;</li>
-<li><a href="#constructor.summary">构造器</a>&nbsp;|&nbsp;</li>
-<li><a href="#method.summary">方法</a></li>
-</ul>
-<ul class="subNavList">
-<li>详细资料:&nbsp;</li>
-<li>字段&nbsp;|&nbsp;</li>
-<li><a href="#constructor.detail">构造器</a>&nbsp;|&nbsp;</li>
-<li><a href="#method.detail">方法</a></li>
-</ul>
-</div>
-<a name="skip.navbar.bottom">
-<!--   -->
-</a></div>
-<!-- ======== END OF BOTTOM NAVBAR ======= -->
-</body>
-</html>
--- a/Java源代码/com/ykl/class-use/Demo5.html
+++ b/Java源代码/com/ykl/class-use/Demo5.html
@@ -1,123 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- NewPage -->
-<html lang="zh">
-<head>
-<!-- Generated by javadoc (1.8.0_333) on Sun Jul 10 18:03:14 CST 2022 -->
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>类 com.ykl.Demo5的使用</title>
-<meta name="date" content="2022-07-10">
-<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
-<script type="text/javascript" src="../../../script.js"></script>
-</head>
-<body>
-<script type="text/javascript"><!--
-    try {
-        if (location.href.indexOf('is-external=true') == -1) {
-            parent.document.title="\u7C7B com.ykl.Demo5\u7684\u4F7F\u7528";
-        }
-    }
-    catch(err) {
-    }
-//-->
-</script>
-<noscript>
-<div>您的浏览器已禁用 JavaScript。</div>
-</noscript>
-<!-- ========= START OF TOP NAVBAR ======= -->
-<div class="topNav"><a name="navbar.top">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.top" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.top.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../../com/ykl/package-summary.html">程序包</a></li>
-<li><a href="../../../com/ykl/Demo5.html" title="com.ykl中的类">类</a></li>
-<li class="navBarCell1Rev">使用</li>
-<li><a href="../../../overview-tree.html">树</a></li>
-<li><a href="../../../deprecated-list.html">已过时</a></li>
-<li><a href="../../../index-files/index-1.html">索引</a></li>
-<li><a href="../../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个</li>
-<li>下一个</li>
-</ul>
-<ul class="navList">
-<li><a href="../../../index.html?com/ykl/class-use/Demo5.html" target="_top">框架</a></li>
-<li><a href="Demo5.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_top">
-<li><a href="../../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_top");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.top">
-<!--   -->
-</a></div>
-<!-- ========= END OF TOP NAVBAR ========= -->
-<div class="header">
-<h2 title="类的使用 com.ykl.Demo5" class="title">类的使用<br>com.ykl.Demo5</h2>
-</div>
-<div class="classUseContainer">没有com.ykl.Demo5的用法</div>
-<!-- ======= START OF BOTTOM NAVBAR ====== -->
-<div class="bottomNav"><a name="navbar.bottom">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.bottom" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.bottom.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../../com/ykl/package-summary.html">程序包</a></li>
-<li><a href="../../../com/ykl/Demo5.html" title="com.ykl中的类">类</a></li>
-<li class="navBarCell1Rev">使用</li>
-<li><a href="../../../overview-tree.html">树</a></li>
-<li><a href="../../../deprecated-list.html">已过时</a></li>
-<li><a href="../../../index-files/index-1.html">索引</a></li>
-<li><a href="../../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个</li>
-<li>下一个</li>
-</ul>
-<ul class="navList">
-<li><a href="../../../index.html?com/ykl/class-use/Demo5.html" target="_top">框架</a></li>
-<li><a href="Demo5.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_bottom">
-<li><a href="../../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_bottom");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.bottom">
-<!--   -->
-</a></div>
-<!-- ======== END OF BOTTOM NAVBAR ======= -->
-</body>
-</html>
--- a/Java源代码/com/ykl/class-use/HelloWorld.html
+++ b/Java源代码/com/ykl/class-use/HelloWorld.html
@@ -1,123 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- NewPage -->
-<html lang="zh">
-<head>
-<!-- Generated by javadoc (1.8.0_333) on Sun Jul 10 18:03:14 CST 2022 -->
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>类 com.ykl.HelloWorld的使用</title>
-<meta name="date" content="2022-07-10">
-<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">
-<script type="text/javascript" src="../../../script.js"></script>
-</head>
-<body>
-<script type="text/javascript"><!--
-    try {
-        if (location.href.indexOf('is-external=true') == -1) {
-            parent.document.title="\u7C7B com.ykl.HelloWorld\u7684\u4F7F\u7528";
-        }
-    }
-    catch(err) {
-    }
-//-->
-</script>
-<noscript>
-<div>您的浏览器已禁用 JavaScript。</div>
-</noscript>
-<!-- ========= START OF TOP NAVBAR ======= -->
-<div class="topNav"><a name="navbar.top">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.top" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.top.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../../com/ykl/package-summary.html">程序包</a></li>
-<li><a href="../../../com/ykl/HelloWorld.html" title="com.ykl中的类">类</a></li>
-<li class="navBarCell1Rev">使用</li>
-<li><a href="../../../overview-tree.html">树</a></li>
-<li><a href="../../../deprecated-list.html">已过时</a></li>
-<li><a href="../../../index-files/index-1.html">索引</a></li>
-<li><a href="../../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个</li>
-<li>下一个</li>
-</ul>
-<ul class="navList">
-<li><a href="../../../index.html?com/ykl/class-use/HelloWorld.html" target="_top">框架</a></li>
-<li><a href="HelloWorld.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_top">
-<li><a href="../../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_top");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.top">
-<!--   -->
-</a></div>
-<!-- ========= END OF TOP NAVBAR ========= -->
-<div class="header">
-<h2 title="类的使用 com.ykl.HelloWorld" class="title">类的使用<br>com.ykl.HelloWorld</h2>
-</div>
-<div class="classUseContainer">没有com.ykl.HelloWorld的用法</div>
-<!-- ======= START OF BOTTOM NAVBAR ====== -->
-<div class="bottomNav"><a name="navbar.bottom">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.bottom" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.bottom.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../../com/ykl/package-summary.html">程序包</a></li>
-<li><a href="../../../com/ykl/HelloWorld.html" title="com.ykl中的类">类</a></li>
-<li class="navBarCell1Rev">使用</li>
-<li><a href="../../../overview-tree.html">树</a></li>
-<li><a href="../../../deprecated-list.html">已过时</a></li>
-<li><a href="../../../index-files/index-1.html">索引</a></li>
-<li><a href="../../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个</li>
-<li>下一个</li>
-</ul>
-<ul class="navList">
-<li><a href="../../../index.html?com/ykl/class-use/HelloWorld.html" target="_top">框架</a></li>
-<li><a href="HelloWorld.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_bottom">
-<li><a href="../../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_bottom");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.bottom">
-<!--   -->
-</a></div>
-<!-- ======== END OF BOTTOM NAVBAR ======= -->
-</body>
-</html>
--- a/Java源代码/com/ykl/package-frame.html
+++ b/Java源代码/com/ykl/package-frame.html
@@ -1,22 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- NewPage -->
-<html lang="zh">
-<head>
-<!-- Generated by javadoc (1.8.0_333) on Sun Jul 10 18:03:14 CST 2022 -->
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>com.ykl</title>
-<meta name="date" content="2022-07-10">
-<link rel="stylesheet" type="text/css" href="../../stylesheet.css" title="Style">
-<script type="text/javascript" src="../../script.js"></script>
-</head>
-<body>
-<h1 class="bar"><a href="../../com/ykl/package-summary.html" target="classFrame">com.ykl</a></h1>
-<div class="indexContainer">
-<h2 title="类">类</h2>
-<ul title="类">
-<li><a href="Demo5.html" title="com.ykl中的类" target="classFrame">Demo5</a></li>
-<li><a href="HelloWorld.html" title="com.ykl中的类" target="classFrame">HelloWorld</a></li>
-</ul>
-</div>
-</body>
-</html>
--- a/Java源代码/com/ykl/package-summary.html
+++ b/Java源代码/com/ykl/package-summary.html
@@ -1,145 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- NewPage -->
-<html lang="zh">
-<head>
-<!-- Generated by javadoc (1.8.0_333) on Sun Jul 10 18:03:14 CST 2022 -->
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>com.ykl</title>
-<meta name="date" content="2022-07-10">
-<link rel="stylesheet" type="text/css" href="../../stylesheet.css" title="Style">
-<script type="text/javascript" src="../../script.js"></script>
-</head>
-<body>
-<script type="text/javascript"><!--
-    try {
-        if (location.href.indexOf('is-external=true') == -1) {
-            parent.document.title="com.ykl";
-        }
-    }
-    catch(err) {
-    }
-//-->
-</script>
-<noscript>
-<div>您的浏览器已禁用 JavaScript。</div>
-</noscript>
-<!-- ========= START OF TOP NAVBAR ======= -->
-<div class="topNav"><a name="navbar.top">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.top" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.top.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li><a href="package-use.html">使用</a></li>
-<li><a href="package-tree.html">树</a></li>
-<li><a href="../../deprecated-list.html">已过时</a></li>
-<li><a href="../../index-files/index-1.html">索引</a></li>
-<li><a href="../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个程序包</li>
-<li>下一个程序包</li>
-</ul>
-<ul class="navList">
-<li><a href="../../index.html?com/ykl/package-summary.html" target="_top">框架</a></li>
-<li><a href="package-summary.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_top">
-<li><a href="../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_top");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.top">
-<!--   -->
-</a></div>
-<!-- ========= END OF TOP NAVBAR ========= -->
-<div class="header">
-<h1 title="程序包" class="title">程序包&nbsp;com.ykl</h1>
-</div>
-<div class="contentContainer">
-<ul class="blockList">
-<li class="blockList">
-<table class="typeSummary" border="0" cellpadding="3" cellspacing="0" summary="类概要表, 列表类和解释">
-<caption><span>类概要</span><span class="tabEnd">&nbsp;</span></caption>
-<tr>
-<th class="colFirst" scope="col">类</th>
-<th class="colLast" scope="col">说明</th>
-</tr>
-<tbody>
-<tr class="altColor">
-<td class="colFirst"><a href="../../com/ykl/Demo5.html" title="com.ykl中的类">Demo5</a></td>
-<td class="colLast">&nbsp;</td>
-</tr>
-<tr class="rowColor">
-<td class="colFirst"><a href="../../com/ykl/HelloWorld.html" title="com.ykl中的类">HelloWorld</a></td>
-<td class="colLast">&nbsp;</td>
-</tr>
-</tbody>
-</table>
-</li>
-</ul>
-</div>
-<!-- ======= START OF BOTTOM NAVBAR ====== -->
-<div class="bottomNav"><a name="navbar.bottom">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.bottom" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.bottom.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li><a href="package-use.html">使用</a></li>
-<li><a href="package-tree.html">树</a></li>
-<li><a href="../../deprecated-list.html">已过时</a></li>
-<li><a href="../../index-files/index-1.html">索引</a></li>
-<li><a href="../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个程序包</li>
-<li>下一个程序包</li>
-</ul>
-<ul class="navList">
-<li><a href="../../index.html?com/ykl/package-summary.html" target="_top">框架</a></li>
-<li><a href="package-summary.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_bottom">
-<li><a href="../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_bottom");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.bottom">
-<!--   -->
-</a></div>
-<!-- ======== END OF BOTTOM NAVBAR ======= -->
-</body>
-</html>
--- a/Java源代码/com/ykl/package-tree.html
+++ b/Java源代码/com/ykl/package-tree.html
@@ -1,133 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- NewPage -->
-<html lang="zh">
-<head>
-<!-- Generated by javadoc (1.8.0_333) on Sun Jul 10 18:03:14 CST 2022 -->
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>com.ykl 类分层结构</title>
-<meta name="date" content="2022-07-10">
-<link rel="stylesheet" type="text/css" href="../../stylesheet.css" title="Style">
-<script type="text/javascript" src="../../script.js"></script>
-</head>
-<body>
-<script type="text/javascript"><!--
-    try {
-        if (location.href.indexOf('is-external=true') == -1) {
-            parent.document.title="com.ykl \u7C7B\u5206\u5C42\u7ED3\u6784";
-        }
-    }
-    catch(err) {
-    }
-//-->
-</script>
-<noscript>
-<div>您的浏览器已禁用 JavaScript。</div>
-</noscript>
-<!-- ========= START OF TOP NAVBAR ======= -->
-<div class="topNav"><a name="navbar.top">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.top" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.top.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li>使用</li>
-<li class="navBarCell1Rev">树</li>
-<li><a href="../../deprecated-list.html">已过时</a></li>
-<li><a href="../../index-files/index-1.html">索引</a></li>
-<li><a href="../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个</li>
-<li>下一个</li>
-</ul>
-<ul class="navList">
-<li><a href="../../index.html?com/ykl/package-tree.html" target="_top">框架</a></li>
-<li><a href="package-tree.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_top">
-<li><a href="../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_top");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.top">
-<!--   -->
-</a></div>
-<!-- ========= END OF TOP NAVBAR ========= -->
-<div class="header">
-<h1 class="title">程序包com.ykl的分层结构</h1>
-</div>
-<div class="contentContainer">
-<h2 title="类分层结构">类分层结构</h2>
-<ul>
-<li type="circle">java.lang.Object
-<ul>
-<li type="circle">com.ykl.<a href="../../com/ykl/Demo5.html" title="com.ykl中的类"><span class="typeNameLink">Demo5</span></a></li>
-<li type="circle">com.ykl.<a href="../../com/ykl/HelloWorld.html" title="com.ykl中的类"><span class="typeNameLink">HelloWorld</span></a></li>
-</ul>
-</li>
-</ul>
-</div>
-<!-- ======= START OF BOTTOM NAVBAR ====== -->
-<div class="bottomNav"><a name="navbar.bottom">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.bottom" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.bottom.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li>使用</li>
-<li class="navBarCell1Rev">树</li>
-<li><a href="../../deprecated-list.html">已过时</a></li>
-<li><a href="../../index-files/index-1.html">索引</a></li>
-<li><a href="../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个</li>
-<li>下一个</li>
-</ul>
-<ul class="navList">
-<li><a href="../../index.html?com/ykl/package-tree.html" target="_top">框架</a></li>
-<li><a href="package-tree.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_bottom">
-<li><a href="../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_bottom");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.bottom">
-<!--   -->
-</a></div>
-<!-- ======== END OF BOTTOM NAVBAR ======= -->
-</body>
-</html>
--- a/Java源代码/com/ykl/package-use.html
+++ b/Java源代码/com/ykl/package-use.html
@@ -1,123 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- NewPage -->
-<html lang="zh">
-<head>
-<!-- Generated by javadoc (1.8.0_333) on Sun Jul 10 18:03:14 CST 2022 -->
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>程序包 com.ykl的使用</title>
-<meta name="date" content="2022-07-10">
-<link rel="stylesheet" type="text/css" href="../../stylesheet.css" title="Style">
-<script type="text/javascript" src="../../script.js"></script>
-</head>
-<body>
-<script type="text/javascript"><!--
-    try {
-        if (location.href.indexOf('is-external=true') == -1) {
-            parent.document.title="\u7A0B\u5E8F\u5305 com.ykl\u7684\u4F7F\u7528";
-        }
-    }
-    catch(err) {
-    }
-//-->
-</script>
-<noscript>
-<div>您的浏览器已禁用 JavaScript。</div>
-</noscript>
-<!-- ========= START OF TOP NAVBAR ======= -->
-<div class="topNav"><a name="navbar.top">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.top" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.top.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li class="navBarCell1Rev">使用</li>
-<li><a href="package-tree.html">树</a></li>
-<li><a href="../../deprecated-list.html">已过时</a></li>
-<li><a href="../../index-files/index-1.html">索引</a></li>
-<li><a href="../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个</li>
-<li>下一个</li>
-</ul>
-<ul class="navList">
-<li><a href="../../index.html?com/ykl/package-use.html" target="_top">框架</a></li>
-<li><a href="package-use.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_top">
-<li><a href="../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_top");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.top">
-<!--   -->
-</a></div>
-<!-- ========= END OF TOP NAVBAR ========= -->
-<div class="header">
-<h1 title="程序包的使用 com.ykl" class="title">程序包的使用<br>com.ykl</h1>
-</div>
-<div class="contentContainer">没有com.ykl的用法</div>
-<!-- ======= START OF BOTTOM NAVBAR ====== -->
-<div class="bottomNav"><a name="navbar.bottom">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.bottom" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.bottom.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li class="navBarCell1Rev">使用</li>
-<li><a href="package-tree.html">树</a></li>
-<li><a href="../../deprecated-list.html">已过时</a></li>
-<li><a href="../../index-files/index-1.html">索引</a></li>
-<li><a href="../../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个</li>
-<li>下一个</li>
-</ul>
-<ul class="navList">
-<li><a href="../../index.html?com/ykl/package-use.html" target="_top">框架</a></li>
-<li><a href="package-use.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_bottom">
-<li><a href="../../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_bottom");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.bottom">
-<!--   -->
-</a></div>
-<!-- ======== END OF BOTTOM NAVBAR ======= -->
-</body>
-</html>
--- a/Java源代码/index-files/index-1.html
+++ b/Java源代码/index-files/index-1.html
@@ -1,128 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- NewPage -->
-<html lang="zh">
-<head>
-<!-- Generated by javadoc (1.8.0_333) on Sun Jul 10 18:03:14 CST 2022 -->
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>C - 索引</title>
-<meta name="date" content="2022-07-10">
-<link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
-<script type="text/javascript" src="../script.js"></script>
-</head>
-<body>
-<script type="text/javascript"><!--
-    try {
-        if (location.href.indexOf('is-external=true') == -1) {
-            parent.document.title="C - \u7D22\u5F15";
-        }
-    }
-    catch(err) {
-    }
-//-->
-</script>
-<noscript>
-<div>您的浏览器已禁用 JavaScript。</div>
-</noscript>
-<!-- ========= START OF TOP NAVBAR ======= -->
-<div class="topNav"><a name="navbar.top">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.top" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.top.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li>使用</li>
-<li><a href="../overview-tree.html">树</a></li>
-<li><a href="../deprecated-list.html">已过时</a></li>
-<li class="navBarCell1Rev">索引</li>
-<li><a href="../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个字母</li>
-<li><a href="index-2.html">下一个字母</a></li>
-</ul>
-<ul class="navList">
-<li><a href="../index.html?index-files/index-1.html" target="_top">框架</a></li>
-<li><a href="index-1.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_top">
-<li><a href="../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_top");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.top">
-<!--   -->
-</a></div>
-<!-- ========= END OF TOP NAVBAR ========= -->
-<div class="contentContainer"><a href="index-1.html">C</a>&nbsp;<a href="index-2.html">D</a>&nbsp;<a href="index-3.html">H</a>&nbsp;<a href="index-4.html">M</a>&nbsp;<a name="I:C">
-<!--   -->
-</a>
-<h2 class="title">C</h2>
-<dl>
-<dt><a href="../com/ykl/package-summary.html">com.ykl</a> - 程序包 com.ykl</dt>
-<dd>&nbsp;</dd>
-</dl>
-<a href="index-1.html">C</a>&nbsp;<a href="index-2.html">D</a>&nbsp;<a href="index-3.html">H</a>&nbsp;<a href="index-4.html">M</a>&nbsp;</div>
-<!-- ======= START OF BOTTOM NAVBAR ====== -->
-<div class="bottomNav"><a name="navbar.bottom">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.bottom" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.bottom.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li>使用</li>
-<li><a href="../overview-tree.html">树</a></li>
-<li><a href="../deprecated-list.html">已过时</a></li>
-<li class="navBarCell1Rev">索引</li>
-<li><a href="../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li>上一个字母</li>
-<li><a href="index-2.html">下一个字母</a></li>
-</ul>
-<ul class="navList">
-<li><a href="../index.html?index-files/index-1.html" target="_top">框架</a></li>
-<li><a href="index-1.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_bottom">
-<li><a href="../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_bottom");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.bottom">
-<!--   -->
-</a></div>
-<!-- ======== END OF BOTTOM NAVBAR ======= -->
-</body>
-</html>
--- a/Java源代码/index-files/index-2.html
+++ b/Java源代码/index-files/index-2.html
@@ -1,130 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- NewPage -->
-<html lang="zh">
-<head>
-<!-- Generated by javadoc (1.8.0_333) on Sun Jul 10 18:03:14 CST 2022 -->
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>D - 索引</title>
-<meta name="date" content="2022-07-10">
-<link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
-<script type="text/javascript" src="../script.js"></script>
-</head>
-<body>
-<script type="text/javascript"><!--
-    try {
-        if (location.href.indexOf('is-external=true') == -1) {
-            parent.document.title="D - \u7D22\u5F15";
-        }
-    }
-    catch(err) {
-    }
-//-->
-</script>
-<noscript>
-<div>您的浏览器已禁用 JavaScript。</div>
-</noscript>
-<!-- ========= START OF TOP NAVBAR ======= -->
-<div class="topNav"><a name="navbar.top">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.top" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.top.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li>使用</li>
-<li><a href="../overview-tree.html">树</a></li>
-<li><a href="../deprecated-list.html">已过时</a></li>
-<li class="navBarCell1Rev">索引</li>
-<li><a href="../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li><a href="index-1.html">上一个字母</a></li>
-<li><a href="index-3.html">下一个字母</a></li>
-</ul>
-<ul class="navList">
-<li><a href="../index.html?index-files/index-2.html" target="_top">框架</a></li>
-<li><a href="index-2.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_top">
-<li><a href="../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_top");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.top">
-<!--   -->
-</a></div>
-<!-- ========= END OF TOP NAVBAR ========= -->
-<div class="contentContainer"><a href="index-1.html">C</a>&nbsp;<a href="index-2.html">D</a>&nbsp;<a href="index-3.html">H</a>&nbsp;<a href="index-4.html">M</a>&nbsp;<a name="I:D">
-<!--   -->
-</a>
-<h2 class="title">D</h2>
-<dl>
-<dt><a href="../com/ykl/Demo5.html" title="com.ykl中的类"><span class="typeNameLink">Demo5</span></a> - <a href="../com/ykl/package-summary.html">com.ykl</a>中的类</dt>
-<dd>&nbsp;</dd>
-<dt><span class="memberNameLink"><a href="../com/ykl/Demo5.html#Demo5--">Demo5()</a></span> - 类 的构造器com.ykl.<a href="../com/ykl/Demo5.html" title="com.ykl中的类">Demo5</a></dt>
-<dd>&nbsp;</dd>
-</dl>
-<a href="index-1.html">C</a>&nbsp;<a href="index-2.html">D</a>&nbsp;<a href="index-3.html">H</a>&nbsp;<a href="index-4.html">M</a>&nbsp;</div>
-<!-- ======= START OF BOTTOM NAVBAR ====== -->
-<div class="bottomNav"><a name="navbar.bottom">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.bottom" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.bottom.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li>使用</li>
-<li><a href="../overview-tree.html">树</a></li>
-<li><a href="../deprecated-list.html">已过时</a></li>
-<li class="navBarCell1Rev">索引</li>
-<li><a href="../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li><a href="index-1.html">上一个字母</a></li>
-<li><a href="index-3.html">下一个字母</a></li>
-</ul>
-<ul class="navList">
-<li><a href="../index.html?index-files/index-2.html" target="_top">框架</a></li>
-<li><a href="index-2.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_bottom">
-<li><a href="../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_bottom");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.bottom">
-<!--   -->
-</a></div>
-<!-- ======== END OF BOTTOM NAVBAR ======= -->
-</body>
-</html>
--- a/Java源代码/index-files/index-3.html
+++ b/Java源代码/index-files/index-3.html
@@ -1,130 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- NewPage -->
-<html lang="zh">
-<head>
-<!-- Generated by javadoc (1.8.0_333) on Sun Jul 10 18:03:14 CST 2022 -->
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>H - 索引</title>
-<meta name="date" content="2022-07-10">
-<link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
-<script type="text/javascript" src="../script.js"></script>
-</head>
-<body>
-<script type="text/javascript"><!--
-    try {
-        if (location.href.indexOf('is-external=true') == -1) {
-            parent.document.title="H - \u7D22\u5F15";
-        }
-    }
-    catch(err) {
-    }
-//-->
-</script>
-<noscript>
-<div>您的浏览器已禁用 JavaScript。</div>
-</noscript>
-<!-- ========= START OF TOP NAVBAR ======= -->
-<div class="topNav"><a name="navbar.top">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.top" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.top.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li>使用</li>
-<li><a href="../overview-tree.html">树</a></li>
-<li><a href="../deprecated-list.html">已过时</a></li>
-<li class="navBarCell1Rev">索引</li>
-<li><a href="../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li><a href="index-2.html">上一个字母</a></li>
-<li><a href="index-4.html">下一个字母</a></li>
-</ul>
-<ul class="navList">
-<li><a href="../index.html?index-files/index-3.html" target="_top">框架</a></li>
-<li><a href="index-3.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_top">
-<li><a href="../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_top");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.top">
-<!--   -->
-</a></div>
-<!-- ========= END OF TOP NAVBAR ========= -->
-<div class="contentContainer"><a href="index-1.html">C</a>&nbsp;<a href="index-2.html">D</a>&nbsp;<a href="index-3.html">H</a>&nbsp;<a href="index-4.html">M</a>&nbsp;<a name="I:H">
-<!--   -->
-</a>
-<h2 class="title">H</h2>
-<dl>
-<dt><a href="../com/ykl/HelloWorld.html" title="com.ykl中的类"><span class="typeNameLink">HelloWorld</span></a> - <a href="../com/ykl/package-summary.html">com.ykl</a>中的类</dt>
-<dd>&nbsp;</dd>
-<dt><span class="memberNameLink"><a href="../com/ykl/HelloWorld.html#HelloWorld--">HelloWorld()</a></span> - 类 的构造器com.ykl.<a href="../com/ykl/HelloWorld.html" title="com.ykl中的类">HelloWorld</a></dt>
-<dd>&nbsp;</dd>
-</dl>
-<a href="index-1.html">C</a>&nbsp;<a href="index-2.html">D</a>&nbsp;<a href="index-3.html">H</a>&nbsp;<a href="index-4.html">M</a>&nbsp;</div>
-<!-- ======= START OF BOTTOM NAVBAR ====== -->
-<div class="bottomNav"><a name="navbar.bottom">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.bottom" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.bottom.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li>使用</li>
-<li><a href="../overview-tree.html">树</a></li>
-<li><a href="../deprecated-list.html">已过时</a></li>
-<li class="navBarCell1Rev">索引</li>
-<li><a href="../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li><a href="index-2.html">上一个字母</a></li>
-<li><a href="index-4.html">下一个字母</a></li>
-</ul>
-<ul class="navList">
-<li><a href="../index.html?index-files/index-3.html" target="_top">框架</a></li>
-<li><a href="index-3.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_bottom">
-<li><a href="../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_bottom");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.bottom">
-<!--   -->
-</a></div>
-<!-- ======== END OF BOTTOM NAVBAR ======= -->
-</body>
-</html>
--- a/Java源代码/index-files/index-4.html
+++ b/Java源代码/index-files/index-4.html
@@ -1,130 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
-<!-- NewPage -->
-<html lang="zh">
-<head>
-<!-- Generated by javadoc (1.8.0_333) on Sun Jul 10 18:03:14 CST 2022 -->
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-<title>M - 索引</title>
-<meta name="date" content="2022-07-10">
-<link rel="stylesheet" type="text/css" href="../stylesheet.css" title="Style">
-<script type="text/javascript" src="../script.js"></script>
-</head>
-<body>
-<script type="text/javascript"><!--
-    try {
-        if (location.href.indexOf('is-external=true') == -1) {
-            parent.document.title="M - \u7D22\u5F15";
-        }
-    }
-    catch(err) {
-    }
-//-->
-</script>
-<noscript>
-<div>您的浏览器已禁用 JavaScript。</div>
-</noscript>
-<!-- ========= START OF TOP NAVBAR ======= -->
-<div class="topNav"><a name="navbar.top">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.top" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.top.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li>使用</li>
-<li><a href="../overview-tree.html">树</a></li>
-<li><a href="../deprecated-list.html">已过时</a></li>
-<li class="navBarCell1Rev">索引</li>
-<li><a href="../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li><a href="index-3.html">上一个字母</a></li>
-<li>下一个字母</li>
-</ul>
-<ul class="navList">
-<li><a href="../index.html?index-files/index-4.html" target="_top">框架</a></li>
-<li><a href="index-4.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_top">
-<li><a href="../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_top");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.top">
-<!--   -->
-</a></div>
-<!-- ========= END OF TOP NAVBAR ========= -->
-<div class="contentContainer"><a href="index-1.html">C</a>&nbsp;<a href="index-2.html">D</a>&nbsp;<a href="index-3.html">H</a>&nbsp;<a href="index-4.html">M</a>&nbsp;<a name="I:M">
-<!--   -->
-</a>
-<h2 class="title">M</h2>
-<dl>
-<dt><span class="memberNameLink"><a href="../com/ykl/Demo5.html#main-java.lang.String:A-">main(String[])</a></span> - 类 中的静态方法com.ykl.<a href="../com/ykl/Demo5.html" title="com.ykl中的类">Demo5</a></dt>
-<dd>&nbsp;</dd>
-<dt><span class="memberNameLink"><a href="../com/ykl/HelloWorld.html#main-java.lang.String:A-">main(String[])</a></span> - 类 中的静态方法com.ykl.<a href="../com/ykl/HelloWorld.html" title="com.ykl中的类">HelloWorld</a></dt>
-<dd>&nbsp;</dd>
-</dl>
-<a href="index-1.html">C</a>&nbsp;<a href="index-2.html">D</a>&nbsp;<a href="index-3.html">H</a>&nbsp;<a href="index-4.html">M</a>&nbsp;</div>
-<!-- ======= START OF BOTTOM NAVBAR ====== -->
-<div class="bottomNav"><a name="navbar.bottom">
-<!--   -->
-</a>
-<div class="skipNav"><a href="#skip.navbar.bottom" title="跳过导航链接">跳过导航链接</a></div>
-<a name="navbar.bottom.firstrow">
-<!--   -->
-</a>
-<ul class="navList" title="导航">
-<li><a href="../com/ykl/package-summary.html">程序包</a></li>
-<li>类</li>
-<li>使用</li>
-<li><a href="../overview-tree.html">树</a></li>
-<li><a href="../deprecated-list.html">已过时</a></li>
-<li class="navBarCell1Rev">索引</li>
-<li><a href="../help-doc.html">帮助</a></li>
-</ul>
-</div>
-<div class="subNav">
-<ul class="navList">
-<li><a href="index-3.html">上一个字母</a></li>
-<li>下一个字母</li>
-</ul>
-<ul class="navList">
-<li><a href="../index.html?index-files/index-4.html" target="_top">框架</a></li>
-<li><a href="index-4.html" target="_top">无框架</a></li>
-</ul>
-<ul class="navList" id="allclasses_navbar_bottom">
-<li><a href="../allclasses-noframe.html">所有类</a></li>
-</ul>
-<div>
-<script type="text/javascript"><!--
-  allClassesLink = document.getElementById("allclasses_navbar_bottom");
-  if(window==top) {
-    allClassesLink.style.display = "block";
-  }
-  else {
-    allClassesLink.style.display = "none";
-  }
-  //-->
-</script>
-</div>
-<a name="skip.navbar.bottom">
-<!--   -->
-</a></div>
-<!-- ======== END OF BOTTOM NAVBAR ======= -->
-</body>
-</html>
--- a/mac使用教程/mac使用教程.md
+++ b/mac使用教程/mac使用教程.md
@@ -0,0 +1,83 @@
+## 1 常用快捷键
+
+### 基本操作
+
+mac系统中的Command键在大多数情况下相当于Windows下的Ctrl键。
+
+* Command-Z 撤销。
+* Command-X 剪切。
+* Command-C 拷贝(Copy)。
+* Command-V 粘贴。
+* Command-A 全选(All)。
+* Command-S 保存(Save)。
+* Command-F 查找(Find)。
+
+∏
+### 截图：
+
+* Command-Shift-4 截取所选屏幕区域到一个文件。
+* Command-Shift-3 截取全部屏幕到文件。
+* Command-Shift-Control-3 截取全部屏幕到剪贴板。
+* Command-Shift-4 截取所选屏幕区域到一个文件，或按空格键仅捕捉一个窗口。
+* Command-Shift-Control-4 截取所选屏幕区域到剪贴板，或按空格键仅捕捉一个窗。
+
+Mac 自带屏幕截图 Command + Shift + 5
+
+### 应用程序
+
+* Command-Option-esc 打开强制退出窗口。
+* Command-H 隐藏(Hide)当前正在运行的应用程序窗口。
+* Command-Option-H 隐藏(Hide)其他应用程序窗口。
+* Command-Q 退出(Quit)最前面的应用程序。
+* Command-Shift-Z 重做，也就是撤销的逆向操作。
+* Command-Tab 在打开的应用程序列表中转到下一个最近使用的应用程序，相当于Windows中(Alt+Tab)。
+* Command-Option-esc 打开“强制退出”窗口，如果有应用程序无响应。可在窗口列表中选择强制退出。
+
+
+### 文本处理：
+
+　　Command-右箭头 将光标移至当前行的行尾。
+
+　　Command-B 切换所选文字粗体(Bold)显示。
+
+　　fn-Delete 相当于PC全尺寸键盘上的Delete，也就是向后删除。
+
+　　fn-上箭头 向上滚动一页(Page Up)。
+
+　　fn-下箭头 向下滚动一页(Page Down)。
+
+　　fn-左箭头 滚动至文稿开头(Home)。
+
+　　fn-右箭头 滚动至文稿末尾(End)。
+
+　　Command-右箭头 将光标移至当前行的行尾。
+
+　　Command-左箭头 将光标移至当前行的行首。
+
+　　Command-下箭头 将光标移至文稿末尾。
+
+　　Command-上箭头 将光标移至文稿开头。
+
+　　Option-右箭头 将光标移至下一个单词的末尾。
+
+　　Option-左箭头 将光标移至上一个单词的开头。
+
+　　Control-A 移至行或段落的开头。
+
+　　Command-F 查找（Find）
+
+
+### 浏览器中
+
+
+　　Control-Tab 转向下一个标签页　
+
+　　Command-L 光标直接跳至地址栏　
+
+　　Control-Tab 转向下一个标签页　　
+
+　　Control-Shift-Tab 转向上一个标签页　
+
+　　Command-加号或等号 放大页面　　
+
+　　Command-减号 缩小页面