java基础——专题一《面向对象之前需要掌握的知识》

Δ前言

一、拾枝杂谈

1.Java是什么？

2.计组前瞻：

3.JDK，JRE，JVM？

二、环境搭建

1.JDK安装和配置：

1.1 人话

1.2 JDK的配置

1.3 如何切换JDK的版本？

2.DOS的简单使用：

2.1 介绍

2.2 常用的dos命令及演示

2.3 通过cmd命令运行Java程序演示：

3.IDEA的详细使用教程：

3.1 什么是IDE？

3.2 什么是IDEA？

3.3 IDEA入门指南：

三、语法特性

1.代码规范：

2.常量、变量、数据类型：

2.1 常量

2.2 变量

2.3 数据类型

2.4 数据类型转换

3.标识符：

3.1 简介

3.2 定义规则

3.3 命名规范

4.运算符：

4.1 常见运算符及它们的优先级

4.2 单目运算符

4.3 算术运算符

4.4 位运算符（特指位移运算符）

4.5 关系运算符

4.6 位运算符（指除了位移运算符之外的位运算符）

4.7 逻辑运算符

4.8 三目运算符 / 三元运算符

4.9 赋值运算符

5.Scanner类的简单使用：

5.1 概念

5.2 代码演示

6.Random类的简单使用：

6.1 概念

6.2 代码演示

四、流程控制

1.顺序结构：

2.选择结构：

3.循环结构：

五、方法

1.概念：

2.格式：

3.方法重载：

六、数组

1.基本概念：

2.定义格式：

3.数组的访问：

4.数组的遍历：

5.数组的初始化：

6.Java程序的内存分配：

7.数组使用的两个常见问题：

8.数组的扩容，缩容，插入元素，插入元素，查找元素：

9.二维数组：

Δ总结

Δ前言

up将JavaSE分为 Java基础 和 Java进阶 两部分——
先说说Java基础，Java基础又被up细分为六大专题：①《面向对象之前需要掌握的知识》；②《面向对象》；③《API—常用类》；④《API—常用工具》；⑤《反射》；⑥《多线程》，无论你是通过什么渠道学习的Java，也无论你学习Java是为了干啥，初学者一定绕不开这六大专题。
再来说说Java进阶，其实Java进阶这个专栏讲得还是JavaSE，主要分为两部分，一个是对常用集合类的源码解读（例如HashMap，LinkedList等），还有一个就是初学者不太可能会用到的知识，例如正则表达式，网络编程，再比如自定义异常，内部类，对象处理流，元注解等知识，前期基本不会用到，等到了做项目、读源码、学框架的时候，诶~，要用到了。
本篇博文要和大家分享的就是Java基础的第一个专题——《面向对象之前需要掌握的知识》，主要内容包括但不限于JDK的配置和切换、Java数据类型、代码规范、数组等。
注意事项——①代码中的注释也很重要；②不要眼高手低，自己跟着过一遍才真正有收获；③点击文章的侧边栏目录或者文章开头的目录可以进行跳转。
良工不示人以朴，up所有文章都会适时补充完善。大家如果有问题都可以在评论区进行交流或者私信up。感谢阅读！

一、拾枝杂谈

1.Java是什么？

我们平时说的Java编程语言，无一例外都是指JavaSE（Java Standard Edition），它最开始是由Sun公司的开发团队发明（Sun公司创立于加利福尼亚的斯坦福大学——Stanford University），这个开发团队后来推选了一个人出来作为他们的代表，这个人就是大名鼎鼎的Java之父——James Gosling（詹姆斯·高斯林），也就是说Java之父其实是众多开发人员中的一个代表人物。

后来呢，Sun公司就被Oracle公司收购了。所以，现在Java语言的所有权掌握在Oracle公司手里，我们在后面的学习中还会经常见到这个公司的名字。

那java语言有什么特点呢？

1）面向对象（Object Oriented Programming，即OOP）。

2）健壮，Java是强类型机制的语言（对比JavaScript是弱类型机制的语言），且Java提供了“异常处理”，“垃圾回收”等机制。

3）跨平台性（原因我们下面马上会是说到）。

4）半编译型半解释型语言，或者说，Java既具有编译型语言的特征，也具有解释型语言的特征。（具体内容up会在计组里说到）

2.计组前瞻：

up之后会出“计算机组成原理”相关的博文，作为计算机基础四大件——“计算机学科专业基础”（即408中）的关键一环，计组是每个学编程的人都逃不掉的。
这里先简单给大家提一嘴，计算机主要由Hardware（硬件）和Software（软件）两大部分组成——
概念：

Hardware：指计算机中由电子、机械和光电元件等组成的各种物理装置的总称。
Software：指按照特定顺序组织的计算机数据和指令的集合。

组成：

Hardware：根据经典的“冯·诺依曼”体系结构，硬件有五大组成部分，分别是——①运算器；②控制器；③存储器；④输入设备；⑤输出设备（其中，前两者为CPU的主要构成）。

Software：主要分为“系统软件”和“应用软件”两大类。系统软件比如黑窗口DOS，以及操作系统像是Windows，Linux，Unix，Mac，Android等；应用软件就是我们平时称的那个“软件”了，比如百度网盘，淘宝，Google浏览器等等。

3.JDK，JRE，JVM？

1. JDK：

Java Development Kit，即Java开发工具包，用于开发Java程序。
JDK = JRE + java的开发工具，其中，Java的开发工具包括 Java 编译器（javac）、Java 文档生成器（javadoc）、Java 反汇编器（javap）等等，我们在后面的学习中会经常用到这些开发工具。

特别说明：
①一般我们说的“诶，你Java用的哪个版本？”，说的都是JDK的版本，目前主流版本有JDK8.0和JDK17.0两个版本。

②Java程序开发和运行原理——示意图如下：

2. JRE：

Java Runtime Environment，即Java运行环境，包含运行Java程序需要的组件，用于运行Java程序。

