注释

1. 什么是注释
   简单来说注释就是在程序中对代码进行解释说明的文字,方便自己和其他人理解,查看,不会影响程序的正常执行
2. 注释有哪些
   单行注释

   // 注释内容只能写一行
   

   多行注释

   /*
   注释内容1
   注释内容2
   */
   

   文档注释

   /**
   注释内容
   注释内容
   */
   

字面量

告诉程序员,数据在程序中的书写格式
字面量分类

字面量类型	说明	实例
整数	不带小数的数字	123,456
小数	带小数的数字	3.1415926
字符	必须使用单引号,且有且只有一个字符	‘a’,‘b’,‘c’
字符串	必须使用双引号,内容可有可无	" ",“hello world”
布尔	布尔值,表示真和假,只有两个值true和false	true,false
空	一个特殊的值空值null	值为null

变量

变量就是用来储存一个数据的内存区域,(可以理解成盒子),且里面储存的数据可以变化

变量使用注意事项

1. 什么类型的变量储存什么类型的值
2. 同一个范围变量名不能重复
3. 变量在使用时要有初始值
4. 变量存在访问范围

数据的存储形式:二进制

计算机底层都是一些数字电路(开关),用开表示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），所以它有能力存储的整数类型数据范围是
-2¹⁵~2¹⁵-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类型更大，它占用四个字节，能表示的范围是从 -2³¹~2³¹-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位，表示范围就是 -2⁶³~2⁶³-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 虽然不能叫做关键字，但它们是不能用作标识符的文字和保留字。

1. 标识符
   标识符就是一些由字符,符号组合起来的名称,用于给类,方法,变量等起名的

2. 标识符要求

• 基本要求: 由数字,字母,下划线(_)和美元符($)组成
• 强制要求: 不能以数字开头,不能是关键字,区分大小写
  

4. 命名规范

• 变量名称: 满足标识规则,建议全英文,有意义,首字母小写,且满足小驼峰模式,例如 int studentAge = 108
• 类名称: 满足标识符规则,建议全英文,有意义,首字母大写,且满足大驼峰模式,例如 HelloWorld.java