第二章 基本语法

1.Java关键字的使用

定义：被Java语言赋予了特殊含义,用做专门用途的单词
特点：关键字中所有的字母均为小写
具体哪些关键字：

关键字	说明
byte	基本数据类型之一，字节类型
short	基本数据类型之一,短整形
int	基本数据类型之一，整数类型
long	基本数据类型之一，长整型
float	基本数据类型之一，单精度浮点数类型
double	基本数据类型之一，双精度浮点数类型
char	基本数据类型之一，字符类型
boolean	基本数据类型之一，声明布尔类型的关键字
do	用在do-while循环结构中关键字
while	用在while循环结构中
for	一种循环结构的引导词
if	选择结构条件语句的引导词
else	用在条件语句中，表明当条件不成立时的分支
switch	分支语句结构的引导词
case	用在switch语句之中，表示其中的一个分支
default	默认,用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现
break	用于提前退出for、while或do循环，或者在switch语句中用来结束case块。
continue	回到一个块的开始处 跳转到for、while或do循环的下一个迭代。
return	从成员方法中返回数据 返回到主调函数继续执行 结束
class	用于声明类
interface	用于声明接口
abstract	表明类或者成员方法具有抽象属性
enum	声明枚举类
public	访问修饰符:公共的
protected	访问修饰符:受保护的
private	访问修饰符:私有的
static	表明具有静态属性
synchronized	表明一段代码需要同步执行
finaly	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量。
extends	继承 表明一个类型是另一个类型的子类型 。对于类，可以是另一个类或者抽象类；对于接口，可以是另一个接口。
implements	实现 表明一个类实现了给定的接口
try	尝试一个可能抛出异常的程序块
catch	用在异常处理中，用来捕捉异常
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
throw	抛出一个异常 可以是自定义的可以是系统定义的
throws	声明在当前定义的成员方法中所有需要抛出的异常
new	用来创建新实例对象
this	指向当前实例对象的引用
super	表明当前对象的父类型的引用或者父类型的构造方法
instanceof	用来判断一个对象是否是指定类型的实例对象
package	声明包路径
import	表明要访问指定的类或包
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
transient	声明不用序列化的成员域
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
assert	断言，用来进行程序调试
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
true	真 用来表示boolean型变量的值
false	假 用来表示boolean型变量的值
null	空值 用来赋值
goto	保留关键字，没有具体含义
const	保留关键字，没有具体含义

2.保留字：

现Java版本尚未使用，但以后版本可能会作为关键字使用。
具体哪些保留字：goto const
注意：保留字和关键字都不能当标识符使用,自己命名标识符时要避免使用这些保留字

3.标识符的使用

定义：凡是可以自己定义名称的地方都叫做标识符
涉及到的结构：包名、类名、接口名、变量名、常量名、方法名
规则：(必须要遵守。否则，编译不通过)
1.由26个英文字母大小写、0-9、_和$组成
2.不能以数字开头
3.不能包含空格
4.不能使用保留字和关键字,但能包含关键字和保留字
5.严格区分大小写,长度没有限制

规范：（可以不遵守，不影响编译和运行。但是要求大家遵守）
包名:多单词组成时所有字母都小写:xxxyyyzzz
类名、接口名:多单词组成时，所有单词的首字母大写:XxxYyyZzz
变量名、方法名:多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写:xxxYyyZzz
常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_Zzz
注意点：
在起名字时，为了提高阅读性，要尽量意义，“见名知意”。

4.变量的分类

4.1 按数据类型分类

详细说明：
//1. 整型：byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
//① byte范围：-128 ~ 127
// ② 声明long型变量，必须以"l"或"L"结尾
// ③ 通常，定义整型变量时，使用int型。
//④整型的常量，默认类型是：int型
//2. 浮点型：float(4字节) \ double(8字节)
//① 浮点型，表示带小数点的数值
//② float表示数值的范围比long还大
//③ 定义float类型变量时，变量要以"f"或"F"结尾
//④ 通常，定义浮点型变量时，使用double型。
//⑤ 浮点型的常量，默认类型为：double
//3. 字符型：char (1字符=2字节)
//① 定义char型变量，通常使用一对’’,内部只能写一个字符
//② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
//4.布尔型：boolean
//① 只能取两个值之一：true 、 false
//② 常常在条件判断、循环结构中使用
4.2 按声明的位置分类(了解)