JRE = JVM + Java的核心类库，其中，Java核心类库包括java.base模块（最基础最重要的模块），java.sql模块，java.net.http模块等等。

3. JVM：

Java Virtual Machine，即Java虚拟机。

JVM负责将Java程序翻成机器语言，交给低层操作系统执行，并保证运行效果；JVM可以实现Java程序的跨平台性，但JVM本身并不能跨平台。（关于JVM，up之后会专门出一个专栏讲解，就放在《Java高级》专栏中。）
Java的跨平台性，是由于通过javac命令编译成的字节码文件，可以在多个系统下运行。

二、环境搭建

1.JDK安装和配置：

1.1 人话

上文我们说了，Java的版本就是指JDK的版本，这么看来JDK选择哪个版本对我们使用Java影响很大，因为不同版本的JDK，其核心类库，以及语言特性，都有不同程度的出入。

目前主流的版本是JDK8.0 和 JDK17.0，这两个版本都是长期支持版，也是用的最多的两个版本，我的建议是两个版本你都下载上，但是主要用JDK17.0（可以随意切换JDK版本，下文会有演示）。

不过我想不会有人无聊到来Java基础教程里找JDK的下载安装教程，你应该直接去找“JDK下载安装教程”；因此，下载和安装自己想办法，up这里只给出JDK的配置教程，以及当安装了多个JDK版本后，如何切换当前使用的JDK版本。

1.2 JDK的配置

第一步，首先，右键点击我的电脑，选择属性，如下图所示：

第二步，接着，在出现的设置页面上，右侧选择高级系统设置，如下图所示：

第三步，接着，在出现的子菜单设置页面中，选择环境变量，如下图所示：

第四步，增加一条"JAVA_HOME"环境变量，选择到JDK安装目录的下一级即可（JDK所在的文件夹点进去那一级），如下图所示：

第五步，也是最后一步，配置Path变量，具体操作如下图所示：

选择编辑"Path"变量，然后在Path变量中增加一条环境变量，目录要选择到JDK的目录里面的bin目录的下一级（亦可用图中所示下面那种方式，即%JAVA_HOME%\bin，默认指向当前JAVA_HOME路径所属的JDK的bin目录下，一个道理），如下图所示：

然后点击“确定”，就完事儿了。

1.3 如何切换JDK的版本？

同时安装了两个JDK版本，如何配置环境变量以达到切换JDK版本的效果？

eg : 当前使用的JDK版本是Java8，如下图所示 :

我们在cmd命令窗口下输入“java -version”命令也可以查看当前设备的JDK版本，如下图所示 :

可知当前设备的JDK版本是JDK8.0，现在up要将其切换到JDK17.0。
首先，将JAVA_HOME环境变量更改为JDK17.0所在的目录，如下图所示 :

然后，配置path环境变量，将配置的JDK17.0的path环境变量上移到JDK8.0的path环境变量之上（那个%JAVA_HOME%\bin就是JDK8.0关联的环境变量），如下图所示 :

此时，若我们再次到cmd命令窗口下输入“java -version”命令（注意——需要重新打开一个cmd窗口），会发现JDK版本已经切换到了JDK17.0，如下图所示 :

PS：如果想了解在IDEA中怎么切换当前项目使用的JDK版本，可以移步“Spring IOC—基于注解控制和管理Bean”一文，直接看“@Resource自动装配”那里。

2.DOS的简单使用：

2.1 介绍

DOS：Disk Operating System磁盘操作系统。DOS原理图如下所示：

2.2 常用的dos命令及演示

1> dir / (dir + 路径)：查看当前目录 / 指定目录有什么内容。

2> cd /D c: 切换到C盘下，亦可选择切换到其他盘下（例如：cd /D d:切换到D盘下）。

3> cd..：切换到上一级。【PS：cd = change directory】

4> cd\：切换到根目录。

5> tree / (tree + 路径)：查看当前目录 / 指定目录下的所有子级目录。

6> cls：清屏。

7> exit：退出DOS。

8> echo xxx > yyy.txt：输入xxx内容到yyy文本文件中，如果yyy文件不存在就创建它；如果yyy文件存在就用xxx内容覆盖它原有的内容。

9> type nul > xxx.txt：创建一个空内容的名字叫xxx的文本文件。

很简单，这里up只演示第一个（其他真懒得演示了😘），其他的大家自己动手去试试就学会了。
比方说，up现在在D盘的用户目录下，如下图所示：

up通过在该目录路径栏输入“cmd”从当前目录进入DOS，并通过dir 和 dir documents命令，分别从查看当前目录下和当前目录下的“文档”目录下都有什么文件，演示GIF图如下所示：

2.3 通过cmd命令运行Java程序演示：

首先我们在桌面创建一个Test.java源文件，如下图所示：

Test.java代码如下：

class Test {
    public static void main(String[] args) {
        System.out.println("This is only a temporary tentitive file~");
    }
}

现在，我们要在DOS下完成两件事——①利用javac命令工具对Test.java编译，生成Test.class文件；②利用java命令工具运行Test.class。
先来干第一件事，如下GIF图所示：

可以看到，Test.java成功被编译，并在桌面上（当前目录）自动生成了Test.class字节码文件。
再来干第二件事，如下GIF图所示：

可以看到，Test.class被正确执行，并且成功打印出了"This is only a temporary tentitive file~"。
特别注意一点——在DOS下用cmd使用java命令工具时，例如上面演示up用的“java Test”，类名后面不能加.class，否则会被误认为是类名的一部分，造成运行错误，如下图所示：

3.IDEA的详细使用教程：

3.1 什么是IDE？

IDE，全称Integrated Development Environment，即“集成开发环境”，是指整合了代码的编写、运行、分析、调试等一系列功能的开发软件；确切地说，它是一个为开发者提供综合工具集的平台，核心目标是简化开发流程，将编写、调试、测试和部署代码的工具集成到一个统一的界面中。

3.2 什么是IDEA？

目前主流的运行Java程序的IDE有两个——①IDEA；②Eclipse。前者智能程度高、功能全面；后者免费。

