第三讲 Java语法基础

关键字

概述

被Java语言赋予了特殊含义的单词。

特点

关键字中所有字母都为小写。
这里将Java语言中的关键字列出如下：

用于定义数据类型的关键字
class	interface	byte	short	int
long	float	double	char	boolean
void
用于定义数据类型值的关键字
true	false	null
用于定义流程控制的关键字
if	else	switch	case	default
while	do	for	break	continue
return
用于定义访问权限修饰符的关键字
private	protected	public
用于定义类，函数，变量修饰符的关键字
abstract	final	static	synchronized
用于定义类与类之间关系的关键字
extends	implements
用于定义建立实例及引用实例，判断实例的关键字
new	this	super	instanceof
用于异常处理的关键字
try	catch	finally	throw	throws
用于包的关键字
package
其他修饰符关键字
native	strictfp	transient	volatile	assert

标识符

概述

在程序中自定义的一些名称，就是给类、接口、方法、变量等起名字时使用的字符序列。

组成规则

由26个英文字母大小写，数字： 0-9，符号： _、$ 组成。

注意事项

定义合法标识符时须注意：

1. 数字不可以开头。
2. 不可以使用关键字。
3. Java语法中严格区分大小写。

标识符常见命名规则

在起名字的时候，为了提高阅读性，要尽量有意义，即能见名知意。下面就是标识符常见的命名规范：

• 包名：多单词组成时所有字母都小写。例，xxxyyyzzz。
• 类名、接口名：多单词组成时，所有单词的首字母大写。例，XxxYyyZzz。
• 变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。例，xxxYyyZzz。
• 常量名：所有字母都大写。多单词时每个单词用下划线连接。例，XXX_YYY_ZZZ。

注释

概述

用于注解说明解释程序的文字。

Java中的注释格式

• 单行注释，格式：//注释文字
• 多行注释，格式：/* 注释文字 */
• 文档注释，格式：/** 注释文字 */

初学者编写程序应该养成习惯：先写注释再写代码。将自己的思想通过注释先整理出来，在用代码去体现，因为代码仅仅是思想的一种体现形式而已。例如：

/**
这个类是用于演示hello world.
作者：李阿昀
版本：V1.0
*/
class Demo {
    /*
    main函数可以保证该类的独立运行
    它是程序的入口
    它会被JVM所调用
    */
    public static void main(String[] args) {
        //这是输出语句用于将括号内的数据打印到控制台。
        System.out.println("hello java");
        System.out.println("hello world");
    }
}

• 对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。
• 对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。
• 注释是一个程序员必须要具有的良好编程习惯。

常量

概述

表示不能改变的数值。

Java中常量的分类

1. 整数常量。所有整数。
2. 小数常量。所有小数。
3. 布尔型常量。较为特殊，只有两个数值：true、false。
4. 字符常量。将一个数字、字母或者符号用单引号( ’ ’ )标识。
5. 字符串常量。将一个或者多个字符用双引号标识。
6. null常量。只有一个数值就是：null。

Java针对整数常量提供了四种表现形式

1. 十进制：0-9，满10进1。
2. 八进制：0-7，满8进1，用0开头表示。
3. 十六进制：0-9、A-F，满16进1，用0x或0X开头表示。
4. 二进制：0、1，满2进1。

负数在计算机内存中的二进制表现形式

负数在计算机内存中的二进制表现形式为对应的正数二进制取反加1，所以(在计算机内存中的二进制形式表现的)负数转换成十进制数就应该这样计算：对应的负数二进制减1取反，转成十进制数，最后前面加一个-。

变量

概述

内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），该区域的数据可以在同一类型范围内不断变化。我们可以理解为变量就如同数学中的未知数。

格式

数据类型 变量名 = 初始化值;。

注：格式是固定的，记住格式，以不变应万变。

为什么要定义变量？

用来不断的存放同一类型的常量，并可以重复使用。(即当数据不确定时，需要对数据进行存储时，就定义一个变量来完成存储动作。)

数据类型和类型转换

数据类型

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。如图：

这里，着重讲解基本数据类型，Java语言中的基本数据类型有：

