第二章 Java基本语法

 1.关键字与保留字 

        定义与特点：Java赋予特殊含义、用做专门用途的字符串(单词)，并且字母要小写。对编译器有特殊含义的固定单词，在程序中不能另作它用。

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

        Java保留字：goto 、const，注意：区分大小写。

2.标识符的使用

        标识符：对各种变量、方法、类、接口和包等命名的字符串为标识符，可以理解为凡是自己命名的字符序列都是标识符。

2.1.标识符的命名规则

        由26个英文字母大小写、0-9、_或$组成。注意：不能以数字开头；不能直接用关键字或保留字，但能包含关键字和保留字；严格区分大小写，长度无限制，不能包含空格等。

2.2.Java中的名称命名规范

        包名：由多单词组成时所有字母要小写：xxxyyyzzz；类名、接口名：由多单词组成时，所有单词的首字母大写：XxxYyyZzz；变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始首字母大写：xxYyZzz；常量名：所有字母都大写，多单词时每个单词用下划线连接：XXX_YYY_ZZZ。注意：起名字时，为提高阅读性，应“见名知义”。

// 包名：com.shangguigu.test
package com.shangguigu.test;
// 类名：Identifier 
public class Identifier {

	public static void main(String[] args) {
        // 变量名myNumber01 
		int myNumber01 = 1002;
		System.out.println(myNumber);
	}
}
// 类名Hello1_$
class Hello1_${
	
}

3.常量和变量

3.1.常量

常量：运行程序时，值不能改变的量

        整数常量：88(十进制)、077(八进制)、11E(十六进制)；浮点型常量：3.4f(float)、3.4(double型)；布尔常量：true、false；字符常量：'A'、'\n'字符(转义)、'\\'特殊；字符串常量：“你好帅"；null常量：null；符号常量：final double p = 3.14。

3.2.变量

        程序在运行期间会产生一些临时数据。变量在内存中存储，类似于宾馆。通过变量名可以简单快速地找到它存储的数据。

        变量的概念：内存中的一个存储区域；该区域的数据可在同一类型范围内不断变化；程序中最基本的存在单元，包含变量类型、变量名和变量值。作用：用于在内存中保存数据。java是强类型语言：所有的变量必须先声明后使用，指定类型的变量只接受该类型与之匹配的值。
        Java中每个变量必须先声明和赋值，才能使用，用变量名可访问这块区域的数据。作用域：在定义内的一对{ }中，只有在其作用域中才有效，同一个作用域，不能定义重名的变量。

类型	语法	举例
声明变量	数据类型 变量名称;	int var;
变量赋值	变量名称 = 值;	var = 10;
声明和赋值变量	数据类型 变量名 = 初始化值;	int var = 10;

        使用变量的步骤：1.声明变量：根据数据类型在内存申请空间。2.赋值：将数据存储至对应的内存空间并赋值。3.作用域：规定了变量所能使用的范围，只有在其作用域内才能使用。

public class HelloWorld {
    // 变量赋值两种方式
    String name1 = "张三"; // 全局变量
    // 方式二
    String name;//先声明
    name = "张三";//在赋值
    // 可以多个同类型的变量同时初始化：
    String username,address,tel;

    public static void main(String[] args) {
    // 变量的定义,声明并赋值
	 int myAge = 12;
	 // 变量的使用
	 System.out.println(myAge);
    int a = 7;
    if (5 > 3) {
        int s = 3;// 局部变量，在if里面有用
        System.out.println("s=" + s);
        System.out.println("a=" + a);
    }
    System.out.println("s=" + s);//报错，不在其作用域内
    System.out.println("a=" + a);
    }
}

3.3.成员变量和局部变量

        根据变量的声明位置不同分为成员变量和局部变量，并且都有各自的生命周期。

变量类型	分类	作用域
成员变量	实例变量(不以static修饰)和类变量(以static修饰)	声明再类里面，方法的外面，作用域是整个类
局部变量	形参(方法、构造器中定义的变量)、方法局部变量(在方法内定义)和代码块局部变量(在代码块内定义)	声明再方法内部，作用域是离它最近的一对大括号里，使用时必须谨慎初始化。局部变量除形参外，需显式初始化