5.定义变量的格式：

5.1.命名时直接初始化赋值
数据类型 变量名 = 变量值;
5.2.先命名后赋值
数据类型 变量名;
变量名 = 变量值;

6.变量使用的注意点：

① 变量必须先声明，后使用
② 变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了
③ 同一个作用域内，不可以声明两个同名的变量

7.基本数据类型变量间运算规则

7.1 自动类型转换(只涉及7种基本数据类型）
结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
byte 、char 、short --> int --> long --> float --> double
特别的：当byte、char、short三种类型的变量做运算时，结果为int型
说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量

7.2 强制类型转换(只涉及7种基本数据类型）：自动类型提升运算的逆运算。
1.需要使用强转符：()
2.注意点：强制类型转换，可能导致精度损失。
7.3 String与8种基本数据类型间的运算
①String属于引用数据类型,翻译为：字符串
② 声明String类型变量时，使用一对""
③String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
④运算的结果仍然是String类型

避免：
String s = 123;//编译错误
String s1 = “123”;
int i = (int)s1;//编译错误

8.进制

1.编程中涉及的进制及表示方式：

2.二进制的使用说明：
2.1 计算机底层的存储方式：所有数字在计算机底层都以二进制形式存在。
2.2 二进制数据的存储方式：所有的数值，不管正负，底层都以补码的方式存储。
2.3 原码、反码、补码的说明：
正数：三码合一 原码 = 反码 = 补码
负数：在计算机中用二进制的补码表示,最高位是符号位 0表示正数

3.进制间的转换：
3.1 图示：

3.2 图示二进制转换为十进制：

3.3 图示十进制转换为二进制：

3.4 二进制与八进制、十六进制间的转换：

9.运算符

1.算术运算符：

【典型代码】

/**
+-  + - * /  % ++   --  + ==
算术运算符测试

*/

class ArithmeticTest {
	public static void main(String[] args){

	//除法: /

	int num1 = 12;

	int num2 = 5;

	int result1 = num1/num2;
	System.out.println(result1);
	System.out.println(num1 / num2 * num2);

	double result3 = num1 /num2;
	System.out.println(result3);

	double result4 = num1 / (double)num2;
	System.out.println(result4);

	// % 取余运算 : 运算结果都±与被取余的数符号相同

	int m1 = 12;
	int n1 = 5;
	System.out.println("12 % 5 = " + m1 % n1);

	int m2 = 12;
	int n2 = -5;
	System.out.println("12 % -5 = " + m2 % n2);

	int m3 = -12;
	int n3 = 5;
	System.out.println("-12 % 5 = " + m3 % n3);

	int m4 = -12;
	int n4 = -5;
	System.out.println("-12 % -5 = " + m4 % n4);

	//前++ 先自增1 后运算  后++ 先运算  后自增1
	//前-- 先自减1 后运算  后-- 先运算  后自减1
	int a1 = 10;
	int b1 = ++a1;
	System.out.println("a1 = " + a1 + "b1 = " + b1);
	
	int a2 = 10;
	int b2 = a2++;
	System.out.println("a2 = " + a2 + "b2 = " + b2);
	
	int a3 = 10;
	int b3 = a3--;
	int b4 = --a3;
	System.out.println("a3 = " + a3 + "b3 = " + b3 + "b4 = " + b4);
	


	//自增运算不会改变本身变量的数据类型
	short s1 = 10;
	s1++; 
	System.out.println(s1);
	byte b10 = 127;
	b10++;
	System.out.println(b10);


	System.out.println("--------练习-------------");
	/*
	练习:随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
	格式如下:
	数字xxx的情况如下:
	个位数:
	十位数:
	百位数:
	
	例如:
	数字153的情况如下:
	个位数:3
	十位数:5
	百位数:1
	*/
	int ii = 187;
	System.out.println("数字"+ ii +"的情况如下:");
	
	System.out.println("百位数:" + 178 / 100);
    System.out.println("十位数:" + ii % 100 / 10);
	System.out.println("个位数:" + ii % 10);
	}
}

【特别说明的】
1.//(前)++ :先自增1，后运算
//(后)++ :先运算，后自增1

2.//(前)-- :先自减1，后运算
//(后)-- :先运算，后自减1
自增/自减运算不会改变变量的数据类型

3.连接符：+：只能使用在String与其他数据类型变量之间使用。

2.赋值运算符

【典型代码】

/*
运算符之二:赋值运算符

= +=  -= *=  /=  %=

*/

class SetValueTest {
	public static void main(String[] args){

	//赋值符号: = 
	int i1 = 10;
	int j1 = 10;
	int i2,j2;

	//连续赋值
	i2 = j2 = 10;

	int i3 = 10, j3 =20;
	
	System.out.println("--------------------------------");
	int num1 = 10;
	num1 += 2; // 等价于  num1 = num1+2;
	System.out.println(num1);//12

	int num2 = 12;
	num2 %= 5;

	System.out.println("num2= " + num2);//2

	//区别  不会改变变量的数据类型
	short s1 = 10;
	s1 += 2;
	System.out.println(s1);
	//开发中如果希望实现变量+2的操作有几种方法?
	//方式1: num = num+2;
	//方式2: num += 2;(推荐)

	//开发中如果希望实现变量+1的操作有几种方法?
	//方式1: num = num+1;
	//方式2: num += 1;
	//方式3: num++;(推荐)


	//练习1
	int i = 1;

	i *= 0.1; //编译运行均可通过
	System.out.println(i);
	i++;
	System.out.println(i);

	//练习2
	int m = 2;
	int n1 = 3;
	n1 *= m++;// n = n * m++ = 6;

	//练习3
	int n = 10;
	n += (n++) + (++n); // n = n + (n++) + (++n) = 10 + 10 +12 = 32;
	System.out.println(n);
	}
}

【特别说明的】
运算的结果不会改变变量本身的数据类型

3.比较运算符
== != > < >= <= instanceof(用于类的比较)
【典型代码】

/*
运算符之三: 比较运算符
== !=  > < >= <=  instanceof

结论:
1.比较运算符的结果是boolean类型
2.区分== 和 = ;

*/

class CompareTest {
	public static void main(String[] args){

		int i = 10;
		int j = 20;
		System.out.println(i == j);//false;
		System.out.println(i = j);//20

		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1);//false
		System.out.println(b2 = b1);//true;
	}
}

【特别说明的】
1.比较运算符的结果是boolean类型
2.> < >= <= :只能使用在数值类型的数据之间。
3. == 和 !=: 不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间。
Account acct1 = new Account(1000);
Account acct2 = new Account(1000);
boolean b1 = (acct1 == acct2);//比较两个Account是否是同一个账户。
boolean b2 = (acct1 != acct2);//

4.逻辑运算符

& && | || ! ^

【典型代码】

/*
运算符之四:逻辑运算符
& && | || ! ^

说明:
1.逻辑运算符操作的都是boolean型变量
*/

class LogicTest {
	public static void main(String[] args){

		//区分& 与 && 相同点: 1.运算结果相同 2. 当符号左边是true时都会执行符号右边的运算
		//不同点: 当左边是false时,&&不执行右边的运算
		boolean b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
			System.out.println("我现在在北京");
			
		}else{
			System.out.println("我现在在南京");
		}

		System.out.println("num1 = " + num1);

		boolean b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)){
			System.out.println("我现在在北京");
			
		}else{
			System.out.println("我现在在南京");
		}

		System.out.println("num2 = " + num2);

		//区分| 与 || 相同点: 1.运算结果相同 2. 当符号左边是false时都会执行符号右边的运算
		//不同点: 当左边是true时,||不执行右边的运算
		boolean b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
			System.out.println("我现在在北京");
			
		}else{
			System.out.println("我现在在南京");
		}

		System.out.println("num3 = " + num3);

		boolean b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0)){
			System.out.println("我现在在北京");
			
		}else{
			System.out.println("我现在在南京");
		}

		System.out.println("num4 = " + num4);

		//! ^ 非(取反)   异或运算
		boolean bool = true;
		boolean blean = false;
		System.out.println(!bool);//false
		System.out.println(bool ^ blean);//true
		System.out.println(!bool ^ blean);//false
	}
}

