Java基础（二）基础语法
本文抄于：https://www.cnblogs.com/adamjwh/p/8322434.html
Java关键字
一、Java程序的基本结构
一个Java程序的基本结构大体可以分为包、类、main()主方法、标识符、关键字、语句和注释等，如下：
1 package hello; // 定义包
2
3 public class Structure { // 创建类
4
5 static int num = 1; // 定义类的成员变量
6
7 public static void main(String[] args) { // 定义主方法
8
9 String str = "http://www.cnblogs.com/adamjwh/"; // 定义局部变量
10
11 System.out.println(num); // 输出成员变量的值
12
13 System.out.println(str); // 输出局部变量的值
14
15 }
16
17 }
我们来逐一分析一下每一条语句，过多的概念我就不详述了，只说最基本的。
第一条语句“package hello;”定义了Java程序中类所在的包是hello，hello是一个标识符，由程序员自己定义，package是关键字。注意：标识符和关键字区分大小写。
第二条语句“public class Structure”用于创建一个名为Structure的类，类名由程序员自己定义，其中public及class是关键字，关于public和static的用法会在后续篇章中提到。
第三条语句“static int num = 1;”定义了类的成员变量，static和int都是关键字，而num是一个标识符，由程序员自己定义。
第四条语句“public static void main(String[] args)”是类的主方法，Java程序从这里开始执行，除了可以将“String[] args”改为“String args[]”外，不可改变本条语句的任何部分。
第五条语句“String str = "http://www.cnblogs.com/adamjwh”是在主方法中定义了一个局部变量，String是一个类，用于创建字符串对象（说简单点就是说，如果你想创建一条字符串，就使用String类），str是局部变量的名称，为程序员自己定义的一个标识符，而后面引号中的网址是局部变量str的值，“=”为赋值运算符。
第六条语句“System.out.println(num);”是输出语句，这是输出语句的固定写法，注意区分大小写，输出换行为println，不换行为print。
第七条语句同样为输出语句，执行将输出str的值，即http://www.cnblogs.com/adamjwh。
二、标识符和关键字
标识符可以简单理解为一个名字，用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。
例如，定义一个变量i并赋值为100，那么我们可以写出如下代码： int i = 100;
命名规则：
a.标识符可以包含字母、数字、下划线"_"、美元符号"$"。
b.标识符不能是关键字或保留字
c.标识符不能以数字开头
d.标识符是区别大小写的，并且没有规定最大长度
例如：identifier、User_name、_sys_varl 、$change等等
命名规范：
a."见名知意"（选择简洁的英文单词作为标识符）
b.每一个单词以小写字母开始，第二个单词的首字母大写（变量、方法命名）
c.每一个单词的首字母都采用大写字母（类的命名）
例如： myStudentCount、DataBaseUser
d.单词之间不以空格断开或连接号（-）、底线（_）连结，每个单词的首字母大写（Pascal命名法）
例如： FirstName、UserName
上面提到的关键字和保留字，是Java语言中已经被赋予特定意义的一组单词，不可作为标识符使用，比如上面代码中的int就是关键字，至于java的关键字有哪些我就不过多的描述了，毕竟网上有很多很详细的介绍，我们还是主要从代码入手。
三、基本数据类型
了解了上面的Java程序的基本结构后是不是对Java有一定的感觉了呢，那么编写程序肯定要用到许许多多数据，那Java中的数据又是如何分类及编写的呢？
在Java中有8种数据类型，其中6种是数值类型，另外两种分别是字符类型和布尔类型，如下：
整型默认是int；
浮点型默认是double；
1 public class Type {
2
3 /* 整数类型 */
4 byte myByte = 45; // byte型变量，占一个字节，取值范围-128~127
5 short myShort = 100; // short型变量，也即短整型，占两个字节，取值范围-32768~32767
6 int myInt = 450; // int型变量，也即整型，占四个字节，取值范围-2147483648~2147483647
7 long myLong = 45261636L; // long型变量，也即长整型，占八个字节，取值范围-9223372036854775808~9223372036854775807
8
9 /* 浮点类型 */
10 float myFloat = 15.621F; // 单精度浮点型，占四个字节，结尾必须加'F'或'f'，如果不加自动定义为double型变量，取值范围1.4E-45~3.4028235E-38
11 double myDouble = 15.621D; // 双精度浮点型，占八个字节，结尾可以加'D'或'd'，也可不加，取值范围4.9E-324~1.7976931348623157E-308
12
13 /* 字符类型 */
14 char myChar = 'a'; // 字符类型变量，用于存储单个字符，占两个字节，需用单引号括起来
15
16 /* 布尔类型 */
17 boolean myBoolean = true; // 布尔类型又称逻辑类型，只有true和false两个值，分别代表“真”和“假”
18 }
当我们要定义一个变量的时候，先判断变量的数据类型，再从上方8种类型中选择合适的类型使用即可，定义方法就如上方代码，以“[数据类型] [变量名] = [值]”的形式即可，其中变量名需自起名，满足上面提到的标识符的几个条件。
在字符类型中还有一种特殊的字符，以反斜线“\”开头，后跟一个或多个字符，具有特定的含义，叫做转义字符。
转义字符 含义
\ddd 1~3位八进制数据所表示的字符，如\456
\dxxxx 4位十六进制所表示的字符，如\0051
\' 单引号字符
\\ 反斜杠字符
\t 垂直制表符，将光标移到下一个制表符的位置
\r 回车
\n 换行
\b 退格
\f 换页
转义字符一般多用于输出，比如“\n”回车换行，“\t”移到下一制表位，如果想要输出单引号、双引号、下划线等字符时，也需要用转义字符进行输出。
四、变量与常量
刚刚我们提到了变量，接下来就说一下什么是变量和常量。在程序执行过程中，其值不能改变的称为常量，其值能改变的称为变量。变量与常量的声明都必须使用合法的标识符，所有变量与常量只有在声明之后才能使用。
变量的概念：
- 内存中的一个存储区域
- 该区域有自己的名称（变量名）和类型（数据类型）和值
- Java中每个变量必须先声明，再赋值，然后才能使用
- 该区域的数据可以在同一类型范围内不断变化
- Java 中的变量有四个基本属性：变量名，数据类型，存储单元和变量值
变量名：合法的标识符
变量的数据类型：可以是基本类型和引用类型（必须包含类型）
存储单元：存储单元大小是由数据类型决定的，如：int 为4 个字节32 位
变量值：在存储单元中放的就是变量值（如果是基本类型放的就是具体值，如果是引用类型放的是内存地址，如果null，表示不指向任何对象）
定义变量的格式：数据类型 变量名 = 初始化值;
变量是通过使用变量名来访问这块区域的。
使用变量注意：
- 变量的作用域：一对{ }之间有效。出了大括号就不认识了。
- 初始化值
- 变量可以重复赋值，但不能重复声明，在同一个域中，变量名不能重复。
- 定义long类型时候整数太大，在变量值后面加上“L”。
- 定义float类型时候为了防止类型不兼容，在变量值后面加上“F”。
下面举一个声明变量的例子：
int age; // 声明int型变量 char c = 'J' // 声明char型变量并赋值
既然叫变量那肯定是能改变的，现在我们对变量进行一下改变试试：
1 public class Variable {
2
3 public static void main(String[] args) {
4 int num = 10; // 定义一个变量num，并赋给初值10
5 System.out.println("num的初值为："+num); // 输出当前变量num的值为10
6
7 num = 100; // 将100赋给num
8 System.out.println("num现在的值为："+num); // 输出现在变量num的值为100
9 }
10
11 }
上方是一段测试代码，我们首先定义一个变量，起名为num，然后对它赋一个初值10，再对这个变量赋值为100，看两次值的变化，运行结果如下所示：
由此可以看出变量是在运行过程中其值可以改变。
而常量在整个程序中只能被赋值一次，需通过final关键字进行限定，如 final double PI = 3.1415926; ，为定义一个常量，名为PI（圆周率），我们如果单独定义一个变量是“double PI = 3.1415926;”，现在定义一个常量就是在double前加一个final关键字进行限定即可。
看到这里，是不是对Java的声明及定义有一些了解了呢？也许在之前大家也都见到了有些变量前有static这个关键字，它有什么用呢？这里就要说的变量的有效范围了。
变量的有效范围是指程序代码能够访问该变量的区域，若超出变量所在区域访问变量则编译时会出现错误。可分为“成员变量”和“局部变量”。
在类体中定义的变量被称为成员变量，成员变量在整个类中都有效，分为静态变量和实例变量两种。
class var {
int x = 45; // 定义实例变量
static int y = 90; // 定义静态变量
}
其中x是实例变量，y是静态变量。如果成员变量的类型前面加上static，就被称为静态变量，静态变量的有效范围可以跨类，甚至可达到整个应用程序之内，也可用“类名.静态变量”的方式在其它类中使用（具体会在今后的篇幅中出现，想了解的可先行查阅资料）。
而在类的方法体中定义的变量（即“{”与“}”之间的声明变量）称之为局部变量。只在当前代码块中有效，简单点来说就是只在其所定义的大括号中有效。下面举一个例子：
1 public class Val {
2
3 static int times = 3; // 定义成员变量times
4 public static void main(String[] args) {
5 int times = 4; // 定义局部变量times
6
7 System.out.println("times的值为：" + times); // 将times输出
8 System.out.println("静态变量times的值为：" + Val.times); // 输出静态变量
9 }
10
11 }
输出结果为：
从这段代码可以看出，首先在main方法外定义了一个成员变量times，并且是一个静态变量，而在main方法内又定义了一个局部变量times。这里有人就会问了，变量名不是不能相同吗？注意，这里第一个times是成员变量，作用范围是针对于整个类而言，而第二个times是局部变量，只在main方法内有效，所以两个重名并不冲突。但如果我们直接输出times，如第一个输出，输出结果为4，是局部变量起了作用，因为当局部变量与成员变量名字相同时，此时成员变量将被隐藏，即这个成员变量在此方法中暂时失效。如果我们想调用成员变量，需要使用“类名.静态变量”调用，如第二个输出，类名为Val，静态变量名为times，用“Val.times”即可调用静态变量的值为3。
五、代码注释
注释可以提高程序的可读性，注释包含的文字不会对程序产生任何影响，在Java中，代码注释主要有以下几种：
1. 单行注释
“//”为单行注释标记，从“//”开始到换行为止的所有内容均被注释而被编译器忽略。
// 这是一条单行注释
2. 多行注释
“/* */”为多行注释标记，符号“/*”与“*/”之间的所有内容均为注释内容，可以换行。
/*
注释内容1
注释内容2
......
*/
在多行注释中可以嵌套单行注释，比如下面的用法是正确的：
/*
名称：博客园 // 时间：2018-1-20
*/
但在多行注释中不能嵌套多行注释。
3. 文档注释
“/** */”为文档注释标记。符号“/**”与“*/”之间的内容均为文档注释内容。当文档注释出现在任何声明之前时，会被Javadoc文档工具读取作为Javadoc文档内容。格式与多行注释相同。
1 /** 2 * name: Hello World 3 * time: 2018-1-20 4 * author: Adam 5 **/
六、运算符
1. 赋值运算符
赋值运算符即“=”，是一个二元运算符（即对两个操作数进行处理），其功能是将右方操作数所含的值赋值给左方的操作符。其中左方必须是一个变量，而右边所赋的值可以使任何数值或表达式，例子如下：
int a = 10; // 将10赋给a int b = 5; // 将5赋给b int c = a+b; // 将变量a和b进行运算后的结果赋给c
也可先定义变量再进行赋值运算，如：
int a, b, c; // 声明int型变量a、b、c a = 10; // 将10赋值给变量a c = b = a + 5; // 将a+5赋值给变量b、c
在Java中可以把赋值运算连在一起使用，比如上方b、c的运算结果都为15。
2. 算数运算符
Java中的算数运算符主要有+、-、*、/和%，分别为加、减、乘、除和求余，都是二元运算符。注意除法运算时，0不能作为除数。
1 public class Arith {
2
3 public static void main(String[] args) {
4 float num1 = 52.56f; // 声明float型变量并赋值
5 int num2 = 512; // 声明int型变量并赋值
6
7 System.out.println("num1 + num2 = " + (num1 + num2)); // 将变量相加并输出
8 System.out.println("num2 - num1 = " + (num2 - num1)); // 将变量相减并输出
9 System.out.println("num1 * num2 = " + num1 * num2); // 将变量相乘并输出
10 System.out.println("num1 / num2 = " + num1 / num2); // 将变量相除并输出
11 }
12 }
运行结果如下：
3. 自增和自减运算符
自增、自减运算符是单目运算符（只有一个操作数），可以放在操作数之前，也可以放在操作数之后。操作数必须是一个整型或浮点型变量。自增自减的作用是将变量的值加一或减一，放在操作数前后的作用不同，考试中最常出现的考题之一，需加以区分。
若自增（自减）运算符在操作数之前，如++a（--a）表示先使a的值加一（减一），再使用变量；若自增（自减）运算符在操作数之后，如--a（--a）表示先使用变量a，再对其进行加一（减一）操作，下面看一个例子：
1 public class Example {
2
3 public static void main(String[] args) {
4 int a; // 声明变量a
5
6 a = 4; // 赋值为4
7 System.out.println("++a后的值为：" + ++a); // 输出++a的值
8
9 a = 4; // 同样赋值为4（重新赋值，放止a的值已经发生改变）
10 System.out.println("a++后的值为：" + a++); // 输出a++的值
11 }
12
13 }
不妨先猜测一下结果是什么，运行结果如下：
为什么会出现两个不同的答案呢？a的值为4，++a相当于先对a进行自增再输出，也就是执行输出时，a的值已经变为5了；而a++相当于先输出a的值再自增，也就是先输出a的值为4，然后再对a进行自增，此时a为5，但4已经输出了，所以会出现这两个结果。
4. 比较运算符
比较运算符属于二元运算符，用于变量与变量之间、变量与常量之间及其它类型的信息之间的比较，运算结果是boolean型，当运算符对应关系成立时，运算结果为true，否则结果为false。
常见比较运算符有>（比较左是否大于右）、<（比较左是否小于右）、>=（比较左是否大于等于右）、<=（比较左是否小于等于右）、==（比较左是否等于右）、！=（比较左是否不等于右）。这里要特别注意，“=”是赋值运算符，“==”才是比较运算符。
1 public class Compare {
2
3 public static void main(String[] args) {
4 int num1 = 4;
5 int num2 = 5;
6
7 System.out.println("4<5: " + (num1 < num2)); // 判断4小于5是否成立
8 System.out.println("4>5: " + (num1 > num2)); // 判断4大于5是否成立
9 System.out.println("4==5: " + (num1 == num2)); // 判断4等于5是否成立
10 System.out.println("4!=5: " + (num1 != num2)); // 判断4不等于5是否成立
11 System.out.println("4>=5: " + (num1 >= num2)); // 判断4大于等于5是否成立
12 System.out.println("4<=5: " + (num1 <= num2)); // 判断4小于等于5是否成立
13 }
14
15 }
上述程序的运行结果如下：
5. 逻辑运算符
逻辑运算符包括&&（&）（逻辑与）、||（|）（逻辑或）和!（逻辑非），返回值为布尔类型，操作元也必须是布尔类型数据。其中除了“!”是一元运算符外，其余的都是二元运算符。逻辑与是左右两个表达式都为true，逻辑结果才为true；逻辑或是左右两个表达式有一个或两个表达式为true时，逻辑结果才为true。
这里就有个小知识点了，&&（||）和&（|）有什么区别呢？
以“&&”和“&”为例，这两个符号都是逻辑与，当左右两个表达式都为true时，逻辑结果才为true。使用“&”时，左右两边都会判断；而使用“&&”时，如果“&&”左边的表达式结果为false，那么计算机就不会再判断右边的结果了，直接返回逻辑结果为false，这就是它们的区别。“||”则是左边判断为true时，就不会再判断右边，而“|”两边都会判断。使用“&&”和“||”可以节省计算机判断的次数，提高效率，通常被称为“短路”，而“&”和“|”被称为“非短路”。
6. 位运算符
位运算符用于处理整型和字符型的操作数，对其内存进行操作，数据在内存中以二进制形式表示（这里二进制的表示不做过多说明，相信学计算机的朋友们都非常了解二进制存储及数据表示）。主要有~（按位取反）、&（按位与）、|（按位或）、^（安慰异或）、<<（左移）、>>（右移）、>>>（无符号右移）。
至于运算方法这里就不多赘述了，Java语言可以利用这几个位运算符帮我们进行复杂的二进制运算，得到我们想要的结果，如 48<<1 就是将48的二进制数向左移1位，结果为96。移位可实现整数除以或乘以2的n次方的效果，例如 y<<2 与y*4的结果相同，4就是2的二次方， y>>1 与y/2的结果相同，2为2的一次方。所以总结起来就是——左乘右除。
7. 三元运算符
三元运算符是Java中唯一一个三目运算符，操作数有三个，如 boolean b = 50 < 30 ? true : false; ，解释一下这句代码，首先定义一个布尔型变量b，=右边是一个三元运算符，先判断50是否小于30，如果成立，则结果为“:”左边的值（true），如果不成立，结果为“:”右边的值（false），然后将得出的值赋给=左边的b。再比如下面这个例子：
int i = 21; int j = 47; int z = i<j ? 100 : 200;
这里首先判断i<j是否成立，如果成立，z的值就是100，如果不成立，z的值就是200，因为21<47成立，所以z=100。
8. 运算符优先级
Java中表达式就是使用运算符连接起来的符合Java规则的式子，运算符的优先级决定了表达式中运算执行的先后顺序
下面是一张运算符优先级的表
| 优先级 | 运算符 |
| 1 | ( ) |
| 2 | +、- |
| 3 | ++、--、! |
| 4 | *、/、% |
| 5 | +、- |
| 6 | >>、>>>、<< |
| 7 | <、>、>=、<= |
| 8 | ==、!= |
| 9 | & |
| 10 | ^ |
| 11 | | |
| 12 | && |
| 13 | || |
| 14 | ? : |
| 15 | = |
如果两个运算符有相同的优先级，那么左边的表达式要比右边的先处理。
七、类型转换
1. 自动类型转换
Java中的8中基本类型可以混合使用，那必然会出现一个类型转换的问题，不同类型的数据在运算过程中首先会自动转换为同一类型再进行运算。自动类型转换遵循低级到高级转换的规则（占用空间越小级别越低）。
例如：
float num1 = 45f; int num2 = 120; System.out.println(num1 + num2);
这里系统首先将int型变量转换成float型变量之后再相加，所以输出为float型，结果是165.0。隐式转换规则见下表：
| 操作数1的数据类型 | 操作数2的数据类型 | 转换后的数据类型 |
| byte、short、char | int | int |
| byte、short、char、int | long | long |
| byte、short、char、int、long | float | float |
| byte、short、char、int、long、float | double | double |
2. 强制类型转换
当把高精度的变量的值赋给低精度的变量时，必须使用显式类型转换运算（又称强制类型转换），如把double、float型转换成int、long型如下：
int a = (int)42.56; // 此时a输出为42 long b = (long)467.5f // 此时b输出为467
但要注意的是，不可超出变量的取值范围，否则会数据溢出，如下方代码，由于byte型变量最大值为127，而427已经超出其取值范围，因此会发生数据溢出，造成了数据的丢失。boolean型不能转换。
short s = 427; byte b = (byte)s;
浙公网安备 33010602011771号