启航-后端-总结1

启航-后端-总结1

人生第一次写博客，以此贴作为学习过程上的见证的一部分。（在此立下Flag：本周因为处于五四期间忙于学生工作，准备得比较仓促，一些细节方面可能会不够详尽，假期期间一定补全！）

一、入门

①对Java的初步了解

基本都是一些老生常谈的问题，但有一些值得关注的部分。首先，Java的核心优势是跨平台，Java诞生时赶上了最初互联网的发展，并随着互联网的发展而发展，也因此建立了强大的生态体系。（所以咱就是说生态真的很重要，这也是鸿蒙发展的一大难题）

②Java的各个版本的区别

1. JavaSE(Java Standard Edition)：标准版，定位在个人计算机上的应用
2. JavaEE(Java Enterprise Edition)：企业版，定位在服务器端的应用
3. JavaME(Java Micro Edition)：微型版，定位在消费性电子产品的应用上

三者之间的关系大概如下：

③Java的优势、特性

1.跨平台/可移植性

这也就是Java的核心优势，相比其他语言来说可以更加轻易地在不同平台上兼容。

2.安全性

Java适合于网络/分布式环境，为了达到这个目标，在安全性方面投入了很大的精力，使Java可以很容易构建防病毒，防篡改的系统。

3.面向对象

相比C++来说，Java是纯粹的一门面向对象的语言。

4.简单性

在学习的过程当中，对此点略有感触，在有了学习C++的基础上，在学习Java的过程中，有很多地方可以相互比较，有很多思路可以互通。

5.高性能

还是拿C++与Java进行比较。当时学习到这里这里的时候比较好奇，于是便上网稍微了解了一下。简单来说就是一句话，C++的运行效率高而Java的开发效率高，C++相对来说更加接近机器语言，因此相对Java来说开发效率更低，计算机执行起来效率比较高（相对来说）。

6.分布式

Java是为Internet的分布式环境设计的，因为它能够处理TCP/IP协议。

7.多线程

多线程的使用可以带来更好的交互响应和实时行为。

8.健壮性

简单来说，就是吸收了C++很多的优点，然后去除其中很多繁琐、容易影响程序“健壮性”的部分。即使Java程序，也可能有错误。如果出现某种出乎意料之事，程序也不会崩溃，而是把该异常抛出，再通过异常处理机制加以处理。

④Java的运行机制

首先，一般来说计算机高级语言的类型主要有编译型和解释型两种。

1.编译型

对于编译型语言，开发完成以后需要将所有的源代码都转换成可执行程序，比如 Windows 下的.exe文件，可执行程序里面包含的就是机器码。只要我们拥有可执行程序，就可以随时运行，不用再重新编译了，也就是“一次编译，无限次运行”。

在运行的时候，只需要编译生成的可执行程序，不再需要源代码和编译器了，所以说编译型语言可以脱离开发环境运行。

2.解释型

对于解释型语言，每次执行程序都需要一边转换一边执行，用到哪些源代码就将哪些源代码转换成机器码，用不到的不进行任何处理。每次执行程序时可能使用不同的功能，这个时候需要转换的源代码也不一样。

因为每次执行程序都需要重新转换源代码，所以解释型语言的执行效率天生就低于编译型语言，甚至存在数量级的差距。计算机的一些底层功能，或者关键算法，一般都使用 C/C++ 实现，只有在应用层面（比如网站开发、批处理、小工具等）才会使用解释型语言。

在运行解释型语言的时候，始终都需要源代码和解释器，所以说它无法脱离开发环境。

两种语言运行机制如下所示：

而对于Java，则是两种类型的结合，运行机制简单来说一般如下：

1. Java 首先利用文本编辑器编写Java 源程序，源文件的后缀名为.java；

2. 再利用编译器（javac）将源程序编译成字节码文件，字节码文件的后缀名为.class；

3. 最后利用虚拟机（解释器，java）解释执行。

如下图所示：

⑤JVM、JRE 和JDK