【特别说明的】
1.逻辑运算符操作的都是boolean类型的变量。而且结果也是boolean类型

5.位运算符：
<< >> >>> & | ^ ~

【典型代码】

/*
运算符之五:位运算符

结论:
1.位运算符操作的都是整形的数据
是对二进制数进行移动操作
对于正数<<左移补0  >>右移也补0
对于负数<<左移补0  >>右移补1
无符号右移运算>>>被移位的二进制最高位无论是0/1都补0
注意: 没有无符号<<<左移运算
2.<<:在一定范围内,每向左移1位,相当于 *2
  >>:在一定范围内,每向右移1位,相当于 /2

  面试题:最高效的方式计算2*8? 2<<3   8<<1

*/
class BitTest {
	public static void main(String[] args){
		
		int i = 21;
		int j = -21;
		System.out.println("i << 2 = " + (i << 2) );
		System.out.println("i << 3 = " + (i << 3 ));
		System.out.println("j << 27 = " + (j << 27 ));

		// 按位与&  按位或|  按位异或^ 二进制层面进行运算
		int m = 12;
		int n = 5;
		System.out.println("m & n = " + (m & n));
		System.out.println("m & n = " + (m | n));
		System.out.println("m & n = " + (m ^ n));
		//~取反 二进制位包括符号位全部取反
		System.out.println("~m = " + ~m);

		//练习 交换2个变量值
		System.out.println("--------------------------");
		int num1 = 10;
		int num2 = 20;
		int temp = 0;
		//方式一 定义临时变量
		temp = num1;
		num1 = num2;
		num2 = temp;
		System.out.println(num1);
		System.out.println(num2);
		//方式二 好处: 不用定义临时变量
		//弊端:有可能超出存储范围 有局限性对于非数值型变量无法使用
		num1 = num1 + num2;
		num2 = num1 - num2;
		num1 = num1 - num2;
		System.out.println(num1);
		System.out.println(num2);
		//方式三 使用位运算符 有局限性对于非数值型变量无法使用
		num1 = num1 ^ num2;
		num2 = num1 ^ num2;
		num1 = num1 ^ num2;
		System.out.println(num1);
		System.out.println(num2);

	}
}