大多数Java程序员使用的IDE，包括企业员工，都是IDEA，因为好用，Eclipse更可能是学校用（比如考研复试里面有机试的时候）。那IDEA呢，是由Jet Brains公司开发的（在捷克首都），卖得还挺贵，咳咳，但是我们一般是用那啥版本的。

3.3 IDEA入门指南：

具体见这篇博文——链接如下：
https://blog.csdn.net/TYRA9/article/details/128360218文章浏览阅读3.8k次，点赞13次，收藏40次。IDEA新人入门指南，手把手带你创建第一个项目！Let's go!_idea使用教程javahttps://blog.csdn.net/TYRA9/article/details/128360218https://blog.csdn.net/TYRA9/article/details/128360218https://blog.csdn.net/TYRA9/article/details/128360218https://blog.csdn.net/TYRA9/article/details/128360218https://blog.csdn.net/TYRA9/article/details/128360218https://blog.csdn.net/TYRA9/article/details/128360218https://blog.csdn.net/TYRA9/article/details/128360218https://blog.csdn.net/TYRA9/article/details/128360218https://blog.csdn.net/TYRA9/article/details/128360218https://blog.csdn.net/TYRA9/article/details/128360218https://blog.csdn.net/TYRA9/article/details/128360218

“IDEA详细入门指南”一文，主要内容包括 :
        ① 项目和类的创建
        ② 如何运行一个程序
        ③ IDEA中包的使用
        ④ IDEA中常用的20个快捷键

⑤ IDEA中语句模板的使用

三、语法特性

1.代码规范：

1）类、方法的注释要以javadoc的方式来写；注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。

2）非javadoc的注释，往往是给代码的维护者看的，着重告诉读者为什么这样写，如何修改，注意什么问题等。

3）代码排版缩进时，先选中要排版的代码，再用Tab 或 Shift Tab进行缩进。

4）源文件要使用UTF-8编码。

5）行宽度不要超过80个字符。

6）代码编写风格——选择次行风格或行尾风格（IDEA默认风格）

PS：常见javadoc注释符如下表所示：

标签	描述	示例
`@author`	标识一个类的作者	`@author John Doe`
`@deprecated`	指名一个过期的类或成员	`@deprecated This method is no longer supported.`
`{@docRoot}`	指明当前文档根目录的路径	`{@docRoot}/images/logo.png`
`@exception`	标志一个类抛出的异常	`@exception IOException On input error.`
`{@inheritDoc}`	从直接父类继承的注释	`{@inheritDoc}`
`{@link}`	插入一个到另一个主题的链接	`{@link java.util.List}`
`{@linkplain}`	插入一个到另一个主题的链接，但该链接显示纯文本字体	`{@linkplain java.util.List List}`
`@param`	说明一个方法的参数	`@param username The name of the user.`
`@return`	说明返回值类型	`@return The number of users.`
`@see`	指定一个到另一个主题的链接	`@see java.util.Collections`
`@serial`	说明一个序列化属性	`@serial description`
`@serialData`	说明通过 `writeObject()` 和 `writeExternal()` 方法写的数据	`@serialData description`
`@serialField`	说明一个 `ObjectStreamField` 组件	`@serialField name type description`
`@since`	标记当引入一个特定的变化时	`@since 1.5`
`@throws`	和 `@exception` 标签一样，标志一个类抛出的异常	`@throws IOException On input error.`
`{@value}`	显示常量的值，该常量必须是 `static` 属性	`{@value java.lang.Math#PI}`
`@version`	指定类的版本	`@version 1.0`

2.常量、变量、数据类型：

2.1 常量

概念：是指在程序执行的过程中，其值不可以发生改变的量。
分类：大体上分为两大类——“字面值常量” 和 “自定义常量”。其中，字面值常量是指直接写在代码中的固定值，它又可分为六种：①字符串常量，如"HELLO WORLD"；②整数常量，如11，-23；③小数常量，如2.333；④字符常量，如'R', 'A', '9'；⑤布尔常量，如true，false；⑥空常量，即null。而自定义常量，则是由final修饰的变量，通过final关键字来定义。
补充：在Java中，整型常量默认是int类型，声明long类型常量必须在后面加“l” 或 “L”。

ConstantDemo类代码如下：

package csdn.foundation.before_info.initial;

public class ConstantDemo {
    /**
     * 补充两个快捷方式：
     *      ①main方法的快捷键：psvm(public static void main(String[] args){}
     *      ②输出语句的快捷键：sout(System.out.println();)
     */
    /*
        常量：
            在程序的运行过程中，其值不会改变的量。
        字面值常量分类：
            Ⅰ字符串常量：要用双引号括起来。eg：“abc”
            Ⅱ字符常量：  要用单引号括起来。eg：‘A’,'0'
            Ⅲ整数常量：11,23
            Ⅳ小数常量：11.23
            Ⅴ布尔常量：值只有两个，true 和 false
            Ⅵ空常量：NULL（null）
     */
    public static void main(String[] args) {
        //演示：
        //Ⅰ字符串常量：
        System.out.println("abc");
        System.out.println("123");//此时的123是一个字符串常量。
        //Ⅱ字符常量：
        System.out.println('A');
        System.out.println('0');
        //Ⅲ整数常量：
        System.out.println(11);
        System.out.println(23);
        //Ⅳ小数常量：
        System.out.println(8.24);
        //注意整数常量和小数常量直接在括号里写就行。
        //Ⅴ布尔常量：
        System.out.println(true);
        System.out.println(false);
    }
}

运行结果：

2.2 变量

变量三要素：①数据类型；②变量名；③变量初始值。
变量的定义：数据类型变量名 = 初始值。
补充：在Java中，局部变量在定义时必须初始化（如果局部变量未被使用，则可以不初始化），而成员变量则有自己的默认值。

VariableDemo类代码如下：

package csdn.foundation.before_info.initial;