JVM(Java Virtual Machine): 用于执行bytecode 字节码的”虚拟计算机”。

Java Runtime Environment (JRE) 包含：Java 虚拟机、库函数等。

Java Development Kit (JDK)包含：JRE，编译器和调试器等。

都是一堆抽象的概念，我快睡着了都，大概关系如下：

⑥Java开发环境的搭建

在大概了解了Java的一些基本信息之后，就就就就到了最最最最最最最最激动人心的，环境搭建的过程。

开开心心地将1.92G的前辈の馈赠下载了下来，麻溜地安装了JDK，原本以为这会与C++编译器安装一样是个傻瓜式的过程，结果令我没想到的是，傻瓜竟是我自己。

在完成JDK的下载和安装后，到了环境变量Path的设置环节，此时此刻，我猛然发现，哦吼，win7和win10的这个界面好像不太一样吼（当场裂开.java）

大概就是底下的这个样子：

事实证明，人生三大错觉：她喜欢我，我能反杀，这东西我自己能鼓捣出来。

在经历了一个小时的失败之后，我在那一瞬间领悟了人生的真谛，我想起了村里已经通网了，因此，我打开了至尊百度，花五分钟解决了问题。

Win10系统下环境配置问题解决教程：

win10下(Java环境)JDK环境变量配置_哔哩哔哩_bilibili

  事实证明，每过去一小时就需要60分钟，3600秒。（祭奠我那逝去的一个小时）

⑦我的第一个程序

人生真是反复无常，三个常见错误，一下子就碰见了其中一个。

在细心地重新设置Path之后，程序终于能够正常运行了。

  但是天不遂人愿，下一个问题紧接着就来了，无法正常输出中文字符。

 

  人总是会在跌倒中长大的，接受了教训之后，我在第一时间便打开了至尊百度，30秒后，我便找到了解决的方法。

解决教程：使用cmd运行java出现错误：编码GBK 的不可映射字符的解决方法_ria_zhou的博客-CSDN博客_不可映射字符如何处理

⑧最常用DOS命令

⑨进入编译器时代

下载了IDEA，配置了中文（汉化万岁！）

编译器环境下的第一个程序：

运行结果：

比起cmd控制台，编译器真是太太太好用了，编译器万岁！

附：输出语句

1.System.out.print("XXX");语句1打印完是没有换行的
2.System.out.println( "XXX");语句2打印完自动换行

• 数据类型与运算符

这部分主要是概念的记忆，跟C++比较相像（最讨厌的部分）

①进制转换

在线进制转化的工具： 进制转换 - 在线工具

②注释

与C++大同小异

1. 单行注释：使用“//”开头，“//”后面的单行内容均为注释。
2. 多行注释：以“/*”开头以“*/”结尾，在“/*”和“*/”之间的内容为注释，我们也可以使用多行注释作为行内注释。但是在使用时要注意，多行注释不能嵌套使用。
3. 文档注释：以“/**”开头以“*/”结尾，注释中包含一些说明性的文字及一些JavaDoc标签(后期写项目时，可以生成项目的API)

③标识符

标识符需要遵守一定的规则：

1. 标识符必须以字母、下划线_、美元符号$开头。 
2. 标识符其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合。
3. Java 标识符大小写敏感，且长度无限制。
4. 标识符不可以是Java的关键字。

标识符的使用规范：

1. 表示类名的标识符：每个单词的首字母大写，如Man, GoodMan
2. 表示方法和变量的标识符：第一个单词小写，从第二个单词开始首字母大写，称之为“驼峰原则”，如eat(), eatFood()。

④关键字/保留字

好像都是一些老面孔了嘿嘿

⑤变量

1.变量的本质

变量本质上就是代表一个”可操作的存储空间”，空间位置是确定的，但是里面放置什么值不确定。

  可通过变量名来访问“对应的存储空间”，从而操纵这个“存储空间”存储的值。

  Java 是一种强类型语言，每个变量都必须声明其数据类型。变量的数据类型决定了变量占据存储空间的大小。比如，int a=3; 表示a 变量的空间大小为4 个字节。

  对于变量的解读，我觉得这个图比较生动形象：

