只记录一些个人觉得比较重要的东西，不然写着浪费时间

一些基本的概念

JDK 和JRE

JRE（Java Runtime Environment）：Java运行时环境

1. JRE包括Java虚拟机、运行时核心类库等Java程序运行时必备的环境
2. JRE主要是给已经编写好的Java程序使用，也就是说操作系统中想要运行Java程序，必须要有JRE

JDK（Java Development Kit）：Java开发者工具包

1. JDK包含JRE
2. 除了JRE外，JDK还提供了Java开发者需要使用的工具，比如javac.exe，java.exe（Windows）

Java语言的编译原理

java是一门需要编译的语言，我们写的代码是xxx.java，称为源代码文件，然后通过javac进行编译成.class文件，也就是会在out文件夹当中显示的文件，这个文件内容实际上是字节码的文件，但是我们在编译器当中可以看到，就是因为编译器的优化，然后我们编译好的.class文件再进行java指令，进行执行，就会进入jvm虚拟机上进行执行这个字节码的文件。

Java源代码总是要经过编译，得到class字节码文件，然后字节码文件在Java虚拟机中解释执行。

编译器和jdk的安装

这边直接跳过了，毕竟当时安装的时候没有截图，这边就直接进行适当掠过。

也没啥值得关注的，重点就是JDK的选择需要是1.8版本的，也就是jdk8，然后具体就见别人的博客吧。

还有就是配置jdk的环境变量，这也是需要配置的，不想配置也可以，就相当于没有办法在cmd下执行java和javac这两条指令。

编译器的基础介绍

新建项目的规范

实际上这并不完全，在位置上应该是D:\item\java\项目名称

原因就是看你会不会使用到module这个东西，至于图片所示，只是为了让你好看，好去了解。

src文件介绍

IDEA中所有Java源代码都必须放在src目录下，才能执行。

简单来说，src是英语单词"source"的缩写，代指"源代码"，这个缩写以后将会经常看到和使用。就JavaSE阶段的学习进度而言，所有的代码都需要写在src目录下，也只有放在src目录下的代码，才可以被执行。

在IDEA这种集成开发环境中，已经集成了cmd窗口控制台的作用，点击main方法左边的Run，启动main方法即可看到代码执行结果！

src规范强调

1. 而对于源文件的强调就是，源文件当中放置的就是源代码，但是并不推荐把源代码直接放置于同层下，我们希望你在src当中先创建一个个包，然后再把java放进去。

2. public修饰类的类名必须和文件名保持一致，一个Java文件中只有一个public修饰的类，但非public类可以有多个。

一个Java文件定义多个类

//文件 HelloWorld.java中
public class HelloWorld {
}
class A{}
class B{}
class C{}

2. main方法是程序的入口方法，只有存在main方法的Java类可以启动，执行其中的代码。

3. 如果Java Class都直接放在src目录下，是不允许有同名的class的，包括public修饰的class和非public修饰的class！这就好比同一个文件夹下，不允许有同名文件一样。

包

通俗点讲在Java当中包就是文件夹，包的作用

1. 区分同名的.java文件，在同包的情况下不能存在同名的java文件也不能出现同名的class，而在同一个java文件中，所有的class都属于同包的关系。
2. 包用来组织一个项目当中庞大的java文件，所以在项目的开发当中，禁止直接讲代码写在src下，需要先创建包，然后在包下写代码
3. 包还用来区分访问的权限，这个之后会进行演示。

Module

Project只是IDEA进行项目管理的顶层概念，而不是真实存在的基本单元。Module才是IDEA进行Java项目开发的基本单元，实际上每创建一个Project，默认就会创建一个Module，并且该Module的名字和Project相同。

当然，在IDEA中要想创建Module，必须在一个Project的基础上才能够完成创建。从操作系统层面上看，每个Module也是一个独立的文件夹，或者这么理解，一个项目project对应的可能不止一个文件夹，如果对应多个文件夹，那么就是对应module。

而创建的过程就需要在项目文件夹下使用右键新建，新建模块，而具体的创建流程和新建项目差不多。

如果你希望第二个Module和第一个Module是同级关系，目录路径上要体现同级。如果你希望第二个Module和第一个Module是上下级关系，目录路径上要体现上下级，这是比较关键的，需要在创建的时候看目录进行体现。

通过在IDEA种创建两种结构Project和Module，不难发现实际上两者没有本质区别。