【特别说明的】

1.位运算符操作的都是整形的数据
是对二进制数进行移动操作
对于正数<<左移补0 >>右移也补0
对于负数<<左移补0 >>右移补1
无符号右移运算>>>被移位的二进制最高位无论是0/1都补0
注意: 没有无符号<<<左移运算
2.<<:在一定范围内,每向左移1位,相当于 *2 ; >>:在一定范围内,每向右移1位,相当于 /2
6.三元运算符
【典型代码】

package com.xjy.helloWorld;
/*
运算符之六: 三元运算符(三目)
1.结构:(条件表达式)?表达式1 : 表达式2
2.说明
① 条件表达式的结果为boolean类型
② 根据表达式的值决定执行表达式1 ,还是表达式2;
如果为true执行1 否则执行2
③ 表达式1 和表达式2要求是一致的
④ 三元运算符是可以嵌套的
3.凡是使用三元运算符的地方都可以改成if...else
反之不成立
 */
public class SanYuanTest {
    public static void main(String[] args) {
        //获取两个整数的较大值
        int m = 12;
        int n = 5;
        int max = (m>n)? m : n;
        System.out.println(max);

        double max2 =  (m>n)? 2 : 1.0;
        System.out.println(max2);

        //double max2 =  (m>n)? 2 : "n大";  不可以这样写 编译错误
        String str =  (m>n)? "m大" : ((m == n) ? "m=n" : "n大");
        System.out.println(str);

        //获取三个数的最大值
        int n1 = 12;
        int n2 = 30;
        int n3 = -43;

        int maxn = (n1 > n2)? n1 : n2;
        maxn = (maxn > n3)? maxn : n3;
        System.out.println(maxn);

    }
}

【特别说明的】
1.说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
如果表达式为true，则执行表达式1。
如果表达式为false，则执行表达式2。
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符可以嵌套使用
2. 凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。
3. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。

运算符的优先级

10.流程控制

1.分支结构
if-else

1.if-else条件判断结构
1.1.
结构一：
if(条件表达式){
执行表达式
}

结构二：二选一
if(条件表达式){
执行表达式1
}else{
执行表达式2
}

结构三：n选一
if(条件表达式){
执行表达式1
}else if(条件表达式){
执行表达式2
}else if(条件表达式){
执行表达式3
}
…
else{
执行表达式n
}

1.2.说明：
1.else 结构是可选的。
2. 针对于条件表达式：
如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
3. if-else结构是可以相互嵌套的。
4. 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。

2.switch-case选择结构