2.变量的声明

double salary;

long earthPopulation;

int age = 18;

double e = 2.718281828;

int i ,j;

3.变量的分类

变量有三种类型：局部变量、成员变量(也称为实例变量)和静态变量。

其中：

1.局部变量

方法或语句块内部定义的变量。生命周期是从声明位置开始到到方法或语句块执行完毕为止。局部变量在使用前必须先声明、初始化(赋初值)再使用。

简单来说就是，这个变量只有在这个局部内可以使用，有点像C++的在子函数内部定义的变量。（废话）

2.成员变量（也叫实例变量）

方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。如果不自行初始化，它会自动初始化成该类型的默认初始值。

3.静态变量（类变量 static variable）

使用static定义。 从属于类，生命周期伴随类始终，从类加载到卸载。如果不自行初始化，与成员变量相同会自动初始化成该类型的默认初始值。

注：

1. 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
2. 变量名必须是合法的标识符
3. 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

⑥常量

在Java语言中，主要是利用关键字final来定义一个常量。 常量一旦被初始化后不能再更改其值。（常量简直是山农第一深情）

声明格式为：final  type  varName = value;

为了更好的区分和表述，一般将1、2、3、’a’、’b’、true、false、”helloWorld”等称为字面常量，而使用final修饰的PI等称为符号常量。

变量和常量命名规范：

1. 所有变量、方法、类名：见名知意
2. 类成员变量：首字母小写和驼峰原则:  monthSalary
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则:  Man, GoodMan
6. 方法名：首字母小写和驼峰原则: run(), runRun()

⑦基本数据类型

1. Java中三类8种基本数据类型：

数值型：byte、 short、int、 long、float、 double

字符型：char

布尔型：boolean

1.数据类型的分类

2.整型变量/常量 

整型用于表示没有小数部分的数值，它允许是负数。整型的范围与运行Java代码的机器无关，这正是Java程序具有很强移植能力的原因之一。与此相反，C和C++程序需要针对不同的处理器选择最有效的整型。

Java语言的整型常数默认为int型，声明long型常量可以后加‘ l ’或‘ L ’ 。 

因此将int类型的常量修改成long类型的即可：

1. 浮点型变量/常量

1. float 类型又被称作单精度类型，尾数可以精确到7 位有效数字。
2. double 表示这种类型的数值精度约是float 类型的两倍，又被称作双精度类型，绝大部分应用程序都采用double 类型。
3. Java 浮点类型常量有两种表示形式：

(1) 十进制数形式： 例: 3.14 314.0 0.314

(2) 科学记数法形式例：3.14e0 3.14E2 3.14E-1

1. 浮点型不精确，不要用于比较
2. 浮点数存在舍入误差，数字不能精确表示。浮点数适合普通的科学和工程计算，精度足够；但不适合精度要求非常高的商业计算，这时候要使用BigDecimal 进行运算和比较。
3. 浮点常量默认类型是double，要改成float 可以后面加F 或f

1. 字符型变量/常量

  Unicode 字符集是为了给全世界所有字符一个唯一的编码，“唯一”对应的英文为Unique，而编码的英文为code。

Unicode 采用了字符集和编码分开的策略。Unicode 之前，Unicode 诞生之前可以将字符集和字符编码混为一谈，而在Unicode 中必须严格区分开。

Unicode 字符集统一采用两个字节表示一个字符，包括英文字母。但是，由于英文占据互联网信息的绝大部分。真实存储和传输时，会造成极大的浪费；因此，目前主要采用UTF-8编码来实现具体的存储和传输。UTF-8 是变长编码，用1-6 个字节编码Unicode 字符。西欧字符仍然是1 个字节，汉字3 个字节。

字符型在内存中占2 个字节，在Java 中使用单引号来表示字符常量。例如’A’是一个字符，它与”A”是不同的，”A”表示含有一个字符的字符串。

