【Java】Java基础

谁践踏了优雅 2023-10-15 11:28 13阅读 0赞

## 环境准备 ##

### 安装JDK和JRE ###

下载JDK，可以在官网[Java Downloads | Oracle 中国][Java Downloads _ Oracle]下载，但是这里需要注册才能够下载。在[Index of java-local/jdk (huaweicloud.com)][Index of java-local_jdk _huaweicloud.com]也可以下载到，但是版本比较老，关系不大，直接下载，对应jdk-8u202-windows-x64.exe，这个是JDK8版本，它是一个长期维护版本。

下载后安装：

![在这里插入图片描述][e6baabd7b3c14bdeb23f0a91e4347b6e.png_pic_center]

注意这里的JRE，它是Java程序执行的环境，会有额外安装：

![在这里插入图片描述][22bb34a7999a45c4937bc77d1a48916e.png_pic_center]

因为已经包含在下载包中，所以也不需要额外下载。

### 设置环境变量 ###

安装成功之后需要增加Java相关的环境变量。

1.  首先是新建一个环境变量JAVA\_HOME：

![在这里插入图片描述][476eb2e79d504f98af95452b2628a11d.png_pic_center]

1.  再将JDK和JRE的bin目录添加到PATH变量中：

![在这里插入图片描述][90fddbc5ab7a42b8b1929f3535c2b8ec.png_pic_center]

之后如果在PowerShell下可以使用java，就表示安装成功了，比如：

C:\Users\jiang>java
    用法: java [-options] class [args...]
               (执行类)
       或  java [-options] -jar jarfile [args...]
               (执行 jar 文件)
    其中选项包括:
        -d32          使用 32 位数据模型 (如果可用)
        -d64          使用 64 位数据模型 (如果可用)
        -server       选择 "server" VM
                      默认 VM 是 server.
    
        -cp <目录和 zip/jar 文件的类搜索路径>
        -classpath <目录和 zip/jar 文件的类搜索路径>
                      用 ; 分隔的目录, JAR 档案
                      和 ZIP 档案列表, 用于搜索类文件。
        -D<名称>=<值>
                      设置系统属性
        -verbose:[class|gc|jni]
                      启用详细输出
        -version      输出产品版本并退出
        -version:<值>
                      警告: 此功能已过时, 将在
                      未来发行版中删除。
                      需要指定的版本才能运行
        -showversion  输出产品版本并继续
        -jre-restrict-search | -no-jre-restrict-search
                      警告: 此功能已过时, 将在
                      未来发行版中删除。
                      在版本搜索中包括/排除用户专用 JRE
        -? -help      输出此帮助消息
        -X            输出非标准选项的帮助
        -ea[:<packagename>...|:<classname>]
        -enableassertions[:<packagename>...|:<classname>]
                      按指定的粒度启用断言
        -da[:<packagename>...|:<classname>]
        -disableassertions[:<packagename>...|:<classname>]
                      禁用具有指定粒度的断言
        -esa | -enablesystemassertions
                      启用系统断言
        -dsa | -disablesystemassertions
                      禁用系统断言
        -agentlib:<libname>[=<选项>]
                      加载本机代理库 <libname>, 例如 -agentlib:hprof
                      另请参阅 -agentlib:jdwp=help 和 -agentlib:hprof=help
        -agentpath:<pathname>[=<选项>]
                      按完整路径名加载本机代理库
        -javaagent:<jarpath>[=<选项>]
                      加载 Java 编程语言代理, 请参阅 java.lang.instrument
        -splash:<imagepath>
                      使用指定的图像显示启动屏幕
    有关详细信息, 请参阅 http://www.oracle.com/technetwork/java/javase/documentation/index.html。
    
    C:\Users\jiang>java -version
    java version "1.8.0_202"
    Java(TM) SE Runtime Environment (build 1.8.0_202-b08)
    Java HotSpot(TM) 64-Bit Server VM (build 25.202-b08, mixed mode)

### 安装IDE ###

开发Java常用的IDE有Eclipse和IntelliJ IDEA，这里使用IntelliJ IDEA，它的Community版是免费的，界面如下：

![在这里插入图片描述][6caa7c323a9540d193604ca542d0ebdc.png_pic_center]

创建Java项目：

![在这里插入图片描述][476cb87878f245719c127fe3d32a3d1e.png_pic_center]

示例代码：

![在这里插入图片描述][4f07dc8af4924cf8ac7ba2d3ba52a3aa.png_pic_center]

到这里Java的基本环境已经安装完毕。

## Java基础 ##

### Java主类结构 ###

Java程序的基本组成单元是类。

每一个应用程序都必须要包含一个`main()`方法，含有`main()`方法的类称为主类。

一个Java程序有若干个类组成。

通过`package`关键字声明类所在的包，通过`import`关键字引入该包包含的类。

下面的代码声明了一个包，该包中包含一个类：

package LearnJava;
    
    public class BasicDataType {
        
        public void test() {
        
            System.out.print(new BasicDataType());
        }
    }

下面的代码包含并使用了上述类：