public class MemberVariable {
	static int Life = 1;// 成员变量的类变量
	// age和name是成员变量，也是实例变量
	int age = 12;
	String name = "张三";
	public static void main(String[] args) {
		new MemberVariable().show("男");
	}
	public void show(String sex) {// sex是形参，也是局部变量
		// habby是局部变量
		String habby = "打篮球";
		System.out.println(name + "性别："+ sex + "年龄：" + age + "爱好：" + habby);
	}
}

4.Java数据类型

        Java对每一种数据都定义明确具体的类型(强类型语言)，在内存中分配了不同大小的内存空间。按照数据类型划分为基本数据类型和引用类型。

4.1.基本数据类型

基本数据类型
类型分类	类型	存储空间：字节		范围和解释
整数类型	byte	1字节=8bit位		-128~127，bit: 计算机中的最小存储单位，byte：计算机中基本存储单元。
	short	2字节		-2^15~2^15-1
	int	4字节		-2^31~2^31-1，java的整型常量默认为 int 型；通常也声明为int型，除非不足以表示较大的数，才使用long
	long	8字节		-2^63~2^63-1，声明时long类型时，必须一"l"或"L"结尾，如：long id = 12452l。
浮点型型	单精度float	4，-3.403E38 ~3.403E38		声明float型常量，结尾加‘f’或‘F’，如：float num = 12.3f；float尾数可以精确到7位有效数字，表示数值的范围比long还大。 浮点型表示带小数点的数值，Java的浮点型默认为double型，因为double的精度更高，是float的两倍。
	双精度double	8，-1.798E38 ~1.798E38
字符类型	char	1字符=2字节		Java中都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符，所以可进行运算。 字符型变量的三种表现形式：1.字符常量用单引号(‘ ’)括起来的单个字符。如：char c1 = 'a'; char c2 = '中';  2.用转义字符‘\’来将其后的字符转变为特殊字符型常量。如：char c3 = ‘\n’， '\n'表示换行符； 3.用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n。
布尔类型	boolean			布尔型只能取两个值：true或false，不能用0或非 0 的整数替代false和true。常常在条件判断和循环结构中使用。

	public static void main(String[] args) {
		// 整形：byte(1字节 = 8bit） / short(2字节） / int(4字节） / long(8字节）
		byte a = 12;
		// 声明long类型变量，必须以“l”或“L"结尾
		long h1 = 424l;
	

		// 浮点型：float(4字节)/double(8字节)
		double d1 = 123.3;
		// 定义float类型变量，变量末尾要加上"f"或"F"
		float f1 = 12.3f;

		// 定义char类型变量，通常使用一对''，内部只能写一个字符
		char c1 = 'q';
		// 转义字符
		char c2 = '\n';// 换行

		// 布尔型：boolean
		boolean isMarried = true;
		if (isMarried) {
			System.out.println("你不能参加\"单身\"party,\\n");
		} else {
			System.out.println("你可以谈女朋友");
		}
	}

4.2.String类型

        String不是基本数据类型，属于引用数据类型，翻译为：字符串；声明String类型变量时，使用一对" "；String可以和8种基本数据类型做连接运算：+；运算结果仍然是String类型。

public static void main(String[] args) {
		String s1 = "Hello World";
		String s2 = "";
		//char = "";//编译不通过
		
		//String str6 = 123;//编译不通过
		String str8 = 123 + "";//"123"
		int number = 1001;
		String numberStr = "学号：";
		boolean b1 = true;
		String info = numberStr + number;// 学号：1001
		String info1 = info + b1;// 学号：1001true
		
		//练习
		char c = 'a';//97  A:65
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str);//107hello
		System.out.println(c + str + num);//ahello10
	}

5.基本数据类型转换

5.1.自动类型转换

        定义：容量小的类型自动转换为容量大的数据类型。
        数据类型按容量大小排序为：byte/char/short --> int --> long --> float --> double。
        当多种类型的数据混合运算时，系统首先自动将所有数据转换成运算中数据类型容量最大的类型，然后再进行计算，容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型，容量大小指表示数的范围的大和小。比如：float容量要大于long的容量。
        注意：byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型；boolean类型不能与其它基本数据类型运算。
        任何基本数据类型的值和字符串(String)进行连接运算时(+)，都会自动转化为字符串(String)类型；一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。
        原则：小类型可以用大类型去接收；小类型遇到大类型会自动转化为大类型；一切类型遇到字符串都会转化为字符串。

