JAVA基础语法
一、 标识符
类名、变量名以及方法名都被称为标识符。
关于 Java 标识符，有以下几点需要注意：
l 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
l 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
l 关键字不能用作标识符
l 标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary
二、 关键字
下面列出了 Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。
| 类别 | 关键字 | 说明 |
| 访问控制 | private | 私有的 |
| protected | 受保护的 | |
| public | 公共的 | |
| 类、方法和变量修饰符 | abstract | 声明抽象 |
| class | 类 | |
| extends | 扩充,继承 | |
| final | 最终值,不可改变的 | |
| implements | 实现（接口） | |
| interface | 接口 | |
| native | 本地，原生方法（非 Java 实现） | |
| new | 新,创建 | |
| static | 静态 | |
| strictfp | 严格,精准 | |
| synchronized | 线程,同步 | |
| transient | 短暂 | |
| volatile | 易失 | |
| 程序控制语句 | break | 跳出循环 |
| case | 定义一个值以供 switch 选择 | |
| continue | 继续 | |
| default | 默认 | |
| do | 运行 | |
| else | 否则 | |
| for | 循环 | |
| if | 如果 | |
| instanceof | 实例 | |
| return | 返回 | |
| switch | 根据值选择执行 | |
| while | 循环 | |
| 错误处理 | assert | 断言表达式是否为真 |
| catch | 捕捉异常 | |
| finally | 有没有异常都执行 | |
| throw | 抛出一个异常对象 | |
| throws | 声明一个异常可能被抛出 | |
| try | 捕获异常 | |
| 包相关 | import | 引入 |
| package | 包 | |
| 基本类型 | boolean | 布尔型 |
| byte | 字节型 | |
| char | 字符型 | |
| double | 双精度浮点 | |
| float | 单精度浮点 | |
| int | 整型 | |
| long | 长整型 | |
| short | 短整型 | |
| 变量引用 | super | 父类,超类 |
| this | 本类 | |
| void | 无返回值 | |
| 保留关键字 | goto | 是关键字，但不能使用 |
| const | 是关键字，但不能使用 | |
| null | 空 |
三、 基本数据类型
| 分类 | 类型 | 说明 |
| 整数型 | byte | byte 数据类型是8位、有符号的，以二进制补码表示的整数； 最小值是 -128（-2^7）； 最大值是 127（2^7-1）； byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一； 例子：byte a = 100，byte b = -50。 |
| short | short 数据类型是 16 位、有符号的以二进制补码表示的整数 最小值是 -32768（-2^15）； 最大值是 32767（2^15 - 1）； Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一； 例子：short s = 1000，short r = -20000。 | |
| int | int 数据类型是32位、有符号的以二进制补码表示的整数； 最小值是 -2,147,483,648（-2^31）； 最大值是 2,147,483,647（2^31 - 1）； 一般地整型变量默认为 int 类型； 例子：int a = 100000, int b = -200000。 | |
| long | long 数据类型是 64 位、有符号的以二进制补码表示的整数； 最小值是 -9,223,372,036,854,775,808（-2^63）； 最大值是 9,223,372,036,854,775,807（2^63 -1）； 这种类型主要使用在需要比较大整数的系统上； 例子： long a = 100000L，Long b = -200000L。 "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。 | |
| 浮点型 | float | float 数据类型是单精度、32位、符合IEEE 754标准的浮点数； float 在储存大型浮点数组的时候可节省内存空间； 浮点数不能用来表示精确的值，如货币； 例子：float f1 = 234.5f。 |
| double | double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数； 浮点数的默认类型为double类型； double类型同样不能表示精确的值，如货币； 例子：double d1 = 123.4。 | |
| 字符型 | char | char类型是一个单一的 16 位 Unicode 字符； 最小值是 \u0000（即为0）； 最大值是 \uffff（即为65,535）； char 数据类型可以储存任何字符； 例子：char letter = 'A';。 |
| 布尔型 | boolean | boolean数据类型表示一位的信息； 只有两个取值：true 和 false； 这种类型只作为一种标志来记录 true/false 情况； 例子：boolean one = true。 |
类型默认值
| 数据类型 | 默认值 |
| byte | 0 |
| short | 0 |
| int | 0 |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
| char | 'u0000' |
| String (or any object) | null |
| boolean | false |
四、 运算符
l 算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。
l 自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算；后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算。
l 位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。位运算符作用在所有的位上，并且按位运算。
l 逻辑运算符，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。
l 条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
l instanceof 运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
| 分类 | 操作符 | 描述 | 例子 |
| 算术运算符 | + | 加法 - 相加运算符两侧的值 | A + B 等于 30 |
| - | 减法 - 左操作数减去右操作数 | A – B 等于 -10 | |
| * | 乘法 - 相乘操作符两侧的值 | A * B等于200 | |
| / | 除法 - 左操作数除以右操作数 | B / A等于2 | |
| ％ | 取余 - 左操作数除以右操作数的余数 | B%A等于0 | |
| ++ | 自增: 操作数的值增加1 | B++ 或 ++B 等于 21（区别详见下文） | |
| -- | 自减: 操作数的值减少1 | B-- 或 --B 等于 19（区别详见下文） | |
| 关系运算符 | == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | （A == B）为假。 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (A != B) 为真。 | |
| > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 | （A> B）为假。 | |
| < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 | （A <B）为真。 | |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 | （A> = B）为假。 | |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 | （A <= B）为真。 | |
| 位运算符 | ＆ | 如果相对应位都是1，则结果为1，否则为0 | （A＆B），得到12，即0000 1100 |
| | | 如果相对应位都是0，则结果为0，否则为1 | （A | B）得到61，即 0011 1101 | |
| ^ | 如果相对应位值相同，则结果为0，否则为1 | （A ^ B）得到49，即 0011 0001 | |
| 〜 | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 | （〜A）得到-61，即1100 0011 | |
| << | 按位左移运算符。左操作数按位左移右操作数指定的位数。 | A << 2得到240，即 1111 0000 | |
| >> | 按位右移运算符。左操作数按位右移右操作数指定的位数。 | A >> 2得到15即 1111 | |
| >>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 | A>>>2得到15即0000 1111 | |
| 逻辑运算符 | && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 | （A && B）为假。 |
| | | | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 | （A | | B）为真。 | |
| ！ | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 | ！（A && B）为真。 | |
| 赋值运算符 | = | 简单的赋值运算符，将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
| + = | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 | C + = A等价于C = C + A | |
| - = | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 | C - = A等价于C = C - A | |
| * = | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 | C * = A等价于C = C * A | |
| / = | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 | C / = A等价于C = C / A | |
| （％）= | 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 | C％= A等价于C = C％A | |
| << = | 左移位赋值运算符 | C << = 2等价于C = C << 2 | |
| >> = | 右移位赋值运算符 | C >> = 2等价于C = C >> 2 | |
| ＆= | 按位与赋值运算符 | C＆= 2等价于C = C＆2 | |
| ^ = | 按位异或赋值操作符 | C ^ = 2等价于C = C ^ 2 | |
| | = | 按位或赋值操作符 | ||
| 条件运算符 | ?: | 条件运算符也被称为三元运算符。 | |
| instanceof | instanceof | 该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。 |
Java运算符优先级
当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。
下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。
| 类别 | 操作符 | 关联性 |
| 后缀 | () [] . (点操作符) | 左到右 |
| 一元 | + + - ！〜 | 从右到左 |
| 乘性 | * /％ | 左到右 |
| 加性 | + - | 左到右 |
| 移位 | >> >>> << | 左到右 |
| 关系 | >> = << = | 左到右 |
| 相等 | == != | 左到右 |
| 按位与 | ＆ | 左到右 |
| 按位异或 | ^ | 左到右 |
| 按位或 | | | 左到右 |
| 逻辑与 | && | 左到右 |
| 逻辑或 | | | | 左到右 |
| 条件 | ？： | 从右到左 |
| 赋值 | = + = - = * = / =％= >> = << =＆= ^ = | = | 从右到左 |
| 逗号 | ， | 左到右 |
五、 表达式和语句
l Java 表达式是变量、字面量、常量、运算符、方法调用的运算，它们组合在一起生成或计算一个值的语句被称为表达式。表达式是一个能够提供值的语句。
l Java 程序中的代码执行指令，都可以分解为一系列的语句。Java 语句就是一条简单的操作指令，它可以让计算机执行某种操作。
l Java 语句以分号（ ; ）结束/结尾。通常，一条语句占一行，如果想要结束该条语句的话，需要使用分号（ ; ）结尾。
表达式和语句的区别：
l 一个语句可以由一个表达式组成也可以由多个表达式组成，或者可以没有表达式。
l 表达式（Expression）有值，而语句（Statement）不总有。
l 表达式可以作为语句的是赋值表达式、自增/减表达式以及方法调用表达式。
六、 分支
Java 条件语句 - if...else
if 语句的语法如下：
if(布尔表达式) {
//如果布尔表达式为true将执行的语句
}
if…else 的用法如下：
if(布尔表达式){
//如果布尔表达式的值为true }else{ //如果布尔表达式的值为false
}
if...else if...else的用法如下：
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码
}else {
//如果以上布尔表达式都不为true执行代码
}
嵌套的 if…else 语法格式如下：
if(布尔表达式 1){
如果布尔表达式 1的值为true执行代码
if(布尔表达式 2){
如果布尔表达式 2的值为true执行代码
}
}
Java switch case 语句
switch case 语句语法格式如下：
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
switch case 语句有如下规则：
l switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
l switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。
l case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。
l 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。
l 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
l switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。
七、 循环
Java中有三种主要的循环结构：
l while 循环
l do…while 循环
l for 循环
while 循环
while是最基本的循环，只要布尔表达式为 true，循环就会一直执行下去。
它的结构为：
while( 布尔表达式 ) {
//循环内容
}
do…while 循环
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
它的结构为：
do{
//循环内容
}while( 布尔表达式 )
For 循环
虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。for循环执行的次数是在执行前就确定的。
它的结构为：
for(初始化; 布尔表达式; 更新) {
//代码语句
}
关于 for 循环有以下几点说明：
l 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
l 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
l 执行一次循环后，更新循环控制变量。
l 再次检测布尔表达式。循环执行上面的过程。
Java 增强 for 循环
Java5 引入了一种主要用于数组的增强型 for 循环。Java 增强 for 循环语法格式如下:
for(声明语句 : 表达式) {
//代码句子
}
l 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
l 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
break 关键字
l break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
l break 跳出最里层的循环，并且继续执行该循环下面的语句。
continue 关键字
l continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
l 在 for 循环中，continue 语句使程序立即跳转到更新语句。
l 在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
八、 方法
方法的定义
一般情况下，定义一个方法包含以下语法：
修饰符 返回值类型 方法名(参数类型 参数名){ ... 方法体 ... return 返回值; }
方法包含一个方法头和一个方法体。下面是一个方法的所有部分：
l 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
l 返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
l 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
l 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
l 方法体：方法体包含具体的语句，定义该方法的功能。
调用一个方法时候需要提供参数，你必须按照参数列表指定的顺序提供。
方法的重载
l 一个类的两个方法拥有相同的名字，但是有不同的参数列表。
l Java编译器根据方法签名判断哪个方法应该被调用。
l 方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。
l 重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。
构造方法
l 当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。
l 通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。
l 不管你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，默认构造方法的访问修改符和类的访问修改符相同(类为 public，构造函数也为 public；类改为 private，构造函数也改为 private)。
l 一旦你定义了自己的构造方法，默认构造方法就会失效。
可变参数
JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。
方法的可变参数的声明如下所示：
typeName... parameterName
在方法声明中，在指定参数类型后加一个省略号(...) 。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
finalize() 方法
Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。
例如，你可以使用 finalize() 来确保一个对象打开的文件被关闭了。
在 finalize() 方法里，你必须指定在对象销毁时候要执行的操作。
finalize() 一般格式是：
protected void finalize() { // 在这里终结代码 }
关键字 protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用。
当然，Java 的内存回收可以由 JVM 来自动完成。如果你手动使用，则可以使用上面的方法。
九、 变量及作用域
Java语言支持的变量类型有：
l 类变量：独立于方法之外的变量，用 static 修饰。
l 实例变量：独立于方法之外的变量，不过没有 static 修饰。
l 局部变量：类的方法中的变量。
Java 局部变量
l 局部变量声明在方法、构造方法或者语句块中；
l 局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
l 访问修饰符不能用于局部变量；
l 局部变量只在声明它的方法、构造方法或者语句块中可见；
l 局部变量是在栈上分配的。
l 局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
l 变量的范围是程序中该变量可以被引用的部分。
l 方法内定义的变量被称为局部变量。
l 局部变量的作用范围从声明开始，直到包含它的块结束。
l 局部变量必须声明才可以使用。
l 方法的参数范围涵盖整个方法。参数实际上是一个局部变量。
l for循环的初始化部分声明的变量，其作用范围在整个循环。
l 但循环体内声明的变量其适用范围是从它声明到循环体结束。它包含如下所示的变量声明：
l 你可以在一个方法里，不同的非嵌套块中多次声明一个具有相同的名称局部变量，但你不能在嵌套块内两次声明局部变量。
实例变量
l 实例变量声明在一个类中，但在方法、构造方法和语句块之外；
l 当一个对象被实例化之后，每个实例变量的值就跟着确定；
l 实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
l 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
l 实例变量可以声明在使用前或者使用后；
l 访问修饰符可以修饰实例变量；
l 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
l 实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
l 实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
类变量（静态变量）
l 类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
l 无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
l 静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
l 静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
l 静态变量在第一次被访问时创建，在程序结束时销毁。
l 与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
l 默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
l 静态变量可以通过：ClassName.VariableName的方式访问。
l 类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
【注】：内容通过菜鸟教程等网络资料整理而来。
扫一扫
1542
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
