java_java基础语法-Toy模板网

这篇具有很好参考价值的文章主要介绍了java_java基础语法。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

注释

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

注释有哪些
单行注释

// 注释内容只能写一行

多行注释

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

文档注释

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

字面量

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

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

变量

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

变量使用注意事项

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

数据的存储形式:二进制

计算机底层都是一些数字电路(开关),用开表示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位表示尾数。
java_java基础语法
下图就是float的二进制存储规则。

S(1位)	E(8位)	M(23位)	N(32位)
符号位	0	0	0.0
符号位	0	不等于0	(-1)^s2 ^-126(0.M)
符号位	1~254	不等于0	(-1)^s2 ^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”说明一下）：
java_java基础语法
注意:这一大串数字是31位并不是32位啊，其实是因为省略了最前面的符号位，因为5.0是整数，符号位是0，所以将其省略了，所以float类型5.0的二进制流是：

0 10000001 0100000000000000000000
符号位S是0，指数部分E为10000001，也就是无符号整数129，尾数部分的隐含位是1，所以实际尾数是1.01000000000000000000000，所以对应的二进制表达式为：
java_java基础语法
即

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型数据，我们会直接用字符对变量进行赋值，而不会用这个字符对应的编码，因为我们也记不住它哈哈，但是有些字符在赋值的时候会报错,
java_java基础语法

这是因为chat 类型必须是有且仅有一个字符

还有一些特殊的字符也不能直接输入,比如’ ,因为这些字符都是Java中可能需要使用到的特殊字符，所以编译器就自动飘红，这时候就需要我们使用转义字符来转义这些特殊字符。
java_java基础语法

boolean类型

boolean也叫布尔类型，是一种取值非真即假也就是true或false的数据类型，Java代码在编译的时候会将boolean用int或者byte替换，用0表示false，用非0正整数表示true，但Java编译器不容许直接用数字对boolean直接赋值

boolean flag = true;            //正确
boolean flag1 = false;          //正确

java_java基础语法

引用类型

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类型来存储”。
java_java基础语法
这时我们就可以将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循环