public static void main(String[] args) {
    //整形常量默认为int类型，浮点类型常量默认为double类型
    byte b1 = 23;
	int i1 = 124;
    // 编译不通过
	//byte = b1 + i1;
	int i2 = b1 + i1;// 127

	char c1 = 'a';// 对应的数字是97
	char c2 = 97;//开发种非常少见
	int i4 = 19;
	int i3 = c1 + i4;// 116

     // 特殊的，如下运算时不改变它的类型
     byte = 5;
     b += 3;// 类型没有改变，还是byte类型

	//编码成功，默认把int类型赋值给long类型
	long l1 = 123231;
	//编译失败，过大的整数
	//long l2 = 123435467889;
	long l3 = 123435467889L;
}

5.2.强制类型转换

        自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。转换时使用强制转换符：()，但可能造成精度降低或溢出。
        格外要注意：字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。boolean类型不可以转换为其它的数据类型。

    double d1 = 12.3;
    int a1 = (int)d1;//12，截断操作，只要整数，损失精度
		
    byte b = 3;
    b = (byte)(b+4); // 把int强制转换成byte
    int i = 5;
    float d = 3.314F;
    // i+d结果为double类型
    double result = (float)(i+d); //把double强转为float类型

    // 小类型可以用大类型去接收
    // byte、short、int、long 从小到大
    int a = (byte)123;//对
    int b = (short)123;//对
    int c = (long)123;//错
    // 一瓶水装入一个盆子里，可以;一盆水装入一个瓶子，不可以。

    // 小类型遇到大类型会自动转化为大类型
    double ave = (98+97+99)/3.0;//98.0

    // 一切类型遇到字符串都会转化为字符串，只有遇到字符串才会转化为字符串
    System.out.println(10 + 1 + "");//11
    System.out.println( 10 + " " + 1);//101
    System.out.println("" + 10 + 1);//101


    double num12 = 8.1 / 3; //2.7，接近2.7的一个小数，而不是 2.7
    // 当我们对运算结果是小数的进行相等判断时，要小心
    // 应该是以两个数的差值的绝对值，在某个精度范围类判断，不然可能达不到想要的效果
    if(Math.abs(num11 - num12) < 0.000001 ) {
        System.out.println("差值非常小，到我的规定精度，认为相等...");
    }

        注意：在将 String 类型转成基本数据类型时，比如我们可以把 "123" , 转成一个整数，但是不能把 "hello" 转成一个整数；如果格式不正确，就会抛出异常，程序就会终止。

6.进制

        数字在计算机底层都以二进制形式存在，并以数字的补码方式存储数据。对于整数，有四种表示方式：

        二进制(binary)：0,1,满2进1，以0b或0B开头；

        十进制(decimal)：0-9,满10进1；

        八进制(octal)：0-7，满8进1，以数字0开头表示 ；

        十六进制（hex）：0-9及A-F，满16进1，以0x或0X开头表示，此处A-F不区分大小写：0x21AF + 1 = 0X21B0。

public static void main(String[] args) {
		// 二进制
		int num1 = 0b110;
		// 十进制
		int num2 = 110;
		// 八进制
		int num3 = 0127;
		// 十六进制
		int num4 = 0x110A;
		// 输出：num1 = 6，num2 = 110，num3 = 87，num4 = 4362
		System.out.println("num1 = "+num1+"\nnum2 = "+num2+"\nnum3 = "+num3+"\nnum4 = "+num4);
	}

7.原码、反码和补码

        对于有符号的而言：二进制的最高位：0表示正数，1表示负数；正数的原码、反码和补码都一样；负数的反码=原码符号位不变，其它位取反；负数的补码=反码+1，负数的反码=负数的补码-1；0的反码和补码都是0；java没有无符号数，换言之Java中的数都是有符号的；在计算机运算时，都是以补码方式来运算；看运算结果时，要看它的原码。

8.运算符

        运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

名称	符号	其他
算术运算符	+、-、*、/、%、++、--	对负数取模，把模数负号忽略不记。 被模数是负数则不可忽略，取模运算的结果不一定总是整数。除法时，整数相除，保留整数部分舍弃小数部分。加号可使字符串连接，能把非字符串转换成字符串。
赋值运算符	=、+=、-=、*=、/=、%=	当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。支持连续赋值。
比较运算符(关系运算符)	==、!=、<、>、<=、>=、instanceof	运算结果为boolean类型，要么是true，要么是false；instanceof是检查是否是类的对象。
逻辑运算符	&、^、|、!、&&、||	^是异或、逻辑运算符用于连接布尔型表达式，如Java把3<x<6写出x>3 & x<6 。
位运算符	<<、>>、>>>、&、|、^、~	<<是左移，再一定范围内，每向左1位，相当于*2，>>>无符号右移，位运算是直接对整数的二进制进行的运算
三元运算符	结构(条件表达式)？表达式1 ： 表达式2	条件为true执行表达式1，条件为false时执行表达式2。