char 类型用来表示在Unicode 编码表中的字符。Unicode 编码被设计用来处理各种语言的文字，它占2 个字节，可允许有65536 个字符。

Unicode 具有从0 到65535 之间的编码，他们通常用从’\u0000’到’\uFFFF’之间的十六进制值来表示（前缀为u 表示Unicode）

1. 布尔型变量/常量

boolean 类型有两个常量值，true 和false。

在内存中占一个字节或4 个字节，不可以使用0 或非0 的整数替代true 和false，这点和C 语言不同。

⑧运算符

1. 运算符类型

1. 运算符优先级问题

⑨类型转换

1.自动类型转换

自动类型转换指的是容量小的数据类型可以自动转换为容量大的数据类型。黑色的实线表示无数据丢失的自动类型转换，而虚线表示在转换时可能会有精度的损失。

可以将整型常量直接赋值给byte、short、char 等类型变量，而不需要进行强制类型转换，只要不超出其表数范围即可。

2.强制类型转换

强制类型转换，又称为造型（cast），用于强制转换数值的类型，可能损失精度。当将一种类型强制转换成另一种类型，而又超出了目标类型的表数范围，就会被截断成为一个完全不同的值。

注：不能在布尔类型和任何数值类型之间做强制类型转换！

• 控制语句

这部分跟C++不能说是一模一样，只能说是大同小异了。

①选择结构

1.if单选择结构

2.if-else双选择结构 

3.if-else if-else多选择结构 

4.switch结构 

②循环结构

循环结构分成两大类，一类是当型，一类是直到型。

1.当型：

当布尔表达式条件为true 时，反复执行某语句，当布尔表达式的值为false 时才停止循环，比如：while 与for 循环。

2.直到型：

先执行某语句， 再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false 时才停止循环，比如do-while 循环。

while 循环

do-while 循环

 for 循环

例：

③break 语句和continue 语句

1.break 用于强行退出整个循环

（防止死循环.java）

2.continue 用于结束本次循环，继续下一次

“标签”是指后面跟一个冒号的标识符，例如：“label:”。对Java 来说唯一用到标签的地方是在循环语句之前。

“goto 有害”论中，最有问题的就是标签，而非goto，随着标签在一个程序里数量的增多，产生错误的机会也越来越多。但Java 标签不会造成这方面的问题，因为它们的活动场所已被限死，不可通过特别的方式到处传递程序的控制权。

最起初还有一些些懵逼，仔细想想，“标签”用于跳转，学习C++的时候老师不建议我们使用，Java这里可以不用顾忌地使用，Java牛逼！

④语句块

语句块（也叫复合语句）。语句块中定义的变量只能用于自己，外部不能使用。

语句块可以使用外部的变量，而外部不能使用语句块的变量。

  这些特点跟C++中的函数很像。

⑤方法

1. 方法：一段用来完成特定功能的代码片段，类似于其它语言的函数。
2. 方法用于定义该类或该类的实例的行为特征和功能实现。
3. 面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。
4. 面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

声明格式：

调用的方式：

一些术语的解释：

⑥方法的重载

方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。

1. 重载的方法，实际是完全不同的方法，只是名称相同而已！

1. 构成方法重载的条件：

1. 形参列表不同的含义：形参类型、形参个数、形参顺序不同
2. 只有返回值不同不构成方法的重载

如：int a(String str){}与void a(String str){}不构成方法重载

1. 只有形参的名称不同，不构成方法的重载

如：int a(String str){}与int a(String s){}不构成方法重载

⑦递归结构

递归的基本思想：自己调用自己

跟C++一致的思路，俺觉得递归是个好东西==算法简单~但是递归确实慢。

• 面向对象编程

  在这一块，大体思路其实跟C++差不多。

  学习这一块的时候，回想一下，通过“表格思维”可以很快地了解到底什么是“对象”。

1. 这一整个表结构对应：类结构

     2. 每一行数据对应：一个对象

     3. 表中所有数据对应：这个类的所有对象