总得来说：Project是概念上的顶层结构，Module是IDEA的基本单元。

1. IDEA中的Project不是一个独立的概念，新建一个Project的实质是创建了一个独立的Module，并且这个module的名字和project名字一样。
2. 一个Project可以有多个module
3. 主流的大型项目结构基本都是多Module的，这类项目一般是按功能划分模块，模块之间彼此可以相互依赖。
4. 在JavaSE阶段，没有必要创建多Module的Project。即便创建了，多个module之间实际也不会相互依赖。
5. 每个Project用独立的窗口打开，而不是堆在一个窗口中。

IJ的一些特殊的操作

分屏写代码

去掉代码提示的大小写限制

注释设置

文件编码设置

设置回车

这个跨文件运行比较重要。

空格，换行这些看起来是"空"的，什么都没有的东西，实际上都是一个字符，称之为控制字符。换行字符在不同操作系统中，显示的符号是不一样的，参考下表：

不同操作系下的换行符

操作系统	换行符
Windows	\r\n，回车加换行
类 Unix	\n，换行
Mac	\n，换行

1. \r 表示回车，即 CR （carriage return）\n 表示换行，即 LF （linefeed）
2. Mac也是类Unix操作系统，之所以单列出来因为早期Mac上的换行符是\r（OS 9和之前），OS X之后统一为\n，当然你现在能见到和使用到的非古董Mac肯定都是Mac X系统的。

因为不同操作系统换行符的不同，在一个系统下编辑的文件放到另一个系统下时，可能会显示不正常。

快捷键

在使用快捷键之前，记得先把QQ，音乐软件以及一些别的的全局快捷键给关了，不然会发生冲突。

IDEA的常用快捷键介绍

快捷键	效果介绍
Alt + Enter	快速修复光标位置的错误，光标放在的位置不同提示的结果也不同 （必备）
Ctrl + Alt + L	格式化代码，强迫症必备，建议每写几行代码下意识的按一下该快捷键（必备）
Ctrl + Y	删除光标所在行 或 删除选中的行 （必备）
Ctrl + D	复制光标所在行 或 复制选择内容，并把复制内容插入光标位置下面（必备）
Ctrl + W	递进式选择代码块，会逐步选择某行代码、结构体，方法直至整个类
Ctrl + O	选择可重写的方法
Ctrl + /	注释光标所在行代码，会根据当前不同文件类型使用不同的注释符号 （必备）
Ctrl + Shift + /	多行注释（必备）
Alt + Insert	代码自动生成，比如构造方法，get/set方法等等（必备）
Ctrl + Alt + 左方向键	回到上一个光标所在位置 （Debug模式必备）
Ctrl + Alt + 右方向键	前进到上一个光标的位置 （Debug模式必备）
Ctrl + Shift + Z	取消撤销 （必备）
Ctrl + Alt + V	快速补全变量
F2	跳转到下一个高亮错误 或 警告位置 （必备）

Java语法基本概念

关键字

关键字的定义是：关键字是被Java语法赋予特定含义的单词。
关键字的特点是：关键字都是合法的单词，而且字母必须全部小写，关键字在Java语法中都有特定的含义，它对编译器具有特殊意义，能够影响编译！具体来说，关键字往往都用来表示一种程序的结构或者修饰一些程序的结构等等。当然更具体的含义，要针对不同的关键字来说明。

修饰符 与 非修饰符

在Java中，关键字总体可分为两大类：修饰符和非修饰符。修饰符是典型的关键字，如它的名字一样，修饰符是用来修饰“别人”的单词。比如用来修饰一个类，修饰一个方法等等的关键字都是修饰符。

修饰符（modifier）总体上还可以再分两类：

1. 访问权限修饰符，例如：
   1. private
   2. 缺省的默认权限（什么关键字都不写）
   3. protected
   4. public
2. 非访问权限修饰符，例如：
   1. final
   2. abstract
   3. static
   4. …

非修饰符实际上远比修饰符更多，非修饰符往往用来表示程序结构，表示一些定义之类的。就比如上面说的class就应该属于这个分类。

保留字

保留字是对当前版本的Java，没有特殊含义的单词。

1. 但是以后的版本中，Java官方可能会将其变成具有特殊含义的单词（也就是说可能升级为关键字）
2. 即便以后也不打算升级为关键字，但是Java官方认为你不应该在Java代码中使用的单词，也会变成保留字