switch(表达式){
case 常量1:
执行语句1;
//break;
case 常量2:
执行语句2;
//break;
…
default:
执行语句n;
//break;
}
2.说明：
① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构
末尾结束为止。
② break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
③ switch结构中的表达式，只能是如下的6种数据类型之一：
byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
④ case 之后只能声明常量。不能声明范围。
⑤ break关键字是可选的。
⑥ default:相当于if-else结构中的else.
default结构是可选的，而且位置是灵活的。
3.如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。
4.break在switch-case中是可选的

.循环结构

1.四要素
① 初始化条件
② 循环条件 —>是boolean类型
③ 循环体
④ 迭代条件
说明：通常情况下，循环结束都是因为②中循环条件返回false了。

2.三种循环结构：
2.1 for循环结构
for(①;②;④){
③
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - … - ②
2.2 while循环结构
①
while(②){
③;
④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - … - ②
说明：
写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！

for和while循环总结：

1. 开发中，基本上我们都会从for、while中进行选择，实现循环结构。
2. for循环和while循环是可以相互转换的！
   区别：for循环和while循环的初始化条件部分的作用范围不同。
3. 我们写程序，要避免出现死循环。
   2.3 do-while循环结构
   ①
   do{
   ③;
   ④;
   }while(②);
   执行过程：① - ③ - ④ - ② - ③ - ④ - … - ②

说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while更多一些。较少使用do-while
3.“无限循环”结构: while(true) 或 for(; ; )
总结：如何结束一个循环结构？
方式一：当循环条件是false时
方式二：在循环体中，执行break

4.嵌套循环
1.嵌套循环:将一个循环结构A声明在另一个循环结构B的循环体中,就构成了嵌套循环
内层循环：循环结构A
外层循环：循环结构B
2.说明：
① 内层循环结构遍历一遍，只相当于外层循环循环体执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次
③ 外层循环控制行数，内层循环控制列数
【典型练习】

		
class ForForTest {
	public static void main(String[] args){

		//输出菱形

		for (int i = 0; i<5 ; i++){
            for (int j = 0; j< 5-i; j++){
                System.out.print(" ");
            }
			for (int j = 0; j<=i; j++){
                System.out.print("* ");
            }
			System.out.println();

        }
		for (int i = 0; i<4 ; i++){

			for(int j = 0; j<=i+1; j++){
				System.out.print(" ");
			}
            for (int j = 0; j< 4-i; j++){
                System.out.print("* ");
            }
			
			System.out.println();

        }
		//99乘法表

		for(int i = 1; i<= 9 ; i++){
			for(int j = 1; j<=i; j++){
				System.out.print(i + "*" + j + "=" + (i*j) + "\t");
			}
			System.out.println();
		}


		//输出100以内的质数
		boolean isFlag = true;
		int count = 0;
		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long startTime = System.currentTimeMillis();
		for(int i = 2; i<=100; i++ ){
			
			for(int j = 2 ; j <= Math.sqrt(i); j++){
				//优化二:对本身是质数的自然数有效
				if(i % j == 0){
				isFlag = false;
				
				
				break;//优化1 只对本身是非质数的自然数有效
				}

			}
			if(isFlag){
				count++;
			}
			isFlag = true;
		
		}
		long endTime = System.currentTimeMillis();
		System.out.println("质数的个数为" + count);
						     
		System.out.println("时间:" + (endTime - startTime) );
	}
}

补充:衡量一个功能代码的优劣：
1.正确性
2.可读性
3.健壮性
4.高效率与低存储：时间复杂度 、空间复杂度 （衡量算法的好坏）

如何理解流程控制的练习：
流程控制结构的使用 + 算法逻辑

break和continue关键字的使用
使用范围 循环中使用的作用(不同点) 相同点
break: switch-case
循环结构中 结束当前循环 关键字后面不能声明执行语句

continue: 循环结构中 结束当次循环 关键字后面不能声明执行语句

补充：带标签的break和continue的使用

//带标签的for的使用

out:for(int i = 0 ; i <= 4 ; i++ ){
	for(int j = 0; j <= 10; j++){
		if(j % 4 == 0){
			break out;
		}
		System.out.println(j);
	}
	System.out.println();
}




//100以内的质数的个数,使用代标签的continue
		int count = 0;
		out:for(int i = 2; i<=100; i++ ){
			
			for(int j = 2 ; j <= Math.sqrt(i); j++){

				if(i % j == 0){
 				continue out; 
				}
			}
				count++;

		}

		System.out.println("质数的个数为" + count);