Java的基本语法
Java代码的基本格式
Java中的程序代码都必须放在一个类中。类需要使用class关键字定义，在class前面可以有一些修饰符，格式如下：
修饰符 class 类名{
程序代码
}- Java中的程序代码可以分为结构定义语句和功能执行语句，其中，结构定义语句用于声明一个类或方法，功能执行语句用于实现具体的功能。每条功能执行语句的最后都必须用分号（;）结束。
- Java语言是严格区分大小写的。
- 编写Java代码时，可以在两个单词或符号之间任意的换行。但为了便于阅读，我们通常会使用一种良好的格式进行排版。
- Java程序中一句连续的字符串不能分开在两行中书写，例如，下面这条语句在编译时将会出错：
System.out.println("这是第一个
Java程序"); 如果为了便于阅读，想将一个太长的字符串分在两行中书写，可以先将这个字符串分成两个字符串，然后用加好（+）将两个字符串连起来，在加好（+）处断行。
System.out.println("这是第一个"+
"Java程序");Java中的注释
在编写程序时，为了使代码易于阅读，通常会在实现功能的同时为代码加一些注释。注释是对程序某个功能或者某行代码的解释说明，它只在Java源文件中有效，在编译程序时编译器会忽略这些注释信息，不会将其编译到class字节码文件中去。
注释还经常用于调试代码，注释掉一段代码，来逐步缩小调试范围，找到出错代码。
- 单行注释：通常用于对程序中中的某一行代码进行解释，用符号“//”表示，“//”后面为被注释的内容。
- 多行注释：以符号“/*”开头，以符号“*/”结尾。
- 文档注释：以“/**”开头，以“*/”结尾。可以使用javadoc命令将文档注释提取出来生成帮助文档。
Java中标识符
在编程过程中，经常需要在程序中定义一些符号来标记一些名词，如包名、类名、方法名、参数名、变量名等，这些符号被称为标识符。
- 标识符可以由任意顺序的大小写字符、数字、下划线（_）和美元符号（$）组成
- 但标识符不能以数字开头
- 不能是Java中的关键字
在Java中定义的标识符必须要严格遵守上面列出的规范，否则程序在编译时会报错。
除了上面列出的规范，为了增强代码的可读性，还应遵循以下规则：
- 包名所有字母一律小写
- 类名和接口名每个单词的首字母都要大写
- 变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写
- 常量名所有字母都大写，单词之间用下划线连接
- 应该尽量使用有意义的英文单词来定义标识符
Java中的关键字
关键字是编程语言里事先定义好并赋予了特殊含义的单词，也称作保留字。
下面列举的是Java中所有的关键字。
| abstract | boolean | break | byte | case |
|---|---|---|---|---|
| catch | char | const | class | continue |
| default | do | double | else | extends |
| false | final | finally | float | for |
| goto | if | implements | inport | instanceof |
| int | interface | long | native | new |
| null | package | private | protected | public |
| return | short | static | strictfp | super |
| switch | this | throw | throws | transient |
| true | try | void | volatile | while |
| synchronized |
- 所有关键字都是小写的
- 程序中的标识符不能以关键字命名。
Java中的常量
常量就是在程序中固定不变的值，是不能改变的数据。例如数字1，字符‘a’,浮点数3.2
整型常量
- 二进制：由数字0和1组成的数字序列。允许使用字面值来表示二进制数，前面要以0b或0B开头，目的是为了和十进制进行区分，如0b10110010。
- 八进制：以0开头并且其后由0~7范围内（包括0和7）的整数组成的数字序列，如0342
- 十六进制：以0x或者0X开头并且其后由0\~9、A~F(包括0和9、A和F)组成的数字序列，如0x23AF。
- 十进制
浮点数常量
浮点数常量就是数学中用到的小数，分为float单精度浮点数和double双精度浮点数两种类型。
单精度浮点数后面以F或f结尾，而双精度浮点数则以D或d结尾。在使用浮点数时也可以在结尾处不加任何的后缀，此时虚拟机会默认为double双精度浮点数。
字符常量
字符常量用于表示一个字符，且必须包含一个字符。一个字符常量要用一对英文半角格式的单引号”引起来,它可以是英文字母、数字、标点符号以及由转义序列来表示的特殊字符。
'a' '\r' '&' '\u0000'‘\u0000’表示一个空白字符，即在单引号之间没有任何字符。之所以能这样表示，是因为Java采用的是Unicode字符集，Unicode字符以\u开头，空白字符在Unicode码表中对应的值为’\u0000’。
字符串常量
字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号”“引起来。
一个字符串可以包含一个字符或多个字符，也可以不包含任何字符，即长度为零。
布尔常量
布尔常量即布尔型的两个值true和false。
null常量
null常量只有一个值null，表示对象的引用为空。
反斜杠（\）
在字符常量中，反斜杠（\）是一个特殊的字符，被称为转义字符，它的作业是用来转义后面一个字符。转义后的字符通常用于表示一个不可见的字符或具有特殊含义的字符。
- \r表示回车符，将光标定位到当前行的开头，不会跳到下一行。
- \n表示换行符，换到下一行的开头。
- \t表示制表符，将光标移到下一个制表符的位置，就像在文档中用Tab键一样。
- \b表示退格符号，就像键盘上的Backspace键。
以下的字符都有特殊意义，无法直接表示，所以用斜杠加上另外一个字符表示。
- \’表示单引号字符，Java代码中单引号表示字符的开始和结束，如果直接写单引号字符（’），程序会认为前两个是一对，会报错，因此需要使用转移符（\’）.
- \”表示双引号字符。
- \\表示反斜杠字符，由于在Java代码中的斜杠（\）是转义字符，因此需要表示字面上的\，就需要使用双斜杠（\\）。
Java中的变量
变量的定义
在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元被称为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。
int x=0,y;
y=x+3;第一行代码的作用 是定义了两个变量x和y，也就相当于分配了两块内存单元，在定义变量的同时为变量x分配了一个初始值0，而变量y没有分配初始值，变量x和y在内存中的状态为。
第二行代码的作用是为变量赋值，在执行第二行代码时，程序首先取出变量x的值，与3相加后，将结果赋值给变量y，此时变量x和y在内存中的状态发生了变化。
变量的数据类型
Java是一门强类型的语言，它对变量的数据类型有严格的限定。在定义变量时必须声明变量的类型，在为变量赋值时必须赋予和变量同一种类型的值，否则程序会报错。
在Java中变量的数据类型分为两种，即基本数据类型和引用数据类型。
8种基本数据类型是Java语言内嵌的，在任何操作系统中都具有相同大小和属性，而引用数据类型是在Java程序中由编程人员自己定义的变量类型。
整数类型变量
整数类型变量用来存储整数数值，即没有小数部分的值。在Java中，为了给不同大小范围内的整数合理地分配存储空间，整数类型分为4中不同的类型：字节型（byte）、短整型（short）、整型（int）和长整型（long）。
| 类型名 | 占用空间 | 取值范围 |
|---|---|---|
| byte | 8位（1个字节） | −27 ~ 27−1 |
| short | 16位（2个字节） | −215 ~ 215−1 |
| int | 32位（4个字节） | −231 ~ 231−1 |
| long | 64位（8个字节） | −263 ~ 263−1 |
在为一个long类型的变量赋值时，所赋值的后面要加上一个字母L（或小写l），说明赋值为long类型。如果赋的值未超过int型的取值范围，则可以省略字母L（或小写l）。
浮点数类型变量
浮点数类型变量用来存储小数数值。在Java中，浮点数类型分为两种:单精度浮点数（float）和双精度浮点数（double）。double型所表示的浮点数比float型更精确。
| 类型名 | 占用空间 | 取值范围 |
|---|---|---|
| float | 32位（4个字节） | 1.4E-45~3.4E+38，-1.4E-45~-3.4E+38 |
| double | 64位（8个字节） | 4.9E-324~1.7E+308，-4.9E-324~-1.7E+308 |
E表示以10为底的指数，E后面的+号和-号代表正指数和负指数，例如 1.4E−45表示1.4∗10−45 。
在Java中，一个小数会被默认为double类型的值，因此在为一个float类型的变量赋值时，所赋值的后面一定要加上字母F（或者小写f）。
在程序中，也可以为一个浮点数类型变量赋予一个整数数值。
字符类型变量
字符类型变量用于存储一个单一字符，在Java中用char表示。Java中每个char类型的字符变量都会占用2个字节。在给char类型的变量赋值时，需要用一对英文半角格式的单引号”把字符括起来，如’a’，也可以将char类型的变量赋值为0~65535范围内的整数，计算机会自动将这些整数转化为所对应的字符，如数值97对应的字符为’a’。
char c='a'; char ch=97;布尔类型变量
布尔类型变量用来存储布尔值，在Java中用boolean表示，该类型的变量只有两个值，即true和false。
变量类型的转换
在程序中，当把一种数据类型的值赋给另一种数据类型的变量时，需要进行数据类型转换。
自动类型转换
自动类型转换也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明。
要实现自动类型转换，必须同时满足两个条件，第一是两种数据类型彼此兼容，第二是目标类型的取值范围大于源类型的取值范围。
byte b=3; int x=b;- 整数类型之间可以实现转换：byte–>short、int、long；short、char–>int、long；int–>long
- 整数类型转换为float：byte、char、short、int、long–>float
- 其他类型转换为double类型：byte、char、short、int、long、float–>double
强制类型转换
强制类型转换也叫显示类型转换，指的是两种数据类型之间的转换需要进行显示地声明。当两种类型彼此不兼容，或者目标类型取值范围小于源类型，自动类型转换无法进行，这时就需要进行强制类型转换。
int a=4; byte b=(byte)a；一个字节的变量b无法存储四个字节的变量a，在这种情况下就需要进行强制类型转换。
但强制类型转换极容易造成 数据精度的丢失。
int a=298; byte b=(byte)a; System.out.println("a="+a); System.out.println("b="+b);输出结果为
a=298 b=42变量a的值本来为298，然而在赋值给变量b之后，其值为42，明显丢失了精读。
因为a是int类型，在内存中占用4个字节，byte类型的数据在内存中占用1个字节。当将变量b的类型强转为byte类型之后，前面3个高位字节的数据丢失，数值发生改变。
int 00000000 00000000 00000001 00101010 byte 00101010表达式类型自动提升
表达式是指由变量和运算符组成的一个算式。变量在表达式中进行运算时，也可能发生自动类型转换，这就是表达式数据类型的自动提升，如一个byte型的变量在运算期间类型会自动提升为int型。
byte b1=3; byte b2=4; byte b3=b1+b2; System.out.println("b3="+b3);运行时会报错，因为表达式b1+b2运算期间，变量b1和b2都会被自动提升为int型，表达式的运算结果也就变成了int型，这时如果将结果赋给byte型的变量就会报错，需要进行强制类型转换。
byte b3=(byte)b1+b2;
变量的作用域
变量需要在它的作用范围内才可以被使用，这个作用范围称为变量的作用域。
在程序中，变量一定会被定义在某一对大括号中，该大括号所包含的代码区域便是这个变量的作用域。
Java中的运算符
算数运算符
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| + | 正号 | +3 | 3 |
| - | 负号 | b=4;-b; | -4 |
| + | 加 | 5+5 | 10 |
| - | 减 | 6-4 | 2 |
| * | 乘 | 3*4 | 12 |
| / | 除 | 5/5 | 1 |
| % | 取模（即算数中的求余数） | 7%5 | 2 |
| ++ | 自增（前） | a=2;b=++a; | a=3;b=3 |
| ++ | 自增（后） | a=2;b=a++; | a=3;b=2 |
| – | 自增（前） | a=2;b=–a; | a=1;b=1 |
| – | 自增（后） | a=2;b=a–; | a=1;b=2 |
- 在进行自增++和自增–的运算时，如果运算符++或–放在操作数的前面则是先进行自增或自减运算，再进行其他运算。反之，如果运算符放在操作数的后面则是先进行其他运算再进行自增或自减运算。
- 在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果会是一个小数。
- 在进行取模（%）运算时，运算结果的正负取决于被模数（%左边的数）的符号，与模数（%右边的数）的符号无关。
赋值运算符
赋值运算符的作用就是将常量、变量或表达式的值赋给某一个变量。
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| = | 赋值 | a=3;b=2; | a=3;b=2; |
| += | 加等于 | a=3;b=2;a+=b; | a=5;b=2; |
| -= | 减等于 | a=3;b=2;a-=b; | a=1;b=2; |
| *= | 乘等于 | a=3;b=2;a*=b; | a=6;b=2; |
| /= | 除等于 | a=3;b=2;a/=b; | a=1;b=2; |
| %= | 模等于 | a=3;b=2;a%=b; | a=1;b=2; |
在赋值过程中，运算顺序从右往左，将右边表达式的结果赋值给左边的变量。
x+=3;就相当于x=x+3;
将一个int类型的值赋给一个short类型的变量，需要显示地进行强制类型转换。然而在使用+=，-+，*=，/=，%=运算符进行赋值时，强制类型转换会自动完成，程序不需要做任何显式子地声明。
比较运算符
比较运算符用于对两个数值或变量进行比较，其结果是一个布尔值，即true或false。
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| == | 相等于 | 4==3 | false |
| != | 不等于 | 4!=3 | true |
| < | 小于 | 4<3 | false |
| > | 大于 | 4>3 | true |
| >= | 小于等于 | 4<=3 | false |
| <= | 大于等于 | 4>=3 | true |
注意不能将比较运算符==误写成赋值运算符=。
逻辑运算符
逻辑运算符用于对布尔型的数据进行操作，其结果仍是一个布尔型。
| 运算符 | 运算 | ||
|---|---|---|---|
| & | 与 | 两边都是true才为true | |
| | | 或 | 有一个true就为true | |
| ^ | 异或 | 两边不同为true | |
| ! | 非 | ||
| && | 短路与 | ||
| || | 短路或 |
在使用&进行运算时，无论左边为true或者false，右边的表达式都会进行运算。
如果使用&&进行运算，当左边为false时，右边的表达式不会进行运算。
位运算符
位运算符是针对二进制数的每一位进行运算的符号，它是专门针对数字0和1进行操作的。
| 运算符 | 运算 | ||
|---|---|---|---|
| & | 按位与 | ||
| | | 按位或 | ||
| ~ | 取反 | ||
| ^ | 按位异或 | ||
| << | 左移 | 10010011<<2 | 01001100 |
| >> | 右移 | ||
| >>> | 无符号右移 |
1代表true
位运算<<就是将操作数所有二进制位向左移动。运算时，右边的空位补0。左边移走的部分舍去。
位运算符>>就是将操作数所有二进制位向右移动。运算时，左边的空位根据原数的符号位补0或者1（原来是负数就补1，是正数就补0）。
位运算符>>>就是将操作数所有二进制位向右移动一位。运算时，左边的空位补0（不考虑原数正负）
运算符的优先级
在对一些比较复杂的表达式进行运算时，要明确表达式中所有运算符参与运算的先后顺序。
数字越小优先级越高。
| 优先级 | 运算符 |
|---|---|
| 1 | . [ ] ( ) |
| 2 | ++ - - ~ ! (数据类型) |
| 3 | * / % |
| 4 | + - |
| 5 | << >> >>> |
| 6 | < > <= >= |
| 7 | == != |
| 8 | & |
| 9 | ^ |
| 10 | | |
| 11 | && |
| 12 | || |
| 13 | ?: |
| 14 | = *= /= %= += -= <<= >>= >>>= &= ^= |= |
编写程序时，尽量使用括号（）来实现想要的运算顺序，以免产生歧义。
选择结构语句
if条件语句
if语句：判断条件是一个布尔值，当判断条件为true时，{}中的执行语句才会执行。
if(判断条件){ 代码块 }if···else语句：判断条件为真，执行语句1，为false执行语句2
if(判断条件){ 执行语句1 }else{ 执行语句2 }三元运算符
判断条件？表达式1：表达式2三元运算符会得到一个结果，通常用于对某个变量进行赋值，当判断条件为真时，结果为1的值，否则结果为表达式2的值。
int max=x>y?x:y;if···else if···else语句
if···else if···else语句用于对多个条件进行判断，进行多种不同的处理。
if(判断条件1){ 执行语句1 }else if（判断条件2）{ 执行语句2 } ... else if(判断条件n){ 执行语句n }else{ 执行语句n+1 }当判断条件1为true时，会执行语句1。为false时，会执行判断条件2，如果为true则执行语句2，依次类推，如果所有的判断条件都为false，则意味着所有条件均为满足，else后面{}中的执行语句n+1会执行。
switch条件语句
switch(表达式){
case 目标值1：
执行语句1
break；
case 目标值2：
执行语句2
break；
...
case 目标值n：
执行语句n
break；
default:
执行语句n+1
break;
}switch语句将表达式的值与每个case中的目标值进行匹配，如果找到了匹配的值，会执行对应case后的语句，如果没有找到任何匹配的值，就会执行default后的语句。
在switch语句中的表达式只能是byte、short、char、int类型的值，如果传入其他类型的值，程序会报错。但这样说也不严谨，在JDK5.0中引入的新特性enum枚举和在JDK7.0中引入的新特性String类型也可以。
在使用switch语句中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可，这是一种简写的方式。
int week=2;
switch(week){
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("今天是工作日");
break；
case 6:
case 7:
System.out.println("今天是休息日");
break;
}循环结构语句
while循环语句
while(循环条件){ 执行语句 }{}中的执行语句被称作循环体。当循环条件为true时，循环体就会执行。循环体执行完毕时会继续判断循环条件，如条件仍为true则会继续执行，直到循环条件为false时，整个循环过程才会结束。
do···while循环语句
do{ 执行语句 }while(循环条件);循环体会无条件执行一次，然后再根据循环条件来决定是否继续执行。
for循环语句
for循环语句是最常用的循环语句，一般用在循环次数已知的情况下。
for(初始化表达式；循环条件；操作表达式){ 执行语句 }先执行初始化表达式，然后判断循环条件，为false就退出循环，为true的话就执行语句，然后执行操作表达式，然后再判断循环条件。。。
嵌套循环
嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do···while、for循环语句都有可以进行嵌套，并且它们之间也可以互相嵌套。
跳转语句（break、continue）
break语句
在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出循环语句，执行后面的代码。
continue语句
continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。
方法
什么是方法
将重复的代码提取出来封装成一个方法。
修饰符 返回值类型 方法名（[参数类型 参数名1，参数类型 参数名2，···]）{
执行语句
return 返回值；
}- 修饰符：对访问权限进行限定。
- 返回值类型： 用于限定返回值的数据类型
- 参数类型：用于限定调用方法时传入参数的数据类型
- 参数名：是一个变量，用于接收调用方法时传入的数据。
- return关键字：用于结束方法及返回方法指定类型的值。
- 返回值：被return语句返回的值，该值会返回给调用者。
方法中的“参数类型 参数名1，参数类型 参数名2”被称作参数列表，它用于描述方法在被调用时需要接收的参数，如果方法不需要接收任何参数，则参数列表为空，即（）内不写任何内容。方法的返回值必须为方法声明的返回值类型，如果方法中没有返回值，返回值类型要声明为void，此时，方法中return语句可以省略。
方法的重载
在一个程序中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。
方法的重载与返回值类型无关，它只需要满足两个条件，一是方法名相同，二是参数个数或参数类型不相同。
方法的递归
方法的递归是指在一个方法的内部调用自身的过程，递归必须要有结束条件，不然就会陷入无限递归的状态，永远无法结束调用。
数组
数组是指一组数据的集合，数组中的每个数据都被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。数组可以分为一维数组和多维数组。
数组的定义
int[] x=new int[100];
上述语句就相当于在内存中定义了100个int类型的变量，第一个变量的名称为x[0]，第二个变量的名称为x[1]，依此类推，第100个变量的名称为x[99]，这些变量的初始值都是0。
上面的一句代码可以分成两句话来写。
int[] x; //声明一个int[]类型的变量
x=new int[100];//创建一个长度为100的数组第一行代码int[] x;声明了一个变量x，该变量的类型为int[]，即一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值。
第二行代码x=new int[100]，创建了一个数组，将数组的地址赋值给变量x。
数组中的每个元素都有一个索引（也可称为角标），要想访问数组中的元素可以通过x[0]、x[1]···x[98]、x[99]的形式。
数组中最小的索引是0，最大的索引是“数组的长度-1”。
为了方便获取数组的长度，提供了一个length属性，在程序中可以通过“数组名.length”的方式来获得数组的长度，即元素的个数。
| 数据类型 | 默认初始化值 |
|---|---|
| byte、short、int、long | 0 |
| float、double | 0.0 |
| char | 一个空字符，即‘\u0000’ |
| boolean | false |
| 引用数据类型 | null，表示变量不引用任何对象 |
在定义数组时只指定数组的长度，由系统自动为元素赋初值的方式称作动态初始化。
在初始化数组时还有一种方式叫做静态初始化，就是定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式。
类型 [] 数组名=new 类型 []{元素，元素，······};
类型 [] 数组名={元素，元素，······};为了简便，建议采用第二种方式。
数组的常见操作
数组遍历
在操作数组时，经常需要依次访问数组中的每个元素，这种操作称作数组的遍历。
int[] arr={1,2,3,4,5}; for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); }数组最值
数组排序
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