public class VariableDemo {
    public static void main(String[] args) {
        //定义变量，记录学生个数。
        //变量的定义格式： 数据类型 变量名 = 初始化值。
        int stu_number = 12;
        System.out.println(stu_number);//输出语句此处直接写变量名即可。
    }
}

运行结果：

2.3 数据类型

分类：基本数据类型和引用数据类型。
基本数据类型分类：①整数型：byte, short, int, long；②浮点型：float（单精度）, double（双精度）；[整数型和浮点型又可统称为数值类数据类型] ③字符型：char；④布尔型：即布尔类型boolean。Java中一共有八种基本数据类型。
引用数据类型分类：①类（class）[String就属于这块儿]；②接口（interface）；③数组。Java中一共有三种引用数据类型。
八种基本数据类型，如下表所示：
PS1：对于boolean类型，不可以用0 或非0来代替false 和 true（与C语言不同），即boolean类型的取值范围只能是true 和 false。
PS2：浮点数尽量用 double 类型存储，而不是 float。

DataTypesDemo类代码如下：

package csdn.foundation.before_info.initial;

/*
    变量的定义形式：
        数据类型 变量名 = 初始化值；
    八种基本数据类型：
        byte，short，int，long，float，double，char，boolean
    定义变量的注意事项：
        1.整形默认是int类型，定义long类型变量的时候，后边要加字母l(L)
        2.浮点型默认是double类型，定义float类型变量的时候，后边要加字母f(F)
    !!!使用变量的注意事项:
    1.变量未赋值，不能使用（局部变量）。
    2.变量只在它所属的范围内有效（即变量的作用域）
    3.一行上可以定义多个变量，但是不建议这样写。
 */
public class DataTypesDemo {
    public static void main(String[] args) {
        //byte类型的变量
        byte b = 11;
        System.out.println(b);

        //short类型的变量
        short s = 4;
        System.out.println(s);

        //int类型的变量
        int i = 24;
        System.out.println(i);

        //long类型的变量
        long l = 10000L;
        System.out.println(l);

        //float类型的变量
        float f = 11.23F;
        System.out.println(f);

        //double类型的变量
        double d = 66.6;
        System.out.println(d);

        //char类型的变量
        char ch = 'K';
        System.out.println(ch);

        //boolean类型的变量
        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b1);
        System.out.println(b2);

        System.out.println("--------------------------------");

        int a;
        a = 11;
        System.out.println(a);

        //代码块：大括号括起来的内容就是代码块。
        {
            int aa = 20;
            System.out.println(aa);
        }//变量只在它所属的代码块内有效。方法与代码块之间空一行。
    }
}

运行结果：

2.4 数据类型转换

分类：①自动（隐式）类型转换：“小类型 → 大类型”，自动提升为大类型，运算结果也是大类型。②强制（显式）类型转换：手动将大类型转换成小类型，运算结果是小类型；转换格式——“小类型变量名 = (小类型) 大类型数据;”。
注意事项：当且仅当大类型数据可以转换为小类型数据时，才能进行强制类型转换，否则会造成精度丢失。
补充：
int 转 float 虽然是小类型转大类型，但可能丢失精度，因为根据IEEE754标准， float 的尾数部分只有 24 位有效位（含1位隐藏位），而 int 需要 32 位表示。如果需要更高的精度，可以使用 double 类型（64 位浮点数，尾数部分有 53 位有效位），但即便如此，double 也无法精确表示所有 long 类型的值。PS：具体细节up将在《计算机组成原理》专栏详细解释。
byte,short 和 char之间不会发生相互自动转换。
byte, short, char参与运算时，结果自动转换为int类型。
当把数值类变量赋值给byte时，先判断该数是否在byte范围内，是就可以赋值。
在Java中，boolean类型不参与数据类型转换。
“表达式” 结果的类型自动提升为所操作的数据中最大的类型。

ConversionDemo类代码如下：

package csdn.foundation.before_info.initial;/*
    类型转换：
        1) 隐式类型转换：    "小 ---> 大"
            数据类型的范围从小到大如下：
                byte，short，char -> int(默认的整形) -> long -> float -> double(默认的浮点型)
                Boolean类型不参与比较，它的值只有true和false两个。
        2) 强制类型转换：    "大 ---> 小"
            目标类型 变量名 = (目标类型) 要转换的值
            注意： 强制类型转换在使用的时候可能会出现丢失精度的问题
 */

public class ConversionDemo {
    public static void main(String[] args) {
        //定义两个int类型的变量
        int a = 10;
        int b = 11;
        System.out.println(a + b);
        //我可以把a+b的结果接收一下。
        int c = a + b;
        System.out.println(c);
        System.out.println("_____________________________ ");

        //定义一个int类型的数据 和 一个byte类型的数据
        int aa = 10;
        byte bb = 20;
        System.out.println(aa + bb);

        /**byte cc = aa + bb;//会报错！！，因为byte类型和int类型计算，会先将byte类型提升为int类型再计算，结果也是int类型。*/
        int cc = aa + bb;//即：隐式类型转换。
        System.out.println(cc);
        System.out.println("______________________________");

        //思考：如何使用byte类型的变量来接收aa + bb?
        byte dd = (byte) (aa + bb);
        System.out.println(dd);     //答: 强制类型转换.
        System.out.println("______________________________");

        double d1 = 3.14;
        int a1 = (int) d1;//此条代码的意义是：将double类型的结果值强制类型转换为整数.
        System.out.println(a1);
    }
}

运行结果：

3.标识符：

3.1 简介

标识符定义：给类、方法、变量、常量等起名字的字符序列，就是标识符
标识符的组成部分：英文大小写字母、数字、下划线_ 和美元符号$

3.2 定义规则

不能以数字开头
不能是关键字 和 保留字（但可以包含）
严格区分大小写

PS_1 ：常用关键字如下——
1）用于定义数据类型的关键字：

