第二章 Java编程基础

---

---

一． Java基本语法

1. 基本格式

Java代码放在一个类中，类使用class关键字定义，在class前面可以有类的修饰符。

修饰符 class 类名{
程序代码
}

Java程序代码分为结构定义语句和功能执行语句。

结构定义语句用于声明一个类或方法。
功能执行语句用于实现具体的功能。必须用;结束语句。

例如我们在前面一章所写的代码中的System.out.println(“hello world”);

Java语言严格区分大小写。编写时格式排版没有严格要求，但一个连续的字符串不能分成两行书写，但如果实在是要分行，需要将字符串分成两个字符串，然后用+连接起来。

2. 注释

单行注释 //注释内容
多行注释 /*注释内容*/
文档注释 /**注释内容*/

3. 标识符

  在Java中，包名，类名，方法名，参数名，变量名等，称为标识符。标识符可以由字母、数字、下画线（_）和美元符号（$）组成，但标识符不能以数字开头，不能是Java中的关键字。

Java程序标识符命名规则：
·包名的所有字母一律小写。
·类名和接口名每个单词的首字母都要大写。
·常量名的所有字母都要大写，单词之间用下画线连接。
·变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词的首字母大写。

4. 关键字

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

5. 常量

整型常量：二进制（0b或0B开头）、八进制（以0开头）、十进制（除0本身外，开头不能是0）、十六进制（0x或0X开头）。

浮点数常量：单精度浮点数（以f或F结尾）和双精度浮点数（以d或D结尾），若不加任何后缀，默认double。

字符常量：需要用’’括起来。

字符串常量：需要用””括起来。

布尔常量：true和false。

Null常量：null，表示空。

二． 变量

1. 定义

例子：

int x=0,y;
y=x+3;
定义了两个变量x和y，x在定义的同时赋值，y没有初始值。

2. 数据类型

  Java是强类型编程语言，在变量定义时必须声明变量的数据类型。Java中数据类型分为基本数据类型和引用数据类型。

3. 整数类型变量

  在为一个long类型的变量赋值时，所赋值的后面要加上字母L（或小写l），说明赋值为long类型。如果赋的值未超出int型的取值范围，则可以省略字母L（或小写l）。

4. 浮点类型变量

  在Java中，一个小数会被默认为double类型的值，因此在为一个float类型的变量赋值时，在所赋值的后面一定要加上字母F（或者小写f），而为double类型的变量赋值时，可以在所赋值的后面加上字母D（或小写d），也可以不加。

5. 字符类型变量

  在Java中，字符类型变量用char表示，用于存储一个单一字符。Java中每个char类型的字符变量都会占用2个字节。在给char类型的变量赋值时，需要用一对英文半角格式的单引号（’ ‘）把字符括起来，如’a’。

例如：

char c = ‘a’; // 为一个char类型的变量赋值字符a
char ch = 97; // 为一个char类型的变量赋值整数97，相当于赋值字符a

6. 布尔类型变量

  在Java中，布尔类型变量只有true和false两个值。

7. 类型转换

  自动类型转换：即隐式类型转换。是指两种数据类型在转换的过程中不需要显示声明，由编译器自动完成。其需同时满足两个条件：两种数据类型彼此兼容，目标类型的取值范围大于源类型的取值范围。

例如：

byte b = 3;
int x = b;

自动转换情况：

（1）整数类型之间可以实现转换。例如，byte类型的数据可以赋值给short、int、long类型的变量；short、char类型的数据可以赋值给int、long类型的变量；int类型的数据可以赋值给long类型的变量。

（2）整数类型转换为float类型。例如，byte、char、short、int类型的数据可以赋值给float类型的变量。

（3）其他类型转换为double类型。例如，byte、char、short、int、long、float类型的数据可以赋值给double类型的变量。

  强制类型转换：即显式类型转换。是指两种数据类型之间的转换需要进行显式声明。当无法进行自动转换时，这时就需要进行强制类型转换。

例如：

public class Example02 {
	public static void main(String[] args) {
		byte a;                // 定义byte类型的变量a
		int b = 298;          // 定义int类型的变量b
		a = (byte) b;
		System.out.println("b=" + b);
		System.out.println("a=" + a);
	}
}

但有时也会有数据精度丢失，

例如：

public class Example02 {
	public static void main(String[] args) {
		byte a;                // 定义byte类型的变量a
		int b = 298;          // 定义int类型的变量b
		a = (byte) b;
		System.out.println("b=" + b);
		System.out.println("a=" + a);
	}
}

当将变量b的类型强转为byte类型后，前面3个高位字节的数据丢失，数值发生改变。

8. 自动提升

例子：

public class Example03 {
	public static void main(String[] args) {
		byte b1 = 3;	      // 定义一个byte类型的变量
		byte b2 = 4;
		byte b3 = (byte)(b1 + b2);	// 两个byte类型变量相加，赋值给一个byte类型变量
		System.out.println("b3=" + b3);
	}
}

表达式b1+b2运算期间，变量b1和b2都被自动提升为int型，表达式的运算结果也就成了int型，将该结果赋给byte型的变量，需要进行强制类型转换。

9. 变量作用域

  变量定义后，需要在它的作用范围内才可以被使用，这个作用范围被称为变量的作用域。

三． 运算符

1. 算数运算符

2. 赋值运算符

  在使用+=、-=、*=、/=、%= 运算符进行赋值时，强制类型转换会自动完成，程序不需要做任何显式地声明。

例如：

public class Example05 {
	public static void main(String[] args) {
		short s = 3;
		int i = 5;
		s += i;	//强制类型转换自动完成
		System.out.println("s = " + s);
	}
}

3. 比较运算符

4. 逻辑运算符

&与&&的区别