比如在java8当中的const 和 goto，实际上并没有作用，但是java8不让用。

Java关键字大全

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	用来进行程序调试
boolean	基本数据类型之一，布尔类型
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言(如C/C++/FORTRAN语言)实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一，短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict(单精度或双精度浮点数)表达式遵循IEEE 754算术规范
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

注释

Java支持三种注释的语法格式，分别是：

1. 单行注释

   // 注释的文字
   

2. 多行注释

   /*
   注释的文字
   注释的文字
   注释的文字
   */
   

3. 文档注释

   /*** 注释的文字* 注释的文字* 注释的文字*/
   

关于三种注释方式，用途是不同的：

1. 单行注释。在解释说明单行或某几行代码时，如果仅需要简短的一句或几句话时，就使用单行注释。
2. 多行注释。在解释说明单行或某几行代码时，如果简短的一句或几句话不能说清楚，就需要使用多行注释。
3. 文档注释。主要是用于解释说明整个类、整个方法这种大的代码结构。Java官网对于文档注释提供了Javadoc规范，符合Javadoc规范的文档注释可以使用javadoc指令，输出对应的文档。（Javadoc规范以及通过文档注释输出文档等，因为不是很重要就不展开讲了，感兴趣自己百度找一下方法试一试。）

java变量

实际上分为下面四种类型：

1. 整型
2. 浮点型
3. 字符类型
4. 布尔类型

而java和C/C++一样，每次声明一个变量都需要同时声明其类型。

整型

1. byte
   byte类型也叫字节型，仅占1个字节内存空间，即8位。
   byte 是占用内存空间最小的整型，只有在极度需要节省空间的场合才会被使用，实际Java开发几乎不会使用。

2. short
   short 也叫短整型，占用2个字节内存空间，即16位。
   短整型比字节型表示范围稍大，但实际开发中short使用频率也不高。

3. int
   int 本身就是单词integer的缩写，它就是整型的代名词，占用4个字节内存空间。int 是最常用的整数数据类型，实际开发中整数往往都是int类型的。

4. long
   long 也叫长整型，占用8个字节内存空间。
   当int类型不足以存储数据时，就需要使用long类型存储数据。即在需要很大的整数时考虑使用long类型。

浮点型

1. float
   float 即单精度的浮点数，占用4个字节内存空间，32位。
   float 相对于double占用空间更小，但它不如double精度高，也没有double表示范围大。

2. double
   double 双精度的浮点数，占用8个字节内存空间，64位。
   double尾数位长度更大，更精确，整体表示范围也更大，是更常用的浮点数类型。

字符型

Java中字符型char就是存储一个正整数，来表示字符，而在java当中字符是2个字节的，和c那些区分一下。

还有就是string类型，不过有的又将其称作字符数组，都可以。

布尔型

boolean，布尔类型，用来存储真（true）和假（false）两种布尔值，没有其它取值。

数据范围

基本数据类型	字节长度	大小（位）	最小值	最大值	取值范围
byte	1字节	8bit	-2^7	2^7-1	-128 ~ 127
short	2字节	16bit	-2^15	2^15-1	-32768 ~ 32767
int	4字节	32bit	-2^31	2^31-1	-2147483648 ~ 2147483647（21亿出头）
long	8字节	64bit	-2^63	2^63-1	-9223372036854774808 ~ 9223372036854774807（大概922亿亿）
float	4字节	32bit	-	-	大约 ±3.403E38（有效位数7~8位）
double	8字节	64bit	-	-	大约 ±1.798E308（有效数字16~17位）
char	2字节	16bit	0	2^16-1	0 ~ 65535，编码值必须是一个正整数

标识符

实际上就是给变量取名字

标识符的开头必须是：
字母（A~Z 和 a~z）
下划线（_）
美元符号（$）
Unicode 字符集中编号为0xC0以及它后面的所有符号

标识符的组成必须是：
数字（0~9）
字母（A~Z 和 a~z）
美元符号（$）
下划线（_）
Unicode 字符集中编号为0xC0以及它后面的所有符号

一般变量和类的命名采用的都是大驼峰命名法

包的命名

多数公司开发的包名会以反转公司的域名作为开头（这边默认java做的就是EE，也就是web端）。

例如在百度做开发，项目的包名开头应该是com.baidu.xxx

包名的单词字母应该全部小写，禁止使用大写字母出现。
包名如果使用名词英文单词，那么统统使用单数形式，不要用复数形式。