关键字	描述
class	定义类
interface	定义接口
enum	定义枚举类型
@interface	定义注解类型
byte	字节类型
short	短整型
int	整型
long	长整型
char	字符类型
float	单精度浮点型
double	双精度浮点型
boolean	布尔类型
void	无返回值类型
true	布尔值真
false	布尔值假
null	空引用

2）用于定义流程控制的关键字：

关键字	描述
if	条件判断
else	条件分支
switch	多分支选择
case	switch 分支
default	switch 默认分支
for	循环
while	循环
do	循环（do-while循环）
break	跳出循环或 switch
continue	继续下一次循环
return	返回值

3）用于定义访问权限修饰符的关键字：

关键字	描述
public	公共访问权限
protected	受保护的访问权限
private	私有访问权限

4）用于定义类、函数、变量修饰符的关键字：

关键字	描述
abstract	抽象类或方法
final	不可继承或不可修改
static	静态成员
synchronized	同步方法或代码块

5）用于定义类与类之间关系的关键字：

关键字	描述
extends	继承类
implements	实现接口

6）用于定义建立实例、引用实例、判断实例的关键字：

关键字	描述
new	创建实例
this	当前对象引用
super	父类对象引用
instanceof	判断对象类型

7）用于处理异常的关键字：

关键字	描述
try	尝试执行代码块
catch	捕获异常
finally	最终执行代码块
throw	抛出异常
throws	声明可能抛出的异常

8）用于包的关键字：

关键字	描述
package	定义包
import	导入包

9）其它关键字：

关键字	描述
native	本地方法
strictfp	严格浮点计算
transient	非序列化字段
volatile	易变字段
assert	断言

10）自己命名时要避免使用的保留字：

保留字	描述
`byValue`	目前未使用，可能用于未来的语言特性。
`cast`	目前未使用，可能与类型转换相关。
`future`	目前未使用，可能用于未来的语言特性。
`generic`	目前未使用，可能与泛型相关。
`inner`	目前未使用，可能与内部类相关。
`operator`	目前未使用，可能与操作符重载相关。
`outer`	目前未使用，可能与外部类相关。
`test`	目前未使用，可能与测试相关。
`var`	从 Java 10 开始，`var` 被用作局部变量类型推断的关键字，但在早期版本中是保留字。
`goto`	保留字，但 Java 中未实现 `goto` 语句（为了避免代码混乱）。
`const`	保留字，但 Java 中使用 `final` 代替 `const` 来定义常量。

3.3 命名规范

类和接口：首字母大写，如果有多个单词，每个单词首字母大写（大驼峰），eg：HashMap，OutputStreamWriter。
变量和方法：首字母小写，如果有多个单词，从第二个单词开始首字母大写（小驼峰），eg：getName，toString。
自定义常量：所有字母全部大写，多个单词之间用下划线（_）隔开，eg：MAX_SIZE，MIN_VALUE。
包名：全部小写，如果有多级包，则包名之间用点号（.）隔开，遵循域名反写的格式：com.cyan.pot。
总结：驼峰命名，见名知意。

4.运算符：

4.1 常见运算符及它们的优先级

单目运算符 > 算术运算符 > 位运算符（特指位移运算符） > 关系运算符 > 位运算符（指除了位移运算符之外的位运算符） > 逻辑运算符 > 三目运算符 > 赋值运算符

4.2 单目运算符

分类：++（自增），--（自减），!（逻辑非），~（按位取反）
PS：偶数个逻辑非（!）不改变真值的结果，eg：(!!true) == true，(!!!!false) == false。

4.3 算术运算符

分类：+（加），-（减），*（乘），/（除），%（取模）
加法运算的特点：
① 加法两边是数值型数据时，进行加法运算；
② 加法两边出现字符型数据参与运算时（eg：'a', 'o'等字符），用该字符在计算机中所表示的数值进行运算。（byte, short, char参与运算时，结果自动转换为int类型）
③ 加号两边有任意一边是字符串时，进行字符串的拼接操作。
PS：华氏温度转摄氏温度的公式：摄氏温度 = (5 / 9) * (华氏温度 - 100)。

4.4 位运算符（特指位移运算符）

<<（算术左移），>>（算术右移），>>>（逻辑右移）

4.5 关系运算符

定义：关系运算符是用来描述两个变量值之间的关系的。
分类：>（大于），<（小于），>=（大于等于），<=（小于等于），==（等于），!=（不等于）。

4.6 位运算符（指除了位移运算符之外的位运算符）

① &：按位与，注意与&&（短路与）作区分。当进行位运算时，&表示把左右两个数的二进制代码的每一位都进行”与“操作，算出组成的新的二进制代码所对应的数。&还可以作为信息的采集方式，比如通过 “a & 0101”，就能判断出a的第一位和第三位。

② |：按位或，注意与||（短路或）作区分。

③^：按位异或（不允许相同）：相同为0，不同为1。

4.7 逻辑运算符

使用：逻辑运算符两端一般连接值为布尔类型的关系表达式。
分类：&（逻辑与），|（逻辑或），&&（短路与），||（短路或）。特别注意——当& 或 | 两边不是booloean类型时，表示位运算。
逻辑与& 和短路与&& 的区别——
短路与&&：如果第一个条件为false，则第二个条件不会进行判断，最终结果直接为false，效率高。
逻辑与&：不管第一个条件是否为false，第二个条件都要进行判断，效率低。
逻辑或| 和短路或|| 的区别——同理。

4.8 三目运算符 / 三元运算符

a ? b : c —— 如果 a 成立，就执行b，否则执行c。

4.9 赋值运算符

分类：①基本赋值运算符：=；②扩展赋值运算符（复合赋值运算符）：+=，-=，/=，*=，%=。
扩展赋值运算符的好处：省略了强制类型转化。
short s = 1;
//s = s + 1; //（报错: 不能把int类型赋值给short类型）
s += 1;     //没事儿，相当于s = (short) (s + 1);

5.Scanner类的简单使用：

5.1 概念

扫描器，即可以通过Scanner类扫描用户在控制台录入的数据。