public class Example06 {
	public static void main(String[] args) {
		int x = 0; 						// 定义变量x，初始值为0
		int y = 0; 						// 定义变量y，初始值为0
		int z = 0; 						// 定义变量z，初始值为0
		boolean a, b; 					// 定义boolean变量a和b
		a = x > 0 & y++ > 1; 			// 逻辑运算符&对表达式进行运算
		System.out.println(a);
		System.out.println("y = " + y);
		b = x > 0 && z++ > 1; 			// 逻辑运算符&&对表达式进行运算
		System.out.println(b);
		System.out.println("z = " + z);
	}
}

  在使用“&”进行运算时，不论左边为true或者false，右边的表达式都会进行运算。在使用“&&”进行运算，当左边为false时，右边的表达式就不再进行运算，因此“&&”被称作短路与。

|与||的区别，与&和&&的区别同理。

5. 运算符的优先级

四． 选择结构语句

1. if

if (条件语句)
{
代码块
}

2. if…else

if (判断条件){
执行语句1
…
}
else{
执行语句2
…
}

3. if…else if…else

if (判断条件1) {
执行语句1
}
else if (判断条件2) {
执行语句2
}
…
else if (判断条件n) {
执行语句n
}
else {
执行语句n+1
}

4. 三元运算符

判断条件 ? 表达式1 : 表达式2
注意：
（1）条件运算符“？”和“：”是一对运算符，不能分开单独使用。
（2）条件运算符的优先级低于关系运算符与算术运算符，但高于赋值运算符。
（3）条件运算符可以进行嵌套，结合方向自右向左。例如，a>b?a:c>d?c:d应该理解为a>b?a:(c>d?c:d)，这也是条件运算符的嵌套情形，即三元表达式中的表达式2又是一个三元表达式。

5. Switch

switch (表达式){
case 目标值1:
执行语句1
break;
case 目标值2:
执行语句2
break;
．．．．．．
case 目标值n:
执行语句n
break;
default:
执行语句n+1
break;
}

  switch语句将表达式的值与每个case中的目标值进行匹配，如果找到了匹配的值，则执行对应case后面的语句；如果没找到任何匹配的值，则执行default后的语句。

五． 循环结构语句

1. While

while(循环条件){
执行语句
…
}

2. Do…while

do {
执行语句
…
} while(循环条件);
循环体会无条件执行一次，然后再根据循环条件决定是否继续执行。

3. For

for（初始化表达式; 循环条件; 操作表达式）
{
执行语句
…
}

4. 跳转语句

Break
  当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。当它出现在循环语句中，作用是跳出循环语句，执行循环后面的代码。
  当break语句出现在嵌套循环中的内层循环时，它只能跳出内层循环，如果想使用break语句跳出外层循环，则需要在外层循环中使用break语句。

Continue
  continue语句用在循环语句中，它的作用是终止本次循环，执行下一次循环。

六． 方法

1. 概述

  方法就是一段可以重复调用的代码。注意，有些书中也会把方法称为函数。

2. 格式

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．){
执行语句
…
return 返回值;
}

3. 重载

即在同一个作用域内方法名相同但参数个数或者参数类型不同的方法。

例子：

public class Example21 {
	public static void main(String[] args) {
		// 下面是针对求和方法的调用
		int sum1 = add(1, 2);
		int sum2 = add(1, 2, 3);
		double sum3 = add(1.2, 2.3);
		// 下面的代码是打印求和的结果
		System.out.println("sum1=" + sum1);
		System.out.println("sum2=" + sum2);
		System.out.println("sum3=" + sum3);
	}
	// 下面的方法实现了两个整数相加
	public static int add(int x, int y) {
		return x + y;
	}
	// 下面的方法实现了三个整数相加
	public static int add(int x, int y, int z) {
		return x + y + z;
	}
	// 下面的方法实现了两个小数相加
	public static double add(double x, double y) {
		return x + y;
	}
}

  上述代码中，定义了三个同名的add()方法，但它们的参数个数或类型不同，从而形成了方法的重载。在main()方法中调用add()方法时，通过传入不同的参数便可以确定调用哪个重载的方法，如add(1,2)调用的是第13~14行代码定义的add()方法。需要注意的是，方法的重载与返回值类型无关。

七． 数组

1. 声明方式

第一种：
数据类型[] 数组名 = null;

第二种：
数据类型[]数组名;
数组名= new数据类型[长度];

2. 不同数据类型的数组元素的默认初始值

3. 静态初始化

第一种：
类型[] 数组名 = new 类型[]{元素,元素,……};

第二种：
类型[] 数组名 = {元素,元素,元素,……};

4. 遍历

例子：

public class Example27 {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4, 5 };          // 定义数组
		// 使用for循环遍历数组的元素
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);        // 通过索引访问元素
		}
	}
}

5. 最值

例子：

public class Example28 {
	public static void main(String[] args) {
		int[] arr = { 4, 1, 6, 3, 9, 8 };  	// 定义一个数组
		int max = getMax(arr);               	// 调用获取元素最大值的方法
		System.out.println("max=" + max); 	// 打印最大值
	}
	static int getMax(int[] arr) {
		int max = arr[0];  // 定义变量max用于记住最大数，首先假设第一个元素为最大值
		// 下面通过一个for循环遍历数组中的元素
		for (int x = 1; x < arr.length; x++) {
			if (arr[x] > max) { 			// 比较 arr[x]的值是否大于max
				max = arr[x];   				// 条件成立，将arr[x]的值赋给max
			}
		}
		return max;              				// 返回最大值max
	}
}

6. 排序

（未完待续……）

---

本篇博客为本人学习Java时的详细笔记，如有错误之处，还望各位指正。
文章为原创，如要转载请注明出处