import LearnJava.BasicDataType;
    
    public class Main {
        
        public static void main(String[] args) {
        
            // 基本数据类型测试
            BasicDataType myBasicDataType = new BasicDataType();
            myBasicDataType.test();
        }
    }

`public`、`static`、`void`分别是**权限修饰符**、**静态修饰符**和**返回值修饰符**。

### 基本数据类型 ###

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ymhpetO7-1693156098722)(Java.assets/基本数据类型.svg)\]

Java没有区分正负的数值型，它们本身包含正负。

下面是一个示例：

package LearnJava;
    
    public class BasicDataType {
        
        public byte byteValue = 0;
        public short shortValue = -1;
        public int intValue = 2;
        public long longValue = 3;
        public char charValue = 'a';
        public float floatValue = 1.1F; // 不加F会告警
        public double doubleValue = -1.2;
        public boolean booleanValue = true;
    
        public void test() {
        
            System.out.println(new BasicDataType());
            System.out.println(byteValue);
            System.out.println(shortValue);
            System.out.println(intValue);
            System.out.println(longValue);
            System.out.println(charValue);
            System.out.println(floatValue);
            System.out.println(doubleValue);
            System.out.println(booleanValue);
        }
    }

### 变量和常量 ###

Java语言严格区分大小写。

Java语言规定标识符有任意顺序的字母、下划线（`_`）、美元符号（`$`）和数字组成，并且第一个字符不能是数字。

Java关键字：

<table> 
 <thead> 
  <tr> 
   <th align="left">关键字</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>abstract</code></td> 
   <td align="left">非访问修饰符。用于类和方法：抽象类不能用于创建对象（要访问它，必须从另一个类继承）。抽象方法只能在抽象类中使用，并且它没有主体。主体由子类（继承自）提供。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>assert</code></td> 
   <td align="left">用于调试。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>boolean</code></td> 
   <td align="left">只能存储真值和假值的数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>break</code></td> 
   <td align="left">从循环或<code>switch</code>块中断开。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>byte</code></td> 
   <td align="left">可以存储-128和127之间的整数的数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>case</code></td> 
   <td align="left">在<code>switch</code>语句中标记代码块。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>catch</code></td> 
   <td align="left">捕获由<code>try</code>语句生成的异常。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>char</code></td> 
   <td align="left">用于存储单个字符的数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>class</code></td> 
   <td align="left">定义一个类。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>continue</code></td> 
   <td align="left">继续到循环的下一个迭代。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>const</code></td> 
   <td align="left">定义一个常量。不再使用，改用<code>final</code>。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>default</code></td> 
   <td align="left">指定<code>switch</code>语句中的默认代码块。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>do</code></td> 
   <td align="left">与<code>while</code>一起使用以创建do-while循环。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>double</code></td> 
   <td align="left">可以存储1.7e−308 到 1.7e+308。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>else</code></td> 
   <td align="left">用于条件语句中。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>enum</code></td> 
   <td align="left">声明枚举（不可更改）类型。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>exports</code></td> 
   <td align="left">导出包含模块的包。Java9中的新特性。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>extends</code></td> 
   <td align="left">扩展类（表示一个类是从另一个类继承的）。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>final</code></td> 
   <td align="left">用于类、属性和方法的非访问修饰符，使它们不可更改（无法继承或重写）。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>finally</code></td> 
   <td align="left">与异常一起使用，无论是否存在异常都将执行的代码块。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>float</code></td> 
   <td align="left">可以存储3.4e−038 到 3.4e+038。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>for</code></td> 
   <td align="left">创建for循环。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>goto</code></td> 
   <td align="left">不在使用中，没有任何功能。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>if</code></td> 
   <td align="left">一个条件语句。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>implements</code></td> 
   <td align="left">实现一个接口。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>import</code></td> 
   <td align="left">用于导入包、类或接口。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>instanceof</code></td> 
   <td align="left">检查对象是特定类的实例还是接口的实例。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>int</code></td> 
   <td align="left">可以存储从-2147483648到2147483647的整数的数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>interface</code></td> 
   <td align="left">用于声明仅包含抽象方法的特殊类型的类。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>long</code></td> 
   <td align="left">可以存储从-9223372036854775808到9223372036854775808的整数的数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>module</code></td> 
   <td align="left">声明一个模块。Java9中的新特性。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>native</code></td> 
   <td align="left">指定方法不是在同一Java源文件中实现的（而是在另一种语言中实现的）。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>new</code></td> 
   <td align="left">创建新对象。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>package</code></td> 
   <td align="left">声明一个包。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>private</code></td> 
   <td align="left">用于属性、方法和构造函数的访问修饰符，使它们只能在声明的类中访问。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>protected</code></td> 
   <td align="left">用于属性、方法和构造函数的访问修饰符，使它们可以在同一个包和子类中访问。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>public</code></td> 
   <td align="left">用于类、属性、方法和构造函数的访问修饰符，使它们可以被任何其他类访问。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>requires</code></td> 
   <td align="left">指定模块内所需的库。Java9中的新特性。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>return</code></td> 
   <td align="left">已完成方法的执行，并可用于从方法返回值。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>short</code></td> 
   <td align="left">可以存储从-32768到32767的整数的数据类型。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>static</code></td> 
   <td align="left">用于方法和属性的非访问修饰符。无需创建类的对象即可访问静态方法/属性。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>strictfp</code></td> 
   <td align="left">限制浮点计算的精度和舍入。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>super</code></td> 
   <td align="left">指超类（父）对象。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>switch</code></td> 
   <td align="left">选择要执行的多个代码块之一。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>synchronized</code></td> 
   <td align="left">非访问修饰符，指定一次只能由一个线程访问方法。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>this</code></td> 
   <td align="left">指方法或构造函数中的当前对象。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>throw</code></td> 
   <td align="left">创建自定义错误。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>throws</code></td> 
   <td align="left">指示方法可能引发的异常。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>transient</code></td> 
   <td align="left">非访问修饰符，指定属性不是对象持久状态的一部分。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>try</code></td> 
   <td align="left">创建try…catch语句。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>var</code></td> 
   <td align="left">声明一个变量。Java10中的新特性。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>void</code></td> 
   <td align="left">指定方法不应具有返回值。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>volatile</code></td> 
   <td align="left">指示属性不是本地缓存的线程，并且总是从“主内存”中读取。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>while</code></td> 
   <td align="left">创建while循环。</td> 
  </tr> 
 </tbody> 
