注释
- 什么是注释
简单来说注释就是在程序中对代码进行解释说明的文字,方便自己和其他人理解,查看,不会影响程序的正常执行 - 注释有哪些
单行注释
多行注释// 注释内容只能写一行
文档注释/* 注释内容1 注释内容2 *//** 注释内容 注释内容 */
字面量
告诉程序员,数据在程序中的书写格式
字面量分类
| 字面量类型 | 说明 | 实例 |
|---|---|---|
| 整数 | 不带小数的数字 | 123,456 |
| 小数 | 带小数的数字 | 3.1415926 |
| 字符 | 必须使用单引号,且有且只有一个字符 | ‘a’,‘b’,‘c’ |
| 字符串 | 必须使用双引号,内容可有可无 | " ",“hello world” |
| 布尔 | 布尔值,表示真和假,只有两个值true和false | true,false |
| 空 | 一个特殊的值空值null | 值为null |
变量
变量就是用来储存一个数据的内存区域,(可以理解成盒子),且里面储存的数据可以变化
变量使用注意事项
- 什么类型的变量储存什么类型的值
- 同一个范围变量名不能重复
- 变量在使用时要有初始值
- 变量存在访问范围
数据的存储形式:二进制
计算机底层都是一些数字电路(开关),用开表示0,关表示1,这些0和1的形式就是二进制
数据在计算机底层都是采用二进制储存的
数据以二进制的形式储存在内存中,内存是一个非常精密的部件，包含了上亿个电子元器件，它们很小，达到了纳米级别。这些元器件，实际上就是电路；电路的电压会变化，要么是 0V，要么是 5V，只有这两种电压。5V 是通电，用1来表示，0V 是断电，用0来表示。所以，一个元器件有2种状态，0 或者 1。
我们通过电路来控制这些元器件的通断电，会得到很多0、1的组合。例如，8个元器件有 28=256 种不同的组合，16个元器件有 216=65536 种不同的组合。虽然一个元器件只能表示2个数值，但是多个结合起来就可以表示很多数值了。
我们可以给每一种组合赋予特定的含义，例如，可以分别用 1101000、00011100、11111111、00000000、01010101、10101010 来表示 我、是、马、牛、逼、! 这几个字，那么结合起来 1101000 00011100 11111111 00000000 01010101 10101010 就表示”我是马牛逼!“。
一般情况下我们不一个一个的使用元器件，而是将8个元器件看做一个单位，即使表示很小的数，例如 1，也需要8个，也就是 00000001。
1个元器件称为1比特（Bit）或1位，8个元器件称为1字节（Byte），那么16个元器件就是2Byte，32个就是4Byte，以此类推：
8×1024个元器件就是1024Byte，简写为1KB；
8×1024×1024个元器件就是1024KB，简写为1MB；
8×1024×1024×1024个元器件就是1024MB，简写为1GB。
现在，我们就知道1GB的内存有多少个元器件了。我们通常所说的文件大小是多少 KB、多少 MB，就是这个意思。
单位换算：
1Byte = 8 Bit
1KB = 1024Byte = 210Byte
1MB = 1024KB = 220Byte
1GB = 1024MB = 230Byte
1TB = 1024GB = 240Byte
1PB = 1024TB = 250Byte
1EB = 1024PB = 260Byte
我们平时使用计算机时，通常只会设计到 KB、MB、GB、TB 这几个单位，PB 和 EB 这两个高级单位一般在大数据处理过程中才会用到
数据类型
数据类型就是约束变量储存数据的形式,在java中数据类型分为基础数据类型和引用数据类型
基础数据类型
基础数据类型是Java在底层帮我们实现好的，我们可以直接使用。它包含了数值型，字符型和布尔型。
基础数据类型分为4类八种
| 数据类型 | 关键字 | 取值范围 | 内存占用 |
|---|---|---|---|
| 整数 | byte | -128~127 | 1 |
| 整数 | short | -32768~32767 | 2 |
| 整数 | int(默认) | -2147483648~2147483647 | 4 |
| 整数 | long | -9223372036854775808L~9223372036854775807L | 8 |
| 浮点数 | float | 1.401298e-45到3.402823e+38 | 4 |
| 浮点数 | double(默认) | 4.9000000e-324到1.797693e+308 | 8 |
| 字符 | char | 0-65535 | 2 |
| 布尔 | boolean | true,false | 1 |
整数类型
byte：
byte又叫字节，是最小的整数类型，它占一个字节的大小，也就是8位（bit），它可以存储 -2^7
～ 2^7-1,(之所以减一是因为有一个编码拿去表示0了)
－1范围的数据，也就是－128～127，默认值是0
byte minByte = -128; //byte最小值
byte maxByte = 127; //byte最大值
byte overMinByte = -129; //编译出错
byte overMaxByte = 128; //编译出错
byte overMinByte = (byte) -129; //结果为127
byte overMaxByte = (byte) 128; //结果为-128
short：
short最小的整数类型是byte，short是倒数第二小的，它占两个字节的大小，也就是16位（bit），所以它有能力存储的整数类型数据范围是
-215~215-1，也就是－32768～32767，默认值同样是0。
short minShort = -32768; //short最小值
short maxShort = 32767; //short最大值
short overMinShort = -32769; //编译出错
short overMaxShort = 32768; //编译出错
short overMinShort = (short) -32769; //结果为32767
short overMaxShort = (short) 32768; //结果为-32768
int：
int类型比short类型更大，它占用四个字节，能表示的范围是从 -231~231-1，也就是－2147483648～2147483647（这个最好能记住，面试的时候有些面试官可能会问到），int类型也是Java中整数默认的类型，默认值同样是0
int minInt = -2147483648; //int最小值
int maxInt = 2147483647; //int最大值
int overMinInt = -2147483649; //编译出错
int overMaxInt = 2147483648; //编译出错
int overMinInt = (int) -2147483649; //编译出错
int overMaxInt = (int) 2147483648; //编译出错
int minInt = (int) -2147483649L; //结果为2147483647
int maxInt = (int) 2147483648L; //结果为-2147483648
int minInt = -2147483648 - 1; //结果为2147483647
int maxInt = 2147483647 + 1; //结果为-2147483648
long：
long型是整数类型中最大的，它占8个字节也就是64位，表示范围就是 -263~263-1
，数太大了，默认值是0L，一般情况下，long可以满足绝大部分的需求
long minLong = -9223372036854775808L; //long最小值
long maxLong = 9223372036854775807L; //long最大值
long overMinLong = -9223372036854775809L; //编译出错
long overMaxLong = 9223372036854775808L; //编译出错
long minLong = -9223372036854775808L - 1; //结果为9223372036854775807
long maxLong = 9223372036854775807L + 1; //结果为-9223372036854775808
小数类型
Java支持两种浮点类型的小数，float和double：
float：占4个字节，共32位，称为单精度浮点数。
double：占8个字节，共64位，称为双精度浮点数。
float:
float和double都是遵循IEEE 754标准的，该标准分别为32位和64位浮点数规定了二进制的表示形式。IEEE 754采用二进制的科学技术法来表示浮点数。对于float浮点数，用一位表示数字的符号，用8位来表示指数（底数为2），用23位来表示尾数，如下图所示。对于double浮点数，用1位表示数字的符号，用11位表示指数（底数为2），52位表示尾数。
下图就是float的二进制存储规则。
| S(1位) | E(8位) | M(23位) | N(32位) |
|---|---|---|---|
| 符号位 | 0 | 0 | 0.0 |
| 符号位 | 0 | 不等于0 | (-1)s*2 -126*(0.M) |
| 符号位 | 1~254 | 不等于0 | (-1)s*2 E-127*(1.M) |
| 符号位 | 255 | 不等于0 | 表示特殊数字 |
在IEEE 754标准中，约定小数点左边有一位隐含位。就是上表中“0.M”和“1.M”中的“0”和“1”.当指数取值范围为1～254时，这个隐含位就是1，这样实际上尾数的有效位是24位。即为：1.MMMMMMMMMMMMMMMMMMMMMMM。
下面以5.0这个float类型的数字举例说明其二进制形式。
首先将5.0转换成二进制流形式，但是怎么转换呢？Java的Float类提供了一个静态方法可以帮我们将float的数字转换成其二进制流对应的int类型，我们再用Integer的toBinaryString()方法就可以得到二进制流了，具体如下图所示（Java默认小数是double类型，所以定义float类型的数需要加一个字母“f”说明一下）：
注意:这一大串数字是31位并不是32位啊，其实是因为省略了最前面的符号位，因为5.0是整数，符号位是0，所以将其省略了，所以float类型5.0的二进制流是：
0 10000001 0100000000000000000000
符号位S是0，指数部分E为10000001，也就是无符号整数129，尾数部分的隐含位是1，所以实际尾数是1.01000000000000000000000，所以对应的二进制表达式为：
即
double:
double类型采用64位来表示浮点数，精确度比float类型要高，表示形式与float类似，这里就不再写了
char类型
char是字符类型，Java对字符采用Unicode字符编码。由于计算机的内存只能存储二进制数据，因此必须对各个字符进行编码。所谓字符编码，是指用一串二进制数据来表示特定的字符。常见的字符编码有很多，这里就不一一列举了，这里主要说一下Java采用的Unicode字符编码。
Unicode字符编码
Unicode收录了全世界所有语言文字中的字符，是一种跨平台的字符编码，UCS是Unicode字符编码的通用字符集。其有两种编码方案：
- 两字节（16位）编码，采用这种编码方式的字符集称为UCS-2。Java语言采用的就是两字节的编码方案。
- 四字节（32位）编码（实际只用了31位，最高位必须为0），采用这种编码方案的字符集称为UCS-4.
前面提到计算机只能存储二进制数据，所以存储字符需要对其进行编码，而Java采用Unicode的UCS-2字符集，占两个字节，例如字符’a’的编码二进制形式为0000 0000 0110 0001，对应16进制0x0061，十进制97，所以以下几种方式是等价的。
char c = 'a';
char c1 = '\u0061';
char c2 = '0x0061';
char c3 = '91';
一般情况下，我们在编写代码的时候，如果需要使用char型数据，我们会直接用字符对变量进行赋值，而不会用这个字符对应的编码，因为我们也记不住它哈哈，但是有些字符在赋值的时候会报错,
这是因为chat 类型必须是有且仅有一个字符
还有一些特殊的字符也不能直接输入,比如’ ,因为这些字符都是Java中可能需要使用到的特殊字符，所以编译器就自动飘红，这时候就需要我们使用转义字符来转义这些特殊字符。
boolean类型
boolean也叫布尔类型，是一种取值非真即假也就是true或false的数据类型，Java代码在编译的时候会将boolean用int或者byte替换，用0表示false，用非0正整数表示true，但Java编译器不容许直接用数字对boolean直接赋值
boolean flag = true; //正确
boolean flag1 = false; //正确
引用类型
Java中引用类型分为三种，分别是类引用类型，接口引用类型和数组引用类型
Object object; //类引用类型
List<Object> list; //接口引用类型
int[] array; //数组引用类型
和基础数据类型不同的一点是，引用数据类型可以赋值为null，也就是空的意思
Object object = null; //类引用类型
List<Object> list = null; //接口引用类型
int[] array = null; //数组引用类型
常用的引用类型有很多，Jdk给我们提供了很多核心引用类型供我们使用，当然我们也可以自定义引用类型来使用（除了数据引用类型），为了缩短文章的篇幅，下一章我会详细讲解引用类型的一些常见问题，比如定义和使用等等
数据溢出
long maxLong = 9223372036854775807L + 1; //结果为-9223372036854775808
在计算机中，当数据大小超过计算机所用数据类型表示范围的时候，就会发生数据溢出。比如下面这行代码，上面已经说过byte的最大值为127，那这行代码会发生什么问题呢？看的出来是一个类型不匹配的问题，因为在java中整数类型默认是int，当我们要存储的数值在byte范围之内，编译器会帮我们把数据自动识别成byte类型，但是当我们输入一个超过byte类型表示范围的数据，编译器就会提示我们：“这是一个int类型的数据，你不可以用byte类型来存储”。
这时我们就可以将130强制转换成byte类型。但是大家可能会问了，130明明已经超过byte类型可以表示的范围了啊，为什么不会报错呢？
这就涉及到了数据溢出的问题，让我们先看看输出这个num到底会得到几。
为什么是-126呢？首先我们要知道，在计算机中，数据是用其二进制补码形式来存储的，过程如下：首先130会被当成int类型存储，int是4个字节32位，也就是0000 0000 0000 0000 0000 0000 1000 0010，转成byte类型会丢弃高三字节部分，也就是1000 0010，因为正数的源码，补码，反码相同，所以130的补码还是1000 0010，将其转换成源码：补码（1000 0010）->反码（1000 0001）->原码（1111 1110）为-126，所以最后的转换结果就是-126。128溢出就是-128，129溢出就是-127（相信大家已经明白了，如果不明白的话大家可以给我留言，我会出一篇相关文章的）。其它类型的溢出也是如此。
byte num = 130; //编译出错
byte castNum = (byte) 130; //结果为-126
关键字标识符
Java有一组关键字，这些关键字是保留字，不能用作变量、方法、类或任何其他标识符
1）48个关键字：abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。
2）2个保留字（现在没用以后可能用到作为关键字）：goto、const。
3）3个特殊直接量：true、false、null。
| 关键字 | 描述 |
|---|---|
| abstract | 非访问修饰符。用于类和方法：抽象类不能用于创建对象（要访问它，必须从另一个类继承）。抽象方法只能在抽象类中使用，并且它没有主体。主体由子类（继承自）提供 |
| assert | 用于调试 |
| boolean | 只能存储真值和假值的数据类型 |
| break | 从循环或switch块中断开 |
| byte | 可以存储-128和127之间的整数的数据类型 |
| case | 在switch语句中标记代码块 |
| catch | 捕获由try语句生成的异常 |
| char | 用于存储单个字符的数据类型 |
| class | 定义一个类 |
| continue | 继续到循环的下一个迭代 |
| const | 定义一个常量。不在使用中改用final |
| default | 指定switch语句中的默认代码块 |
| do | 与while一起使用以创建do-while循环 |
| double | 可以存储1.7e−308 到 1.7e+308 |
| else | 用于条件语句中 |
| enum | 声明枚举（不可更改）类型 |
| exports | 导出包含模块的包。Java9中的新特性 |
| extends | 扩展类（表示一个类是从另一个类继承的） |
| final | 用于类、属性和方法的非访问修饰符，使它们不可更改（无法继承或重写） |
| finally | 与异常一起使用，无论是否存在异常都将执行的代码块 |
| float | 可以存储3.4e−038 到 3.4e+038 |
| for | 创建for循环 |
| goto | 不在使用中，没有任何功能 |
| if | 一个条件语句 |
| implements | 实现一个接口 |
| import | 用于导入包、类或接口 |
| instanceof | 检查对象是特定类的实例还是接口的实例 |
| int | 可以存储从-2147483648到2147483647的整数的数据类型 |
| interface | 用于声明仅包含抽象方法的特殊类型的类 |
| long | 可以存储从-9223372036854775808到9223372036854775808的整数的数据类型 |
| module | 声明一个模块。Java9中的新特性 |
| native | 指定方法不是在同一Java源文件中实现的（而是在另一种语言中实现的） |
| new | 创建新对象 |
| package | 声明一个包 |
| private | 用于属性、方法和构造函数的访问修饰符，使它们只能在声明的类中访问 |
| protected | 用于属性、方法和构造函数的访问修饰符，使它们可以在同一个包和子类中访问 |
| public | 用于类、属性、方法和构造函数的访问修饰符，使它们可以被任何其他类访问 |
| requires | 指定模块内所需的库。Java9中的新特性 |
| return | 已完成方法的执行，并可用于从方法返回值 |
| short | 可以存储从-32768到32767的整数的数据类型 |
| static | 用于方法和属性的非访问修饰符。无需创建类的对象即可访问静态方法/属性 |
| strictfp | 限制浮点计算的精度和舍入 |
| super | 指超类（父）对象 |
| switch | 选择要执行的多个代码块之一 |
| synchronized | 非访问修饰符，指定一次只能由一个线程访问方法 |
| this | 指方法或构造函数中的当前对象 |
| throw | 创建自定义错误 |
| throws | 指示方法可能引发的异常 |
| transient | 非访问修饰符，指定属性不是对象持久状态的一部分 |
| try | 创建try…catch语句 |
| var | 声明一个变量。Java10中的新特性 |
| void | 指定方法不应具有返回值 |
| volatile | 指示属性不是本地缓存的线程，并且总是从"主内存"中读取 |
| while | 创建while循环 |
注意 true false null 虽然不能叫做关键字，但它们是不能用作标识符的文字和保留字。
-
标识符
标识符就是一些由字符,符号组合起来的名称,用于给类,方法,变量等起名的 -
标识符要求
- 基本要求: 由数字,字母,下划线(_)和美元符($)组成
- 强制要求: 不能以数字开头,不能是关键字,区分大小写
- 命名规范
- 变量名称: 满足标识规则,建议全英文,有意义,首字母小写,且满足小驼峰模式,例如 int studentAge = 108
- 类名称: 满足标识符规则,建议全英文,有意义,首字母大写,且满足大驼峰模式,例如 HelloWorld.java