5.2 代码演示

ScannerDemo类代码如下：

package csdn.foundation.before_info.scanner.extendclass;
//  1.导包
import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        //  2.创建Scanner类的对象
        //  System.in：标准的输入流，默认指向键盘。(编译类型为InputStream)
        boolean key = true;

        Scanner sc = new Scanner(System.in); //根据Scanner类的构造方法，需要传入一个指定输入流。
        //  3.接收数据
        System.out.println("请输入一个实数：");

        //为了防止InputMismatchException异常，需要先对f进行判断
        loop: while (key) {
            if (sc.hasNextFloat()) {
                float f = sc.nextFloat();
                sc.nextLine();      //nextLine用于“消化”掉Enter键的'/n'换行符
                System.out.println("f:" + f);
                key = false;
            } else
                break loop;
        }
        //接收字符串类型的数据
        System.out.println("请输入一个字符串：");

        //方法一:
        String s = sc.nextLine();   //结束标志：回车
        System.out.println("s："+ s);

        //方法二:
        /*String s = sc.next();     //结束标志：空白符(回车，Tab键，空格) eg：空格后的字符都不会计入
        System.out.println("s："+ s);*/

        //  4. 关闭扫描器
        sc.close();
    }
}

运行结果如下GIF图所示：

6.Random类的简单使用：

6.1 概念

随机数，用于产生随机数的类。

6.2 代码演示

RandomDemoEX类代码如下：

package csdn.foundation.before_info.Random;
/**
    猜数字的小游戏，系统产生一个1~100之间的随机数，请猜出这个数是多少。
 */
import java.util.Random;
import java.util.Scanner;
//记得导包

public class RandomDemoEX {
    public static void main(String[] args) {
        //1.获取一个1~100之间的随机数，让用户猜。
        Random r = new Random();
        Scanner sc = new Scanner(System.in);
        int num = r.nextInt(100) + 1;
        /*
            "0~100前闭后开区间" + 1, 就能取到100. 即[1,101)
            r.nextInt(99) --> [0,99)
         */

        for ( ; ; ) {
        //2.通过键盘录入获取用户猜的数字，并接收。
            System.out.println("请猜一下1~100间的这个整数是多少:");
            int t = sc.nextInt();

            //3.比较两个数字大小，看是否一致，并给予提示。
            if (t < num)
                System.out.println("猜小了，哥们");
            else if (t > num)
                System.out.println("猜大了，哥们");
            else {
                System.out.println("恭喜哥们，可算混对了！");
                break;
            }
        }//4.因为不知道你啥时候猜对，所以用死循环。
        sc.close();
    }
}
//PS:猜数字技巧：折半法。

运行结果：（如下GIF图）

四、流程控制

1.顺序结构：

Java中定义变量时应采用合法的前向引用（即先定义后使用）。
写程序的时候，做数据测试应该测试以下几种情况——
① 正确数据。
② 错误数据。
③ 边界数据。
读程序的时候，应该遵循以下步骤——
① 程序的整体执行流程。
② 每条语句的具体含义。
③ 试数（代入一个数据过一遍）。

2.选择结构：

在用法上，选择结构与C语言类似。
在Java中，switch (表达式) ，表达式的取值类型可以是①byte; ②short; ③int; ④char；
JDK5开始，还可以是 ⑤枚举；
JDK7开始，还可以是 ⑥String。
PS：对于switch语句，表达式的数据类型应和case后的常量类型一致，或者是“可以自动转换成的能够相互比较的类型”，eg：表达式是char类型，而case后常量的类型是int类型。
多分支 if条件语句可以没有单else语句。
建议实际开发中，分支语句的嵌套不要超过三层。
switch分支和 if分支，应该用谁？
若需要判断的是具体数值且值的数目不多（离散的值），而且值的类型符合switch表达式的六种类型，更推荐用switch分支。
若要对一个或多个连续的区间进行判断，更推荐if分支，

3.循环结构：

for循环语句的格式：
for (初始条件语句;  判断条件语句; 控制语句) {
    //循环体——重复执行的代码  
}              
①初始条件语句——用于循环变量的初始化。用一个Java的赋值语句来完成，eg: int i = 1; PS：for循环中，初始条件语句可以有多条语句，但要求变量的数据类型相同，多条初始语句之间用逗号隔开。
②判断条件语句——判断本次循环是否执行，往往优先采用"<"（小于号），返回一个布尔值。
③控制语句——用于控制循环执行的次数或循环的执行特性。PS：控制语句也可以有多条，中间照样用逗号隔开。
while 循环：相比于for循环，初始条件语句和控制语句可以省略。

do-while循环：要点与C语言相同，do-while循环至少执行一次，记得最后的while()后要加;（分号）。

for循环和 while循环，应该用哪个？
一般来说，for循环和while循环可以互相改写，但while循环格式更加简洁；for循环更倾向于循环次数是固定的，而while循环更倾向于循环次数不固定的情况。
死循环：代码如下：
//1. for循环版本的死循环
for ( ; ; ) {
    //循环体，根据实际需求给出结束循环的条件。
}

//2. while循环版本的死循环
while (true) {
    //循环体，根据实际需求给出结束循环的条件。
}

演示一下循环结构，Orange类代码如下：

package csdn.foundation.before_info.control;

/**
 * 1024程序员节，给可爱的程序员发橙子，
 * 已知条件：
 * 1.假设有三个班级，每个班级有十五位码农，现在要将100个橙子分别发给每位码农，且每人只能拿一个橙子。
 * 2.假设编号中有5的哥们不吃橙子
 * 3.如果当前编号的码农已经有了橙子，则不再给该码农发放橙子，若橙子发完了，则活动结束。
 */