数据类型	说明	所占内存	举例	备注
byte	字节型	1 byte	3, 127
short	短整型	2 bytes	3, 32767
int	整型	4 bytes	3, 21474836
long	长整型	8 bytes	3L, 92233720368L	long最后要有一个L字母(大小写无所谓)
float	单精度浮点型	4 bytes	1.2F, 223.56F	float最后要有一个F字母(大小写无所谓)
double	双精度浮点型	8 bytes	1.2, 1.2D, 223.56, 223.56D	double最后最好要有一个D字母(大小写无所谓)
char	字符型	2 bytes	‘a’, ‘A’	字符型数据只能是一个字符，由单引号包围
boolean	布尔型	1 bit	true, false

注意：整数默认为int，小数默认为double。
在Java中我们可以通过Integer.SIZE这样的方法直接查看基本类型所占内存空间的大小。通过以下程序就能够查看了：

class JavaType {
    public static void main(String[] args) {
        System.out.println("Byte: " + Byte.SIZE);
        System.out.println("Short: " + Short.SIZE);
        System.out.println("Integer: " + Integer.SIZE);
        System.out.println("Long: " + Long.SIZE);
        System.out.println("Float: " + Float.SIZE);
        System.out.println("Double: " + Double.SIZE);
        System.out.println("Character: " + Character.SIZE);
    }
}

输出结果为：(单位是bit)

Byte: 8(一个字节)
Short: 16(二个字节)
Integer: 32(四个字节)
Long: 64(八个字节)
Float: 32(四个字节)
Double: 64(八个字节)
Character: 16(二个字节)

boolean类型有点奇怪，官方文档是这么说的：This data type represents one bit of information, but its “size” isn’t something that’s precisely defined.，翻译为中文：这种数据类型保存一位的信息，但是它的大小却不是精确定义的。
Java基本数据类型举例如下：

int x = 4;
byte b = 2; //2是一个int常量，但是会自动判断2是不是在byte类型的范围内（-128~127），=运算符在给b赋值时，自动完成了强转操作
byte b1 = 128; //编译未通过，超出byte类型的范围
short s = 30000;
long l = 4l;

float f = 2.3f;
double d = 34.56;

char ch = '4';
char ch1 = 'a';
char ch2 = '+';
char ch3 = ' ';
char ch4 = '昀'; //一个中文在内存中占2个字节，而char就是2个字节空间大小

boolean bo = true;
boolean bo1 = false;

类型转换

自动类型转换

自动类型转换也叫隐式类型转换。表达式中的数据类型自动提升：

• 所有的byte型、 short型和char型的值将被提升到int型。
• 如果一个操作数是long型/float型/double型，计算结果就是long型/float型/double型。

例，

byte b = 3;
int x = 4;
x = x + b;//b会自动提升为int类型进行运算。

强制类型转换

强制类型转换也叫显式类型转换。例，

byte b = 3; // 3是一个int常量，但是会自动判断3是不是在byte类型的范围内（-128~127），=运算符在给b赋值时，自动完成了强转操作
b = b + 4;//报错
b = (byte)(b+4);//强制类型转换，强制将b+4的结果转换为byte类型，再赋值给b。

运算符

算术运算符

这里就不介绍具体的运算符了，只讲其注意的三个点：

• 如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论，如：-5%2=-1，面试的时候可能会考到。

• 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。如：

  int x = 4270;
  x = x / 1000 * 1000;
  System.out.println(x); // 4000

• 字符串数据和任何数据使用+都是相连接，最终都会变成字符串。如：

  System.out.println("5+5="+5+5); //"5+5=55"
  System.out.println("5+5="+(5+5)); // "5+5=10"

赋值运算符

例，

int a, b, c;
a = b = c = 5;

这里有一个N年前的面试题，虽然以后再也不会出现在如今的面试题中了，但是可以通过这样的一个例子来加深对赋值运算符的理解。思考如下代码中s = s + 2;与s += 2;的区别？

short s = 3;
s = s + 2;
s += 2;

答案：

short s = 3;
s = s + 2; // 编译失败，因为s会被提升为int类型，运算后的结果还是int类型，无法赋值给short类型
s += 2; // 编译通过，因为+=运算符在给s赋值时，自动完成了强转操作

比较运算符

这里就不介绍具体的运算符了，只讲其注意的二个点：

• 比较运算符的结果都是boolean型，也就是要么是true，要么是false。
• 比较运算符==不能误写成=。

逻辑运算符