常量

从大的分类来说，常量主要分为两类：

1. 字面值常量，在Java代码中，所有直接写值的量都是字面值常量。包括：
   （1）整数常量：直接写在代码中的整数都是。例如1、2、3等。
   （2）小数常量：直接写在代码中的小数都是。例如1.1、1.2、1.3等。
   （3）字符常量：直接写在代码中的，使用单引号引起来的字符都是。例如’A’、'a’等。
   （4）布尔常量：直接写在代码中的布尔值，只有true和false两个。
   （5）字符串常量：直接写在代码中的，使用双引号引起来的字符串都是。例如"HelloWorld"、"hello"等
   （6）空常量：空常量是引用数据类型独有的一种取值，只有null一个。
2. 自定义常量，通过语法自由地定义一个常量在代码中使用。（面向对象再讲）

局部变量

代码块决定了其中的变量的作用域，也就是代码块中的变量仅在当前代码块内部生效。这意味着同一个代码块中，不可能有同名的变量。定义在代码块中的变量，被代码块限制了作用域，称之为局部变量。

public static void main(String[] args) {
// num的作用域是整个main方法，以下main方法中就无法再定义num局部变量了。
int num = 100;
if (true) {// int num = 10; 不能定义，会编译报错。// a变量的作用域就在if的代码块之间int a = 200;
}
// a = 300; a不能在if之外生效
// a仍然可以在main方法下面定义
int a = 100;
}

声明变量

// 默认的字面值常量的类型
int a = 10;
char b = 'A';
double c = 0.1;
String str = "Hello";//声明long类型的数据 需要末尾加上个L
long a = 123L；//声明float类型的数据 需要末尾加上F
float a = 0.1F

String简谈

String s1 = "hello";
String s2 = "hello";//s1和s2的内容是一致的，如何判断呢，不过值得注意的是不能使用==
s1.equals(s2);

数据类型转换

数据类型的转换又可以分为两类：

1. 自动类型转换
2. 强制类型转换

自动类型转换

自动类型转化发生在从小变大，一般来说不会发生数据失真现象，但是难说，有时候会产生，下图当中的虚线处会产生。

1. 整型自然是占用内存空间越大，取值范围就越大。
2. 浮点型的float虽然只占4个字节，但是它比所有整型的取值范围都大。
3. 该体系中double是取值范围最大的，byte是最小的。
4. char类型比较特殊，在参与数值类型的自动类型转换时，是编码值参与了转换。而且由于char类型的编码值范围是[0，65535]，所以只有int及以上数据类型的取值范围比char类型大。
   

强制类型转化

强制类型转换一般发生在由大变小，在这种情况下，一般都会发生数据的失真，这边就需要注意。

// 做强转要慎重考虑再进行
目标数据类型 变量名 = (目标数据类型)(被转换变量的变量名);

表达类型提升

如果表达式当中存在多种数据类型 变量 参与运算，由于表达式的运算结果是唯一的，所以结果 变量 的数据类型将会提升到"最大取值范围"的那个。有以下规则：

1. byte、short、char之间不互相转换，一旦发生运算，一律自动转换为int进行运算，结果是int
2. byte、short、char任何数据类型与int进行计算，一律自动转换为int进行计算，结果是int
3. byte、short、char、int任何数据类型与long进行计算，一律自动转换为long进行计算，结果是long
4. byte、short、char、int、long任何数据类型与float进行计算，一律自动转换为float进行计算，结果是float
5. byte、short、char、int、long、float任何数据类型与double进行计算，一律自动转换为double进行计算，结果是double
6. String作为字符串类型，也可以使用" + “在表达式中参与运算，称之为"字符串的拼接”。 任何表达式一旦有字符串拼接运算，那么结果必然是String类型。

举个例子：

System.out.println('a');
输出：aSystem.out.println('a' + 1);
输出：98System.out.println("hello" + 'a' + 1);
输出：helloa1System.out.println('a' + 1 + "hello");
输出：98helloSystem.out.println("5 + 5 = " + 5 + 5);
输出：5+5=55System.out.println(5 + 5 + " = 5 + 5");
输出：10=5+5System.out.println(5 + 5.0);
输出：10.0System.out.println(5 + "5" + 5.0);
输出：555.0

和C++的定义不一致的地方

这里简单聊几个常见，但是容易引起误解的名词：