</table>

常量也被称为“final变量”，再整个程序中只能被赋值一次。

在Java语言中声明一个常量，除了要指定数据类型，还需要通过`final`关键字进行限定。

常量名通常使用大写字母，但这并不是必须的。

final double PI = 3.1425926;

在为所有的对象共享值时，常量是非常有用的。

根据变量的有效返回，变量可以分为：

*  **成员变量**：在类体中声明的变量被称为成员变量，成员变量在整个类中都有效。类中的成员变量又分为两类：**静态变量**和**实例变量**。
 *  **局部变量**：在类的方法体中声明的变量称为局部变量。

### 运算符 ###

算数运算符：

<table> 
 <thead> 
  <tr> 
   <th align="left">运算符</th> 
   <th align="left">名称</th> 
   <th align="left">描述</th> 
   <th align="left">实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>+</code></td> 
   <td align="left">加法</td> 
   <td align="left">将两个值相加。</td> 
   <td align="left">x + y</td> 
  </tr> 
  <tr> 
   <td align="left"><code>-</code></td> 
   <td align="left">减法</td> 
   <td align="left">从一个值减去另一个值。</td> 
   <td align="left">x - y</td> 
  </tr> 
  <tr> 
   <td align="left"><code>*</code></td> 
   <td align="left">乘法</td> 
   <td align="left">将两个值相乘。</td> 
   <td align="left">x * y</td> 
  </tr> 
  <tr> 
   <td align="left"><code>/</code></td> 
   <td align="left">除法</td> 
   <td align="left">分子除以分母。</td> 
   <td align="left">x / y</td> 
  </tr> 
  <tr> 
   <td align="left"><code>%</code></td> 
   <td align="left">取模</td> 
   <td align="left">取模运算符，整除后的余数。</td> 
   <td align="left">x % y</td> 
  </tr> 
  <tr> 
   <td align="left"><code>++</code></td> 
   <td align="left">自增</td> 
   <td align="left">自增运算符，整数值增加 1。</td> 
   <td align="left">++x</td> 
  </tr> 
  <tr> 
   <td align="left"><code>--</code></td> 
   <td align="left">自减</td> 
   <td align="left">自减运算符，整数值减少 1。</td> 
   <td align="left">–x</td> 
  </tr> 
 </tbody> 
</table>

赋值运算法：

关系运算符：

<table> 
 <thead> 
  <tr> 
   <th align="left">运算符</th> 
   <th align="left">名称</th> 
   <th align="left">实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>==</code></td> 
   <td align="left">等于</td> 
   <td align="left">x == y</td> 
  </tr> 
  <tr> 
   <td align="left"><code>!=</code></td> 
   <td align="left">不等于</td> 
   <td align="left">x != y</td> 
  </tr> 
  <tr> 
   <td align="left"><code>&gt;</code></td> 
   <td align="left">大于</td> 
   <td align="left">x &gt; y</td> 
  </tr> 
  <tr> 
   <td align="left"><code>&lt;</code></td> 
   <td align="left">小于</td> 
   <td align="left">x &lt; y</td> 
  </tr> 
  <tr> 
   <td align="left"><code>&gt;=</code></td> 
   <td align="left">大于或等于</td> 
   <td align="left">x &gt;= y</td> 
  </tr> 
  <tr> 
   <td align="left"><code>&lt;=</code></td> 
   <td align="left">小于或等于</td> 
   <td align="left">x &lt;= y</td> 
  </tr> 
 </tbody> 
</table>

逻辑运算符：