8.1.算术运算符和赋值运算符

public static void main(String[] args) {
    // 除号 /
	int num1 = 12;
	int num2 = 5;
	int result = num1 / num2;// 2
	double result3 = num1 / num2;// 2.0
	double result4 = num1 / (num2 + 0.0);// 2.4
	double result5 = (double) num1 / num2;// 2.4
	double result6 = (double) (num1 / num2);// 2.0
	
	// 赋值运算符：=
	int wangScore = 80;
	int zhangScore;
	zhangScore = wangScore;//80 将右边的赋值给左边的
	// 变量名 = 表达式:表达式就是符号（如加、减）与操作数（如wangScore，10等）的组合
	zhangScore = (wangScore + 10) + (wangScore - 5);// 165
	
	// %:取余运算
	// 结果的符号和被模数的符号相同
	// 开发中，用来判断是否能除尽
	int m1 = 12 % 5;// 2
	int m2 = -12 % 5;// -2
	int m3 = 12 % -5;// 2
	int m4 = -12 % -5;// -2

    // 复合运算符：+=、-=、*=、/=、...
	int num3 = 5;
	num3 += 3;// 8等价于num3 = num3 + 3;

	// (前)++:先自增1，在运算
	// (后)++：先运算，在自增1
	int a1 = 10;
	int b1 = ++a1;
	System.out.println("a1 = " + a1 + ",b1 = " + b1);// a1 = 11,b1 = 11
	int a2 = 10;
	int b2 = a2++;
	System.out.println("a2 = " + a2 + ",b2 = " + b2);// a2 = 11,b2 = 10

	// 注意点
	short s1 = 10;
	// s1 = s1 + 1;//编译失败，结果为int，但是s1是short类型
	s1 = (short) (s1 + 1);// 正确的
	s1++;// 自增1不会改变本身变量的数据类型

    // 赋值
	int g1 = 10, j1 = 10;
	int g2, j2;
	g2 = j2 = 10;
	int j3 = 10;
	int g3 = 10;

	g1 += j1;// g1 = g1 +j1;
	short h1 = 10;
	// h1 = h1 +2;//编译不通过
	h1 += 2;// 不会改变变量本身的数据类型，还是short类型

	// 开发中希望变量+2有几种方式？
	// 方式一：num = num + 2;
	// 方式二：num += 2;(推荐)

	// +1的几种方法
	// num = num + 1;
	// num += 1;
	// num++;(推荐)

	// 练习1
	int i = 1;
	i *= 0.1;// 通过
	System.out.println(i);// 0
	i++;
	System.out.println(i);// 1

	// 练习2
	int m = 2, n = 3;
	n *= m++;
	System.out.println(m);// 3
	System.out.println(n);// 6

	int n5 = 10;
	n5 += (n5++) + (++n5);// n5 = n5 + (n++) + (++n); n5 = 10 + 10 + 12;
	System.out.println("n5 = " + n5);// n5 = 32
}

8.2.比较运算符(关系运算符)、逻辑运算符和位运算符