逻辑运算符用于连接boolean类型的表达式。

&——AND(与)

boolean类型的表达式	逻辑运算符	boolean类型的表达式	结果
true	&	true	true
true	&	false	false
false	&	true	false
false	&	false	false

特点：只要两边的布尔表达式结果有一个为false，那么结果就为false。只有两边都为true，结果为true。

|——OR(或)

boolean类型的表达式	逻辑运算符	boolean类型的表达式	结果
true	|	true	true
true	|	false	true
false	|	true	true
false	|	false	false

特点：两边只要有一个为true，结果为true，两边都为false，结果为false。

^——XOR(异或)

就是和|有点不一样，当true ^ true = false时。

boolean类型的表达式	逻辑运算符	boolean类型的表达式	结果
true	^	true	false
true	^	false	true
false	^	true	true
false	^	false	false

!——Not(非)

!true = false
!fasle = true

注意：&和&&的区别以及|和||的区别

&：无论左边是true是false，右边都运算。
&&：当左边为false时，右边不运算。

|：两边都参与运算。
||：当左边为true时，右边不运算。

位运算符

位运算是直接对二进制进行运算。

位运算符	运算	范例
<<	左移	3 << 2 = 12 → 3 * 2 * 2 = 12
>>	右移	3 >> 1 = 1 → 3 / 2 = 1
>>>	无符号右移	3 >>> 1 = 1 → 3 / 2 = 1
&	与运算	6 & 3 = 2
|	或运算	6
^	异或运算	6 ^ 3 = 5
~	反码	~6 = -7

注意：

1. <<：其实就是乘以2的移动的位数次幂。
2. >>：其实就是除以2的移动的位数次幂。

位运算符的细节

位运算符	细节
<<	空位补0，被移除的高位丢弃，空缺位补0
>>	被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1
>>>	被移位二进制最高位无论是0或者是1，空缺位都用0补
&	二进制位进行&运算，只有1&1时结果是1，否则是0
|	二进制位进行|运算，只有0|0时结果是0，否则是1
^	任何相同二进制位进行^运算，结果是0：1^1=0,0^0=0；不相同二进制位^运算结果是1：1^0=1,0^1=1

观察下面的一个例子，你能得出什么结论呢？

    7 ^ 4

    111
  ^ 100 (加密)
  ------
    011
  ^ 100 (解密)，密钥：100
  ------
    111 = 7;  ----> 7 ^ 4 ^ 4 = 7;

显然，结论：一个数异或同一个数两次，结果还是那个数。这里也有一个N年前的面试题，虽然以后再也不会出现在如今的面试题中了，但是可以通过这样的一个例子来加深对位运算符的理解。请对两个整数变量的值进行互换(不需要第三方变量)。
答案：

• 第一种方式：(使用第三方变量，实际开发时使用)

  int n = 3, m = 8;
  System.out.println("n = " + n + ", m = " + m);
  
  int temp;
  temp = n;
  n = m;
  m = temp;
  
  System.out.println("n = " + n + ", m = " + m);

• 第二种方式：(不需要第三方变量，这种方式最好不要用，因为容易超出int范围)

  int n = 3, m = 8;
  System.out.println("n = " + n + ", m = " + m);
  
  n = n + m; // 如果n和m的值非常大，容易超出int范围
  m = n - m;
  n = n - m;
  
  System.out.println("n = " + n + ", m = " + m);

• 第三种方式：(不需要第三方变量，炫技型，用到了一个数异或同一个数两次，结果还是那个数的结论)

  int n = 3, m = 8;
  System.out.println("n = " + n + ", m = " + m);
  
  n = n ^ m;
  m = n ^ m; // (n ^ m) ^ m = n;
  n = n ^ m; // n ^ (n ^ m) = m;
  
  System.out.println("n = " + n + ", m = " + m);

三元运算符

格式：

(条件表达式) ? 表达式1 : 表达式2

• 如果条件为true，运算后的结果是表达式1。
• 如果条件为false，运算后的结果是表达式2。

例，取出三个数中的最大值(三元运算符的嵌套)。

int a = 2;
int b = 10;
int c = 3;
int max = a > b ? (a > c ? a : c) : (b > c ? b : c); // 取出三个数中的最大值(三元运算符的嵌套)
System.out.println("max = " + max);