<table> 
 <thead> 
  <tr> 
   <th align="left">运算符</th> 
   <th align="left">名称</th> 
   <th align="left">描述</th> 
   <th align="left">实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>&amp;&amp;</code></td> 
   <td align="left">逻辑与</td> 
   <td align="left">如果两个语句都为<code>true</code>，则返回<code>true</code>。</td> 
   <td align="left">x &lt; 5 &amp;&amp; x &lt; 10</td> 
  </tr> 
  <tr> 
   <td align="left"><code>||</code></td> 
   <td align="left">逻辑或</td> 
   <td align="left">如果其中一条语句为<code>true</code>，则返回<code>true</code>。</td> 
   <td align="left">x &lt; 5 || x &lt; 4</td> 
  </tr> 
  <tr> 
   <td align="left"><code>!</code></td> 
   <td align="left">逻辑非</td> 
   <td align="left">反转结果，如果结果为真则返回<code>false</code>。</td> 
   <td align="left">!(x &lt; 5 &amp;&amp; x &lt; 10)</td> 
  </tr> 
 </tbody> 
</table>

位运算符：

<table> 
 <thead> 
  <tr> 
   <th align="left">运算符</th> 
   <th align="left">描述</th> 
   <th align="left">例子</th> 
   <th align="left">等同于</th> 
   <th align="left">结果</th> 
   <th align="left">十进制</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>&amp;</code></td> 
   <td align="left">AND - 如果两个位都为1，则将每个位设置为1。</td> 
   <td align="left">5 &amp; 1</td> 
   <td align="left">0101 &amp; 0001</td> 
   <td align="left">0001</td> 
   <td align="left">1</td> 
  </tr> 
  <tr> 
   <td align="left"><code>|</code></td> 
   <td align="left">OR - 如果两个位中的任何一个为1，则将每个位设置为1。</td> 
   <td align="left">5 | 1</td> 
   <td align="left">0101 | 0001</td> 
   <td align="left">0101</td> 
   <td align="left">5</td> 
  </tr> 
  <tr> 
   <td align="left"><code>~</code></td> 
   <td align="left">NOT - 反转所有位。</td> 
   <td align="left">~ 5</td> 
   <td align="left">~0101</td> 
   <td align="left">1010</td> 
   <td align="left">10</td> 
  </tr> 
  <tr> 
   <td align="left"><code>^</code></td> 
   <td align="left">XOR - 如果两个位中只有一个为1，则将每个位设置为1。</td> 
   <td align="left">5 ^ 1</td> 
   <td align="left">0101 ^ 0001</td> 
   <td align="left">0100</td> 
   <td align="left">4</td> 
  </tr> 
  <tr> 
   <td align="left"><code>&lt;&lt;</code></td> 
   <td align="left">Zero-fill left shift - 通过从右侧推入零并让最左边的位脱落来向左移动。</td> 
   <td align="left">9 &lt;&lt; 1</td> 
   <td align="left">1001 &lt;&lt; 1</td> 
   <td align="left">0010</td> 
   <td align="left">2</td> 
  </tr> 
  <tr> 
   <td align="left"><code>&gt;&gt;</code></td> 
   <td align="left">Signed right shift - 通过从左侧推入最左侧位的副本并让最右侧位脱落来右移。</td> 
   <td align="left">9 &gt;&gt; 1</td> 
   <td align="left">1001 &gt;&gt; 1</td> 
   <td align="left">1100</td> 
   <td align="left">12</td> 
  </tr> 
  <tr> 
   <td align="left"><code>&gt;&gt;&gt;</code></td> 
   <td align="left">Zero-fill right shift - 通过从左边推入零并让最右边的位脱落来右移。</td> 
   <td align="left">9 &gt;&gt;&gt; 1</td> 
   <td align="left">1001 &gt;&gt;&gt; 1</td> 
   <td align="left">0100</td> 
   <td align="left">4</td> 
  </tr> 
 </tbody> 
</table>

还有三元运算符`?:`也支持。

### 代码注释和编码规范 ###

代码注释说明：

// 单行注释
    
    /*
    	多行
    	注释
    */
    
    /**
    	文档注释
    	注意上面有两个**
    */

一些编码规范：

1.  package语句要写在类文件的第一行。如果类不在任何包中，可以不写package语句。
2.  import语句写在类的上方，package语句下方。

### 流程控制 ###

if语句：

if () {
        
        
    } else if {
        } {
        
        
    } else {
        
        
    }

switch语句：

switch () {
        
        case x:
            break;
        case y:
            break;
        default:
            break;
    }

循环语句：

while () {
        
        
    }
    
    do {
        
        
    } while ();
        
    for (x; y; z) {
        
        
    }
    
    for (i : a) {
        
        
    }

控制语句：

break;
    continue;

### 数组 ###

*  声明一维数组：

int[] arr1;
    // int arr2[];

第二种会在IDE中报告警：

Local variable 'arr2' has C-style array type declaration

所以还是建议使用`数据类型[]`的方式。

*  一维数组赋值：

public void testArray() {
        
        int[] arr1;
        arr1 = new int[5];
        for (int j : arr1) {
        
            System.out.println(j);
        }
    }

*  声明的同时为一维数组分配内存：

int[] arr1 = new int[5];

*  初始化一维数组：

int[] arr1 = new int[] {
        1, 2, 3, 4, 5};
    int[] arr2 = {
        10, 20, 30};