public static void main(String[] args) {
    
	// =为赋值运算符，==为等于运算符
	// 关系表达式的结构为布尔值；>、<、>=、<=运算符的优先级别高于==、!=
	// >、<、>=、<=运算符只支持数值类型的数据比较
	int num4 = 5, num5 = 6;
	if (num4 == num5) {// false
		System.out.print("num4 == num5");
	}
	if (num4 != num5) {// true
		System.out.print("num4 == num5");
	}

	// 优先级：! -> && -> ||
	// 逻辑与，两个操作数都为true，结果才为true
	if (num4 < num5 && num5 > 3) {// true
		System.out.println("&&运算结果为真");
	}
	// 逻辑或，两个操作数一个为true，结果为true
	if (num4 > num5 || num5 > 3) {// true
		System.out.println("||运算结果为真");
	}
	// ! true变为false，false变成true
	boolean isTrue = false;
	if (!isTrue) {
		System.out.println("!运算结果为真");
	}

    // 区分& 和&&，两者的运算结果相同，当左边为true二者右边都执行
	// &&左边为false，右边不再执行；&不管左边成不成立，右边都执行
	boolean b1 = true;
	b1 = false;
	int num1 = 10;
	if (b1 & (num1++ > 0)) {
		System.out.println("我现在北京");
	} else {
		System.out.println("我现在南京");// 我现在南京
	}
	System.out.println(num1);// 11

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

	// 区分：| 与 ||，二者运算结果相同，二者左边为false，右边都会执行
	// 二者左边为ture，|还会运算右边，||不会运算右边

	// 逻辑运算符：&、|、^
	// 操作数类型只能是布尔类型，操作结果也是布尔类型
	// 优先级：! -> & -> ^ -> | -> && -> ||
	// 逻辑与，都为true，结果才为true
	if (num4 < num5 & num5 > 3) {// true
		System.out.println("&运算结果为真");
	}

	// 逻辑或，有一个为true，结果为true
	if (num4 > num5 | num5 > 3) {// true
		System.out.println("|运算结果为真");
	}

	// 逻辑异或，相同时false，不同时true
	if (num4 > num5 ^ num5 > 3) {// true
		System.out.println("^运算结果为真");
	}

	// &,按位与，两个操作数都是1，结果为1
	// |,按位或，两个操作数一个是1，结果为1
	// ^,按位异或，两个操作数不同，结果为1
	// ~,按位非/取反，操作数为1，结果为0；操作数为0，结果为1
	// <<,左移，右边空位补0
	// >>,右移，左侧空位补最高位，及符号位
	// >>>,无符号右移，左侧空位补0
	// 位运算的结果也是整型数;位运算符对操作数以二进制位为单位进行运算
	// 如果操作数是char、byte、short，位运算前其值会自动晋升为int，运算结果也为int
	// 位运算的操作数是整型数
	// 5的二进制：00000101；2的二进制时00000010
	// 00000101左移两位变成00010100
	int num6 = 5 << 2;// 左移相当于5*2^2次幂
	int num7 = 20 >> 2;// 右移相当于20/2^2
    // num6=20，num7=5
	System.out.println("num6 = " + num6 + "\t" + "num7 = " + num7);
		

	int num3 = 10;
	int num4 = 20;
	// 交换两个的值
	// 方式一：定义临时变量的方式
	// 推荐方式
	int temp = num4;
	num4 = num3;
	num3 = temp;

	// 方式二：好处，不用定义临时变量
	// 弊端①相加操作可能存在超出存储范围②局限性：只是用数值类型
	// num3 += num4;
	// num4 = num3 -num4;
	// num3 = num3 - num4;

	// 方式三：使用位运算，好处，不用定义临时变量，局限性：只是用数值类型
	// num3 = num3 ^ num4;
	// num4 = num3 ^ num4;
	// num3 = num3 ^ num4;
	System.out.println("num3 = " + num3 + ",num4 =" + num4);// num3 = 20,num4 =10
}

        算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符和条件运算符：优先级别最低的是赋值运算符，可通过()小括号控制表达式的运算顺序。()优先级最高，从右向左结合性的只有赋值运算符、三目运算符和单目运算符;算术运算符 > 关系运算符 > 逻辑运算符。
        =和==的区别：== 是 比较运算符，返回true或者false；= 是赋值运算符，只是把右边的值通过等号传递到左边。注意：大于、小于、大于等于、小于等于只支持左右两边都是数值；== 和 !=两边的操作数既可以是数值类型，也可以是引用类型；= 是赋值用的，== 是比较用的；字符串的比较用equals。

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

8.3.三元运算符

        凡是可以使用三元运算符的地方都能使用if-else结构，反之不成立。如果程序即可以用三元运算符，又可以使用if-esle结构，优先选择三元运算符，效率高。
        三目运算符或三元运算符：条件  ？ 表达式1  ： 表达式2,条件为true执行表达式1，条件为false时执行表达式2。
        表达式1和表达式2类型相同；条件表达式是boolean类型；三元运算符可以嵌套使用。

        //三目运算符的使用
		boolean sex = true;
		System.out.println(sex == true ? '男' : '女');
		int sex1 = 0;
		System.out.println(sex1 == 1 ? '男' : '女');

8.4.练习：最高效方式的计算2 * 8 ？ 2 << 3 或 8 <<1

        2乘以8，最高效的方式2左移3位或8左移1位。