public class Orange {
    public static void main(String[] args) {
        int count = 0;  //count变量用于记录已经发放的橘子的个数。
        firstFor:       //带标号的循环
        for (int i = 1; i <= 3; i++) {
            secondFor:
            for (int j = 1; j <= 15; j++) {
                if (j % 10 == 5 || j / 10 % 10 == 5) {
                    continue secondFor;     //跳过当前码农，直接进行下一次循环(内层循环)
                }
                System.out.println("正在给第"+ i +"个班的第" + j + "个哥们发橘子" + "，哥们吃的挺香");
                count++;
                if (count >= 100)
                    break firstFor;
            }
            System.out.println();
        }
        System.out.println("总共发放了"+ count +"个橘子");
    }
}

运行结果：

五、方法

1.概念：

也叫"函数"，是完成特定功能的代码块。

2.格式：

修饰符 返回值类型方法名(形参列表) {
//方法体语句;
return 返回值; // Java中，方法的返回值必须和函数名前等等返回值类型相同。
}

注意事项——

① 参数类型可以是基本类型，也可以是引用类型。
② 方法必须定义在类中，方法之间是平级关系，方法不能嵌套定义。

③ 当方法的返回值类型为void时，return语句可以省略。

3.方法重载：

定义：同一个类中的多个方法，方法名相同但形参列表不同，这样的情况称为”方法重载“。对于重载的多个方法，可以通过方法签名（方法名 + 形参列表）准确地找到具体方法。
为什么需要方法重载？
当实现的功能相同，但具体的实现方式不同时，我们可以通过定义名称相同而形参列表（条件）不同的多个方法，来更好地识别和管理类中的方法。

演示一下方法重载，ReMethodDemo类代码如下：

package csdn.foundation.before_info.method_test;

/**
 * 方法重载的概念：
 *      同一个类中的多个方法，出现方法名相同，但是参数列表不相同的情况。
 *      参数列表不同有以下情况：(有一个不同就可以) //注意和形参的名字无关系
 *       I.个数不同
 *      II.对应数据类型不同
 *     III.相同数据类型但位置不同
 * Δ方法重载与方法的返回值类型无关, 与方法的修饰符无关。
 */
public class ReMethodDemo {
    public static void main(String[] args) {
        int a1 = 3,b1 = 5;
        long a2 = 8L,b2 = 11L;
        float a3 = 2.11F,b3 = 9.85F;//小数默认double类型，想定义float类型，需要后面加上一个F。

        System.out.println("int类型中，较大的数字是" + compare(a1, b1));
        System.out.println("long类型中，较大的数字是" + compare(a2, b2));
        System.out.println("float类型中，较大的数字是" + compare(a3, b3));
    }

    public static int compare (int a, int b) {
        return (a > b)?a :b;
    }

    public static long compare (long a, long b)  {
        return (a > b)?a :b;
    }

    public static float compare (float a, float b)  {
        return (a > b)?a :b;
    }

    public static void compare (int a, float c) {;}
}

运行结果：

六、数组

1.基本概念：

数组是用来存储同一种数据类型的多个元素的容器；此处提到的”数据类型“可以是基本类型，也可以是引用类型，但不能混用。

2.定义格式：

格式一：
数据类型[] 数组名 = new 数据类型[长度]; (new关键字用于开辟内存空间；数组长度在定义时指定，不可更改)
格式二：
数据类型[] 数组名 = new 数据类型[] {元素1，元素2，...}; （定义时元素是确定的，避免了内存空间的浪费）
格式三：
数据类型[] 数组名 = {元素1，元素2，元素3，...}; （格式三是格式二的变形，简化了代码编写）

ArrayDemo1类代码如下：

package csdn.foundation.before_info.array0;

/**
 *    PS :  1) 数据类型[] 数组名 = 数据类型 数组名[]
 *          两种方式都可以。
 *          2) 也可以先声明数组，后分配空间，
 *          eg：int[] aaa;       //此处数组实际为null
 *              a = new int[3];
 *
 */

public class ArrayDemo1 {
    public static void main(String[] args) {
//        eg:！！！注意格式正确
        int[] a1 = new int[5];            //格式1
        int[] a2 = new int[]{1, 2, 3, 4};   //格式2
        int[] a3 = {1, 2, 3, 4, 5};            //格式3
        System.out.println("-------------------------------");

        //C中是这样的： int a[] = {1,2};  ，有点类似于Java中的格式三
        //数据类型[] 数组名 = 数据类型 数组名[]
        int aa1[] = new int[3];
        int aa2[] = new int[]{1,2,3,4};
        int aa3[] = {1, 2, 3, 4, 5};
        System.out.println(aa1);

        //Define a char Array to store 26 English alphabet.
        char[] alphabets = new char[26];

        int i = 0;
        for ( ; i < alphabets.length; ) {
            alphabets[i] = (char) ('A' + i);
            i++;
        }
        //print alphabets
        for (int j = 0; j < alphabets.length; ++j) {
            System.out.print(alphabets[j] + " ");
        }
    }
}

运行结果：

3.数组的访问：

通过 索引（也叫下标、脚标）来访问数组，下标是指数组元素距数组起始位置的偏移量，第一个元素的偏移量为0，所以数组的下标从0开始。
访问格式：数组名[索引] or 数组名[索引] = 值。
若直接手动输出数组变量名，得到的是数组的内地址值。如下图所示：

Java中，数组中未手动赋值的元素有默认值；eg：int类型数组默认值是0，double类型数组默认值是0.0。

4.数组的遍历：

通过for循环遍历数组，打印数组中每个元素的值。
PS：数组变量存储的是数组在堆内存中的地址值，而不是数组元素的值，数组变量通过内存地址引用堆内存中的数组，所以数组是引用类型。

演示类ArrayDemo5代码如下：

package csdn.foundation.before_info.array0;

import java.util.Scanner;

/**
 * 在Java中，定义一个方法来遍历数组时，只需要将数组名发送给方法即可，
 * 由于java在内部已经写好了代码，所以方法能够自己找到数组的长度。
 */