*  二维数组可以看做是特殊的一维数组。

int[][] arr3 = new int[2][4];

2是行数，4是列数：

![在这里插入图片描述][b1bf51f051034f72930d36f09421f362.png_pic_center]

*  二维数组的初始化：

int[][] arr4 = new int[][] {
        {
        1, 2, 3, 4}, {
        5, 6, 7, 8}};

arr3和arr4是等价的，但是不能直接写`new int[2][4]`，会报错。

这样写更能看出行列关系：

int[][] arr3 = new int[][] {
        
        {
        1, 2, 3, 4},
        {
        5, 6, 7, 8}
    };

#### 数组的基本操作 ####

*  遍历：

int[][] arr3 = new int[][] {
        
        {
        1, 2, 3, 4},
        {
        5, 6, 7, 8}
    };
    for (int[] j : arr3) {
        
        for (int i : j) {
        
            System.out.println(i);
        }
    }

foreach的方式很好用。

*  填充：

int[] arr2 = new int[3];
    
    Arrays.fill(arr2, 1);
    for (int i : arr2) {
        
        System.out.println(i);
    }

为了使用`fill()`，需要导入对应的类：

import java.util.Arrays;

这里通过`fill()`为数组填充了同一个值。

还可以指定范围填充：

Arrays.fill(arr2, 0, 1, 10);

0表示起始位置，1表示结束位置（但该位置不在填充范围内），10表示需要填充的值。

*  排序：

int[] arr1 = new int[] {
        10, 2, 1, 4, 5};
    Arrays.sort(arr1);
    for (int i : arr1) {
        
        System.out.println(i);
    }

*  复制数组：

int[] arr1 = new int[] {
        10, 2, 1, 4, 5};
    int[] arr2 = Arrays.copyOf(arr1, 10);
    for (int i : arr2) {
        
        System.out.println(i);
    }

如果复制的值超过了原有的数组，则用0填充。

也有一个范围的版本：

int[] arr1 = new int[] {
        10, 2, 1, 4, 5};
    int[] arr2 = Arrays.copyOfRange(arr1, 1, 2);
    for (int i : arr2) {
        
        System.out.println(i);
    }

通用结束的索引没有包含在内，所以上例中只复制一个值。

*  查询：

int[] arr1 = new int[] {
        10, 2, 1, 4, 5};
    System.out.println(Arrays.binarySearch(arr1, 1));
    System.out.println(Arrays.binarySearch(arr1, 0, arr1.length, 1));

返回的是索引值，同样可以指定范围。上例的返回值是2。

### 类和对象 ###

面向对象的特性：

*  封装。
 *  继承。
 *  多态。

类示例：

package LearnJava;
    
    public class Book {
        
        private String name;
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    }

**修饰符权限**：

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>private</th> 
   <th>protected</th> 
   <th>public</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>本类</td> 
   <td>可见</td> 
   <td>可见</td> 
   <td>可见</td> 
  </tr> 
  <tr> 
   <td>同包其它类或子类</td> 
   <td>不可见</td> 
   <td>可见</td> 
   <td>可见</td> 
  </tr> 
  <tr> 
   <td>其它包的类或子类</td> 
   <td>不可见</td> 
   <td>不可见</td> 
   <td>可见</td> 
  </tr> 
 </tbody> 
</table>

如果没有显式指定权限修饰符，则预设为包存取范围，即只有一个包中的类可以访问。

`this`关键字用于表示本类当前的对象，当前对象不是某个`new`出来的实体对象，而是当前正在编辑的类。`this`关键字只能在本类中使用。

构造函数：

public Book() {
        
        this.name = "Unspecific";
    }
    public Book(String name) {
        
        this.name = name;
    }

如果类中没有定义构造方法，则会自动创建一个无参数的构造方法；如果已经有构造函数了，且都是带参数的，则不会有无参数的构造方法。

这里定义了两个构造函数，实际是中**方法重载**，即方法名相同，但是参数不同。

`static`定义类的静态变量或静态方法，它们在所有的实例中共享。静态成员同样有修饰符约束。

静态成员在类中可以不用`this`：

package LearnJava;
    
    public class Book {
        
        private String name;
        public static int count = 0;
    
        public Book() {
        
            this.name = "Unspecific";
            count++;
        }
        public Book(String name) {
        
            this.name = name;
            count++;
        }
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public void showBook() {
        
            System.out.format("Total count: %d\n", count);
            System.out.println(this.name);
        }
    }

类的使用：

Book book1 = new Book();
    Book book2 = new Book("Learning Java");
    book1.showBook();
    book2.showBook();