1. 赋值（assignment）
2. 声明（declaration）
3. 初始化（initialization）
4. 定义（definition）

赋值和初始化在java当中的含义是一样的，但在c++当中是不一样的，原因就是c当中的=是可以进行重载运算符的，而初始化特指的就是第一次赋值，后面的赋值就叫做赋值。

算数运算符

这边主要列出和C++当中不一样的

自增和自减

int x = 4;
int y = (x++) + (++x) + (x*10);
输出：70
流程就是y = 4 + 6 + 60
但如果在C当中就是 y = 4 + 5 + 50

一般别使用这种方式来折磨自己或者别人。

赋值语句杂谈

System.out.println(s = 30)
输出：30
赋值语句也是有输出的，输出的是=右侧的东西。

比较运算符的注意事项

1. 在比较时，基本数据类型和基本数据类型比，引用数据类型和引用数据类型比。其中基本数据类型的数值类型的比较，上述运算符都是可用的。但布尔类型仅适用于"==“或者” != "的比较。
2. 引用数据类型的变量比较只能使用" == “和” != "，而且不是任意两个引用数据类型变量都能够比较。
3. 基本数据类型的数值类型和char是可以相互比较的，boolean只能自己和自己比较。引用数据类型的比较，只能相同类型之间比较，比如String和String比较，String和System就没有可比性。
4. 两个浮点数的比较不建议直接使用比较运算符，还有诸如引用数据类型的比较等知识点，我们等到日后再谈。（面向对象讲）

逻辑运算符

逻辑运算符稍有不同，在c还是说在python当中逻辑运算符代表的都是短路，但在java当中如果想要表示短路，则需要两个连着敲

操作符	描述	例子
&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（a & b）为假
|	称为逻辑或运算符。如果任何两个操作数任何一个为真，条件为真。	(a | b)为真
^	成为逻辑异或运算符。相同时为false，不同时为true	(a ^ b) 为真
&&	称为短路与逻辑运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假
||	称为短路或逻辑运算符。如果任何两个操作数任何一个为真，条件为真。	（A | | B）为真
!	称为逻辑非运算符，用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	!(A && B)为真

Scanner 键盘输入

Scanner在做键盘录入时,调用的方法比如nextInt等,都是阻塞方法,必须要等待用户完成键盘录入后,才会继续执行代码，如果用户不输入,代码不能继续执行Scanner在做键盘录入时,不同的方法所能接收的值的数据类型不同,不要乱输入,否者会引发程序报错， 抛出异常,终止程序执行(后面会讲)

import java.util.Scanner;public class Demo {public static void main(String[] args) {// 新建一个工具类Scanner sc = new Scanner(System.in);System.out.print("请输入一个int整数:");// 阻塞方法使用，接收一个int的值int num = sc.nextInt();System.out.println(num);}
}

然后就是拒绝NextInt系列的和NextLine的混用，这是十分糟糕的操作。

1. next、nextInt、nextDouble等next系列的方法
   开始扫描数据是从第一个不为空格（换行、制表等）的字符开始
   结束扫描数据是从碰到第一个空格（换行、制表等）字符结束
2. nextLine方法
   该方法会完整接收一行数据输入，只有碰到换行符才会结束扫描
   正如它的方法名nextLine一样，完整接收一行输入。

在使用Scanner时,如果有录入多种数据类型数据的场景时,不要混用next系列和nextLine方法，永远使用nextLine方法，这样是最安全的,最省事的。

如下：

public class Demo4 {public static void main(String[] args) {// 需求,先录入一个int数据,再录入一个字符串,最后录入一个double数据Scanner sc = new Scanner(System.in);System.out.println("先录入一个int数据:");String numStr = sc.nextLine();// 很明显有一个问题: 如何把字符串转换成int数值呢?// 推荐使用包装类/*注意在做转换时,不要乱写数据,这样会导致转换失败,抛出异常*/// String ---> int 用Integer.parseInt(String)int num = Integer.parseInt(numStr);System.out.println(num);System.out.println("再录入一个字符串:");String str = sc.nextLine();System.out.println(str);System.out.println("最后录入一个double数据:");String doubleStrNum = sc.nextLine();// 如何把字符串转换成double数值呢?// String ---> double 用Double.parseDouble(String)double doubleNum = Double.parseDouble(doubleStrNum);System.out.println(doubleNum);}
}

包装类的知识之后再讲，这边就不细说了。