public class ArrayDemo5 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] arr = new int[5];

        System.out.println("请输入数组的元素（5个整数）：");
        for (int i = 0; i < arr.length; i++) {
            arr[i] = sc.nextInt();
        }
        System.out.println("_______________________");
        System.out.println("数组遍历的结果为：");
        printArray(arr);

        sc.close();

        int[] arr2 = new int[5];
        for (int i = 0; i < arr2.length; ++i) {
            arr2[i] = arr[i];
            System.out.println("拷贝后的arr2中的第" + (i + 1) + "个元素是：" + arr2[i]);
        }
    }

    public static void printArray(int[] arr) {
        for (int a = 0; a < arr.length; a++) {
            System.out.println(arr[a]);
        }
    }
}

运行结果：

5.数组的初始化：

动态初始化：只指定长度，由系统给出默认值。（定义格式一）
整数型（byte, short, int, long）：0
浮点型（float，double）：0.0
字符型（char）：'\u0000'（空字符）
布尔型（boolean）：false
引用类型：null（空引用）

静态初始化：给出初始化值，由系统决定数组长度。（定义格式二、三）

6.Java程序的内存分配：

方法区：存储可运行的class文件（字节码文件），包含方法，静态成员，常量等。包含方法的类会被逐个加载到方法区，其中首先加载的是包含main方法的类。
栈：方法运行时使用的内存，特点是“后进先出”，即最先进入栈区的方法最后出栈，比如main方法。
堆：存储new出来的数组或对象。
本地方法栈：JVM在调用操作系统功能时使用，与开发无关。
寄存器：CPU使用，与开发无关。

PS：关于“Java程序的内存分配”，我们会在《面向对象》专题（也就是下一个专题）更详细地讲解。有兴趣的同志可以先去看看up写得这两篇博文——
①创建对象的内存图解：java 创建对象的内存图解（通俗易懂)_java创建对象内存分配图解-CSDN博客
②继承关系的内存图解：java 继承关系的内存图解（通俗易懂)_java继承的内存模型-CSDN博客

7.数组使用的两个常见问题：

数组索引越界异常（ArrayIndexOutOfBoundsException）：即下标越界。
空指针异常（NullPointerException）：数组引用存储的值为null，而非数组的地址。
arrr1 = null;
System.out.println(arr1[2]);    //运行时报错——java.lang.NullPointerException

8.数组的扩容，缩容，插入元素，插入元素，查找元素：

链接如下：

java 数组的扩容，缩容，插入元素，查找元素详解（通俗易懂）_java 数组扩容-CSDN博客Java数组的扩容和缩容是一种常见的操作。扩容是指增加数组的容量以容纳更多的元素，缩容则相反。本文详细介绍了扩容和缩容的需求、思路和代码演示，并附上了运行效果。https://blog.csdn.net/TYRA9/article/details/128262798https://blog.csdn.net/TYRA9/article/details/128262798https://blog.csdn.net/TYRA9/article/details/128262798

9.二维数组：

ArrayEX类代码如下：

package csdn.foundation.before_info.array0;

import java.util.Arrays;
import java.util.Scanner;

/*
    关于二维数组的声明：(一共三种)
        除了像一维数组一样的int[][] twoDiArray = 和 int twoDiArray[][] = 之外，
        还有int[] twoDiArray[] =
 */
public class ArrayEX {
    public static void main(String []args) {
        int[][] twoDimensionalArray = {
                {0, 0, 0, 0, 0, 0},
                {0, 0, 1, 0, 0, 0},
                {0, 2, 0, 3, 0, 0},
                {0, 0, 0, 0, 0, 0},
        };

        System.out.println("The length of twoDimensionalArray is :" + twoDimensionalArray.length);
        System.out.println("The length of twoDimensionalArray's element is :" + twoDimensionalArray[0].length);
        System.out.println("--------------------------------------");

        //traverse the two-dimension array
        for (int i = 0; i < twoDimensionalArray.length; ++i) {
            for (int j = 0; j < twoDimensionalArray[0].length; ++j) {
                System.out.printf("%-5d", twoDimensionalArray[i][j]);
            }

            System.out.println();
        }

        System.out.println("--------------------------------------");
        for (int i = 0; i < twoDimensionalArray.length; ++i) {
            System.out.println(Arrays.toString(twoDimensionalArray[i]));
        }

        System.out.println("--------------------------------------");
        System.out.println(Arrays.toString(twoDimensionalArray));
        System.out.println("--------------------------------------");

//Die Demo_two Live Second.
        Scanner sc = new Scanner(System.in);

        int rowNum;
        rowNum = sc.nextInt();

        int[][] tDA = new int[rowNum][];
        /*
            Assignment.
            print every oneDimensionalArray of twoDimensionalArray.
         */
        for (int i = 0; i < tDA.length; ++i) {
            tDA[i] = new int[i + 1];
            for (int j = 0; j < tDA[i].length; ++j) {
                tDA[i][j] = i + 1;
                System.out.print(tDA[i][j] + "\t");
            }
            System.out.println();
        }
        sc.close();
    }
}
        /**
         * Actually,the length of twoDimensionalArray's element is uncertain.
         * It means that the column number of twoDimensionalArray is not decided.
         * eg:
         *      int[][] twoDimensionalArray;
         *      twoDimensionalArray = new int[5][]; //Don't have to write the width.
         *      并且，如果没有给一维数组开空间，那么twoDimensionalArray[i] = null;
         */

运行结果：

Δ总结

🆗，以上就是我们专题一 ——《面向对象之前需要掌握的知识》的全部内容了。感谢阅读！
回顾我们的第一个专题，我们先是从“JDK，JRE，JVM”的关系出发，又引出了DOS，IDEA；接着，介绍了Java的一些语法特性，Java的流程控制；最后，又给出了Java的方法和数组的内容，所有内容都相对比较简单，比较容易上手。
嗯，总的来说，对于这一专题的内容，大家不需要太上心😂，啥时候忘了回来看看就行，第一个专题就像是安全村，溜达溜达，下一专题开始才是真正的主线。
下一专题——《面向对象》，大家不见不散。

System.out.println("END--------------------------------");