### Object类 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">ID</th> 
   <th align="left">方法描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><code>protected Object clone();</code><br>创建并返回一个对象的拷贝。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><code>boolean equals(Object obj);</code><br>比较两个对象是否相等。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><code>protected void finalize();</code><br>当 GC (垃圾回收器)确定不存在对该对象的有更多引用时，由对象的垃圾回收器调用此方法。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><code>Class getClass();</code><br>获取对象的运行时对象的类。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><code>int hashCode();</code><br>获取对象的hash值。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><code>void notify();</code><br>唤醒在该对象上等待的某个线程。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><code>void notifyAll();</code><br>唤醒在该对象上等待的所有线程。</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left">String toString();<br>返回对象的字符串表示形式。</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><code>void wait();</code><br>让当前线程进入等待状态。直到其他线程调用此对象的notify()方法或notifyAll()方法。</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><code>void wait(long timeout);</code><br>让当前线程处于等待(阻塞)状态，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者超过参数设置的<code>timeout</code>超时时间。</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left"><code>void wait(long timeout, int nanos);</code><br>与<code>wait(long timeout)</code>方法类似，多了一个<code>nanos</code>参数，这个参数表示额外时间（以纳秒为单位，范围是 0-999999），所以超时的时间还需要加上 <code>nanos</code>纳秒。</td> 
  </tr> 
 </tbody> 
</table>

### 继承和多态 ###

继承：

package LearnJava;
    
    public class FictionBook extends Book {
        
        public FictionBook(String name) {
        
            super(name);
            System.out.println("FictionBook(String)");  // 这句要在上句下面，否则会报错
        }
    }

`super`指向父类，这里是父类的构造函数。

使用：

Book book = new FictionBook("The Three-Body Problem");
    book.showBook();

这里有一个向上转型，即子类对象转换成父类对象。

子类可以直接使用父类的函数。

多态是通过父类可以对它以及其子类都可以进行通用操作（其中也包含了向上转型）：

public static void checkBook(Book book) {
        
        if (book instanceof FictionBook) {
        
            System.out.println("This is a fiction book");
        } else if (book instanceof ReferenceBook) {
        
            System.out.println("This is a reference book");
        } else {
        
            System.out.println("This is a normal book");
        }
    }
    
    Book book1 = new FictionBook("The Three-Body Problem");
    Book book2 = new ReferenceBook("XinHua Dictionary");
    checkBook(book1);
    checkBook(book2);

这里使用了`instanceof`关键字，可以用来判断对象的类型。

前面介绍过final变量，还有：

*  final方法：防止子类修改父类的定义与实现方式，同时提高执行效率。
 *  final类：不能被继承。

Java只支持单继承。

### 抽象类与接口 ###

抽象类使用`abstract`关键字定义。

抽象类不可实例化。

通过`abstract`关键字还可以定义抽象方法，该方法没有方法体，本身没有任何意义，必须要被重写（可以被它的直接子类重写，也可以被其子类的子类重写）。当然抽象类中也可以有正常的方法。

接口是纯粹的抽象类，所有方法都没有方法体。

使用`interface`关键字定义接口。

接口中方法必须要是public或abstract形式的，否则没有意义。

接口中定义的任何字段都默认是static和final的。

### 内部类 ###

在一个类中使用内部类，可以在内部类中直接存起其所在类的私有成员变量。

package LearnJava;
    
    public class OuterClass {
        
        private int x = 1;
    
        public class InnerClass {
        
            private int x = 11;
    
            public void show() {
        
                System.out.format("Inner int: %d\n", this.x);	// 只用内部类（就是它自己）的成员变量
                System.out.format("Outer int: %d\n", OuterClass.this.x);	// 使用外部类的成员变量
            }
        }
    
        public void show() {
        
            InnerClass inner = new InnerClass();
            inner.show();
        }
    }

内部类的使用：

OuterClass out = new OuterClass();
    OuterClass.InnerClass inner = out.new InnerClass(); // 内部类依赖于外部类的方法，所以必须要用out.new
    out.show();
    inner.show();

匿名类是只在创建对象时才会编写类体的一种方法。

匿名类的特点是“现用现写”。比如有一个抽象类：

package LearnJava;
    
    public abstract class AnimalClass {
        
        String name;
        public abstract void sound();
    }

这里临时使用：

AnimalClass dog = new AnimalClass() {
        
        @Override
        public void sound() {
        
            System.out.println("Wang ~ Wang ~");
        }
    };
    dog.sound();

### 异常 ###

try-catch-finally语句块用于捕捉异常：

try {
        
        int a = 10 / 0;
    }
    catch (Exception e) {
        
        e.printStackTrace();
    }
    finally {
        
        System.out.println("Always be here");   // 无论是否异常都会执行
    }