面向过程、面向对象

既然有面向对象编程，那肯定少不了面向过程编程。之前学习C++的时候，对二者之间的区别一直有些许疑问。

面向过程和面向对象都是对软件分析、设计和开发的一种思想,它指导着人们以不同的方式去分析、设计和开发软件。C 语言是一种典型的面向过程语言，Java 是一种典型的面向对象语言。

面向过程思想适合简单、不需要协作的事务，重点关注如何执行。面向过程时，我们首先思考“怎么按步骤实现？”并将步骤对应成方法，一步一步，最终完成。这个适合简单任务，不需要过多协作的情况下。

比如，如何开车？我们很容易就列出实现步骤：

点火→挂挡→踩油门→走你

再比如，如何把大象装进冰箱？

打开冰箱→放入大象→关闭冰箱

  相对来说，如果用面向对象问题来思考“如何把大象装进冰箱？”这个问题，首先我们要想的是：我们是不是该把大象切块之后放入冰箱？

面向对象思想更契合人的思维模式。我们首先思考的是“怎么设计这个事物？” 比如思考造车，我们就会先思考“车怎么设计？”，而不是“怎么按步骤造车的问题”。这就是思维方式的转变。因此，面向对象可以帮助我们从宏观上把握、从整体上分析整个系统。但是，具体到实现部分的微观操作（就是一个个方法），仍然需要面向过程的思路去处理。

• 数组

我觉得Java中数组的思想和原理与C++差不多，但相对来说，Java的数组更加“健壮”。

①数组的定义

数组是相同类型数据的有序集合。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。数组的四个基本特点：

1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

2. 其元素的类型必须是相同类型，不允许出现混合类型。

3. 数组类型可以是任何数据类型，包括基本类型和引用类型。

4. 数组变量属于引用类型，数组也是对象,数组中的元素相当于对象的属性。

②数组的声明

type[ ] arr_name; //方式一

type arr_name[ ]; //方式二

声明数组→给数组分配空间→给数组元素赋值

需要注意的地方：

1. 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM 才分配空间，这时才与长度有关。
2. 声明一个数组的时候并没有数组真正被创建。
3. 构造一个数组，必须指定长度。

③数组的初始化

1.静态初始化

除了用new 关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

2.动态初始化 

  数组定义与为数组元素分配空间并赋值的操作分开进行。

3.数组的默认初始化 

数组是对象，它的元素相当于对象的属性；每个元素也按照属性的方式被默认初始化。

④数组的一些常见操作

即：遍历与拷贝（和C++一样的这不是）

1.数组的遍历

数组元素下标的合法区间：[0, n-1]。我们可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值，一般通过循环来实现。

2.for-each 循环

for-each 专门用于读取数组或容器中所有的元素。

注：

1. for-each 增强for 循环在遍历数组过程中不能修改数组中某元素的值。
2. for-each 仅适用于遍历，不涉及有关索引（下标）的操作。

数组的拷贝 

声明方式：

System.arraycopy（object src，int srcpos，object dest， int destpos，int length）

该方法可以将src数组里的元素值赋给dest 数组的元素，其中srcpos 指定从src 数组的第几个元素开始赋值，length 参数指定将src 数组的多少个元素赋给dest 数组的元素。

java.util.Arrays类

Arrays 类包含了：排序、查找、填充、打印内容等常见的数组操作。

多维数组

跟C++一样，多维数组相对来说会好用不少，多维数组可以看成以数组为元素的数组。

1.二维数组的声明：

Java中多维数组的声明和初始化应按从低维到高维的顺序进行↓

2.二维数组的初始化 

以上是第一次总结的大致内容，由于时间仓促，很多内容没有体现，再次回收一下开头的Flag，假期期间对这些知识点进行温习并补全。（头秃.java）

PS：这个发布文章的机制真是太不好用了，竟然不能直接复制粘贴WPS里面排好版的内容，图片通通没了==早早码完总结结果死在上传上边T-T