### 字符串 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">ID</th> 
   <th align="left">方法描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left"><code>char charAt(int index)</code><br>返回指定索引处的 char 值。</td> 
  </tr> 
  <tr> 
   <td align="left">2</td> 
   <td align="left"><code>int compareTo(Object o)</code><br>把这个字符串和另一个对象比较。</td> 
  </tr> 
  <tr> 
   <td align="left">3</td> 
   <td align="left"><code>int compareTo(String anotherString)</code><br>按字典顺序比较两个字符串。</td> 
  </tr> 
  <tr> 
   <td align="left">4</td> 
   <td align="left"><code>int compareToIgnoreCase(String str)</code><br>按字典顺序比较两个字符串，不考虑大小写。</td> 
  </tr> 
  <tr> 
   <td align="left">5</td> 
   <td align="left"><code>String concat(String str)</code><br>将指定字符串连接到此字符串的结尾。</td> 
  </tr> 
  <tr> 
   <td align="left">6</td> 
   <td align="left"><code>boolean contentEquals(StringBuffer sb)</code><br>当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。</td> 
  </tr> 
  <tr> 
   <td align="left">7</td> 
   <td align="left"><code>static String copyValueOf(char[] data)</code><br>返回指定数组中表示该字符序列的String。</td> 
  </tr> 
  <tr> 
   <td align="left">8</td> 
   <td align="left"><code>static String copyValueOf(char[] data, int offset, int count)</code><br>返回指定数组中表示该字符序列的String。</td> 
  </tr> 
  <tr> 
   <td align="left">9</td> 
   <td align="left"><code>boolean endsWith(String suffix)</code><br>测试此字符串是否以指定的后缀结束。</td> 
  </tr> 
  <tr> 
   <td align="left">10</td> 
   <td align="left"><code>boolean equals(Object anObject)</code><br>将此字符串与指定的对象比较。</td> 
  </tr> 
  <tr> 
   <td align="left">11</td> 
   <td align="left"><code>boolean equalsIgnoreCase(String anotherString)</code><br>将此String与另一个String比较，不考虑大小写。</td> 
  </tr> 
  <tr> 
   <td align="left">12</td> 
   <td align="left"><code>byte[] getBytes()</code><br>使用平台的默认字符集将此String编码为byte序列，并将结果存储到一个新的byte数组中。</td> 
  </tr> 
  <tr> 
   <td align="left">13</td> 
   <td align="left"><code>byte[] getBytes(String charsetName)</code><br>使用指定的字符集将此String编码为byte序列，并将结果存储到一个新的byte数组中。</td> 
  </tr> 
  <tr> 
   <td align="left">14</td> 
   <td align="left"><code>void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)</code><br>将字符从此字符串复制到目标字符数组。</td> 
  </tr> 
  <tr> 
   <td align="left">15</td> 
   <td align="left"><code>int hashCode()</code><br>返回此字符串的哈希码。</td> 
  </tr> 
  <tr> 
   <td align="left">16</td> 
   <td align="left"><code>int indexOf(int ch)</code><br>返回指定字符在此字符串中第一次出现处的索引。</td> 
  </tr> 
  <tr> 
   <td align="left">17</td> 
   <td align="left"><code>int indexOf(int ch, int fromIndex)</code><br>返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。</td> 
  </tr> 
  <tr> 
   <td align="left">18</td> 
   <td align="left"><code>int indexOf(String str)</code><br>返回指定子字符串在此字符串中第一次出现处的索引。</td> 
  </tr> 
  <tr> 
   <td align="left">19</td> 
   <td align="left"><code>int indexOf(String str, int fromIndex)</code><br>返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。</td> 
  </tr> 
  <tr> 
   <td align="left">20</td> 
   <td align="left"><code>String intern()</code><br>返回字符串对象的规范化表示形式。</td> 
  </tr> 
  <tr> 
   <td align="left">21</td> 
   <td align="left"><code>int lastIndexOf(int ch)</code><br>返回指定字符在此字符串中最后一次出现处的索引。</td> 
  </tr> 
  <tr> 
   <td align="left">22</td> 
   <td align="left"><code>int lastIndexOf(int ch, int fromIndex)</code><br>返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。</td> 
  </tr> 
  <tr> 
   <td align="left">23</td> 
   <td align="left"><code>int lastIndexOf(String str)</code><br>返回指定子字符串在此字符串中最右边出现处的索引。</td> 
  </tr> 
  <tr> 
   <td align="left">24</td> 
   <td align="left"><code>int lastIndexOf(String str, int fromIndex)</code><br>返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。</td> 
  </tr> 
  <tr> 
   <td align="left">25</td> 
   <td align="left"><code>int length()</code><br>返回此字符串的长度。</td> 
  </tr> 
  <tr> 
   <td align="left">26</td> 
   <td align="left"><code>boolean matches(String regex)</code><br>告知此字符串是否匹配给定的正则表达式。</td> 
  </tr> 
  <tr> 
   <td align="left">27</td> 
   <td align="left"><code>boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)</code><br>测试两个字符串区域是否相等。</td> 
  </tr> 
  <tr> 
   <td align="left">28</td> 
   <td align="left"><code>boolean regionMatches(int toffset, String other, int ooffset, int len)</code><br>测试两个字符串区域是否相等。</td> 
  </tr> 
  <tr> 
   <td align="left">29</td> 
   <td align="left"><code>String replace(char oldChar, char newChar)</code><br>返回一个新的字符串，它是通过用newChar替换此字符串中出现的所有oldChar得到的。</td> 
  </tr> 
  <tr> 
   <td align="left">30</td> 
   <td align="left"><code>String replaceAll(String regex, String replacement)</code><br>使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串。</td> 
  </tr> 
  <tr> 
   <td align="left">31</td> 
   <td align="left"><code>String replaceFirst(String regex, String replacement)</code><br>使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串。</td> 
  </tr> 
  <tr> 
   <td align="left">32</td> 
   <td align="left"><code>String[] split(String regex)</code><br>根据给定正则表达式的匹配拆分此字符串。</td> 
  </tr> 
  <tr> 
   <td align="left">33</td> 
   <td align="left"><code>String[] split(String regex, int limit)</code><br>根据匹配给定的正则表达式来拆分此字符串。</td> 
  </tr> 
  <tr> 
   <td align="left">34</td> 
   <td align="left"><code>boolean startsWith(String prefix)</code><br>测试此字符串是否以指定的前缀开始。</td> 
  </tr> 
  <tr> 
   <td align="left">35</td> 
   <td align="left"><code>boolean startsWith(String prefix, int toffset)</code><br>测试此字符串从指定索引开始的子字符串是否以指定前缀开始。</td> 
  </tr> 
  <tr> 
   <td align="left">36</td> 
   <td align="left"><code>CharSequence subSequence(int beginIndex, int endIndex)</code><br>返回一个新的字符序列，它是此序列的一个子序列。</td> 
  </tr> 
  <tr> 
   <td align="left">37</td> 
   <td align="left"><code>String substring(int beginIndex)</code><br>返回一个新的字符串，它是此字符串的一个子字符串。</td> 
  </tr> 
  <tr> 
   <td align="left">38</td> 
   <td align="left"><code>String substring(int beginIndex, int endIndex)</code><br>返回一个新字符串，它是此字符串的一个子字符串。</td> 
  </tr> 
  <tr> 
   <td align="left">39</td> 
   <td align="left"><code>char[] toCharArray()</code><br>将此字符串转换为一个新的字符数组。</td> 
  </tr> 
  <tr> 
   <td align="left">40</td> 
   <td align="left"><code>String toLowerCase()</code><br>使用默认语言环境的规则将此String中的所有字符都转换为小写。</td> 
  </tr> 
  <tr> 
   <td align="left">41</td> 
   <td align="left"><code>String toLowerCase(Locale locale)</code><br>使用给定Locale的规则将此String中的所有字符都转换为小写。</td> 
  </tr> 
  <tr> 
   <td align="left">42</td> 
   <td align="left"><code>String toString()</code><br>返回此对象本身（它已经是一个字符串）。</td> 
  </tr> 
  <tr> 
   <td align="left">43</td> 
   <td align="left"><code>String toUpperCase()</code><br>使用默认语言环境的规则将此String中的所有字符都转换为大写。</td> 
  </tr> 
  <tr> 
   <td align="left">44</td> 
   <td align="left"><code>String toUpperCase(Locale locale)</code><br>使用给定Locale的规则将此String中的所有字符都转换为大写。</td> 
  </tr> 
  <tr> 
   <td align="left">45</td> 
   <td align="left"><code>String trim()</code><br>返回字符串的副本，忽略前导空白和尾部空白。</td> 
  </tr> 
  <tr> 
   <td align="left">46</td> 
   <td align="left"><code>static String valueOf(primitive data type x)</code><br>返回给定data type类型x参数的字符串表示形式。</td> 
  </tr> 
  <tr> 
   <td align="left">47</td> 
   <td align="left"><code>contains(CharSequence chars)</code><br>判断是否包含指定的字符系列。</td> 
  </tr> 
  <tr> 
   <td align="left">48</td> 
   <td align="left"><code>isEmpty()</code><br>判断字符串是否为空。</td> 
  </tr> 
 </tbody> 
</table>

[Java Downloads _ Oracle]: https://www.oracle.com/cn/java/technologies/downloads/
[Index of java-local_jdk _huaweicloud.com]: https://repo.huaweicloud.com/java/jdk/
[e6baabd7b3c14bdeb23f0a91e4347b6e.png_pic_center]: https://img-blog.csdnimg.cn/e6baabd7b3c14bdeb23f0a91e4347b6e.png#pic_center
[22bb34a7999a45c4937bc77d1a48916e.png_pic_center]: https://img-blog.csdnimg.cn/22bb34a7999a45c4937bc77d1a48916e.png#pic_center
[476eb2e79d504f98af95452b2628a11d.png_pic_center]: https://img-blog.csdnimg.cn/476eb2e79d504f98af95452b2628a11d.png#pic_center
[90fddbc5ab7a42b8b1929f3535c2b8ec.png_pic_center]: https://img-blog.csdnimg.cn/90fddbc5ab7a42b8b1929f3535c2b8ec.png#pic_center
[6caa7c323a9540d193604ca542d0ebdc.png_pic_center]: https://img-blog.csdnimg.cn/6caa7c323a9540d193604ca542d0ebdc.png#pic_center
[476cb87878f245719c127fe3d32a3d1e.png_pic_center]: https://img-blog.csdnimg.cn/476cb87878f245719c127fe3d32a3d1e.png#pic_center
[4f07dc8af4924cf8ac7ba2d3ba52a3aa.png_pic_center]: https://img-blog.csdnimg.cn/4f07dc8af4924cf8ac7ba2d3ba52a3aa.png#pic_center
[b1bf51f051034f72930d36f09421f362.png_pic_center]: https://img-blog.csdnimg.cn/b1bf51f051034f72930d36f09421f362.png#pic_center