二、Java基础语法（1）

1 关键字

注意：
A:goto和const是保留字（保留字：在JDK的新版本可能会提升为关键字）
B:类似于Notepad++这样的高级记事本，针对关键字都有特殊的颜色标记。

2 标识符

标识符：就是给类，接口，方法，变量等起名字。

组成规则：
		A:英文字母大小写
		B:数字字符
		C:$和_
		
	注意事项：
		A:不能以数字开头
		B:不能是Java中的关键字
		C:Java语言严格区分大小写
		
	常见的命名规则：见名知意
		举例：我要定义一个学生类
			class Student {}
			class S{}
			
		包：其实就是文件夹，用于把相同的类名进行区分
			全部小写
		
			单级：hcy
			多级：cn.hecy
				cn
					hecy
					
		类或者接口：
			一个单词：单词的首字母必须大写
				举例：Student,Dog
			多个单词：每个单词的首字母必须大写
				举例：HelloWorld,StudentName
			
		方法或者变量：
			一个单词：单词的首字母小写
				举例：main,age
			多个单词：从第二个单词开始，每个单词的首字母大写
				举例：studentAge,showAllNames()
				
		常量：
			一个单词：全部大写
				举例：PI
			多个单词：每个字母都大写，用_隔开
				举例：STUDENT_MAX_AGE

举个例子：

class MakeNameDemo {
	public static void main(String[] args) {
		//正确做法
		int x = 100;
		
		//不能以数字开头
		//int 1y = 100;
		int y1 = 100;
		
		//不能是Java中的关键字
		//int public = 100;
		int Public = 100;
	}
}

3 常量

3.1 常量概述

在程序执行过程中，其值不发生改变的量。

分类：
		A:字面值常量
		B:自定义常量(后面讲)
		
	字面值常量
		A:字符串常量	用双引号括起来的内容。
			举例："hello","world","HelloWorld"
		B:整数常量	所有的整数
			举例：100,200
		C:小数常量	所有的小数
			举例：10.23,110.11
		D:字符常量	用单引号括起来的内容
			举例：'a','A','0'
			错误的：'ab'
		E:布尔常量	比较特殊
			举例：true,false
		F:空常量	后面讲
			举例：null

3.2 进制

不同进制的数据表现：
二进制：由0，1组成。以0b开头。
八进制：由0,1,…7组成。以0开头。
十进制：由0,1,…9组成。默认整数是十进制。
十六进制：由0,1,…9,a,b,c,d,e,f(大小写均可)组成。以0x开头。

class JinZhiDemo {
	public static void main(String[] args) {
		System.out.println(100); //十进制
		
		System.out.println(0b100); //二进制
		System.out.println(0100); //八进制
		System.out.println(0x100); //十六进制
	}
}

4 变量

在程序的执行过程中，其值在某个范围内可以发生改变的量。

变量的定义格式：
		A:数据类型 变量名 = 初始化值;
		B:数据类型 变量名;
		  变量名 = 初始化值;

5 数据类型

Java是一种强类型语言，针对每种数据都提供了对应的数据类型。

5.1 分类

	A:基本数据类型：4类8种
	B:引用数据类型：类，接口，数组。

5.2 基本数据类型

基本数据类型
		A:整数			占用字节数
			byte			1
			short			2
			int 			4
			long			8
		B:浮点数
			float			4
			double			8
		C:字符
			char			2
		D:布尔
			boolean			1
			
		注意：
			整数默认是int类型，浮点数默认是double。
			
			长整数要加L或者l。
			单精度的浮点数要加F或者f。

5.3 数据类型的转换

(1)boolean类型不参与转换
(2)默认转换
	A:从小到大
	B:byte,short,char -- int -- long -- float -- double
	C:byte,short,char之间不相互转换，直接转成int类型参与运算。
(3)强制转换
	A:从大到小
	B:可能会有精度的损失，一般不建议这样使用。
	C:格式：
		目标数据类型 变量名 = (目标数据类型) (被转换的数据);
(4)思考题和面试题：
	A:下面两种方式有区别吗?
		float f1 = 12.345f;
		float f2 = (float)12.345;
		
		答：f1其实是通过一个double类型强制转换过来的。
		而f2本身就是一个float类型。
	B:下面的程序有问题吗，如果有，在哪里呢?
		byte b1 = 3;
		byte b2 = 4;
		byte b3 = b1 + b2;
		byte b4 = 3 + 4;
	C:下面的操作结果是什么呢?
		byte b = (byte)130;
	D:字符参与运算
		是查找ASCII里面的值
		'a'		97
		'A'		65
		'0'		48
		
		System.out.println('a');
		System.out.println('a' + 1);
	E:字符串参与运算
		这里其实是字符串的连接
		
		System.out.println("hello"+'a'+1);
		System.out.println('a'+1+"hello");
		System.out.println("5+5="+5+5);
		System.out.println(5+5+"=5+5");

B的解答：

/*
    面试题：
            byte b1 = 3,b2=4,b;
            b = b1+b2;
            b = 3+4;
        哪句是编译失败的，为什么？
        b = b1+b2是有问题的；
        因为变量相加，会首先看类型问题，最终把结果赋值也会考虑类型问题。
        常量相加，首先做加法，然后看结果是否在赋值的数据类型的范围内，如果不是才报错
            byte b = 130;有没有问题？如果我想让它赋值正确，可以怎么做，结果是多少？
        练习byte b = 300;
 */
public class DateTypeDemo6 {
    public static void main(String[] args) {
        byte b1 = 3,b2 = 4,b;
        //b = b1 + b2;//这个是类型提升，byte类型的先转为int，然后int赋值给了byte，没有强转出错
        b = 3+4;//常量，先把结果计算出来，然后看是否在byte的范围内，就不报错
    }
}

反编译后，查看：

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   DataTypeDemo6.java
class DataTypeDemo6
{

	DataTypeDemo6()
	{
	}

	public static void main(String args[])
	{
		byte byte0 = 3;
		byte byte1 = 4;
		byte byte2 = 7;
	}
}

证明了，计算机是直接计算出结果7的
C的解答：

/*
	byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?
	
	练习：byte b = (byte)300;
*/
class DataTypeDemo7 {
	public static void main(String[] args) {
		//因为byte的范围是：-128到127。
		//而130不在此范围内，所以报错。
		//byte b = 130; 
		
		//我们可以使用强制类型转换
		byte b = (byte) 130;
		
		//结果是多少呢?
		System.out.println(b);
	}
}
/*
	分析过程：
		我们要想知道结果是什么，就应该知道是如何进行计算的。
		而我们又知道计算机中数据的运算都是补码进行的。
		而要得到补码，首先要计算出数据的二进制。
		
		A:获取130这个数据的二进制。
			00000000 00000000 00000000 10000010
			这是130的原码，也是反码，还是补码。
		B:做截取操作，截成byte类型的了。
			10000010 
			这个结果是补码。
		C:已知补码求原码。
					符号位		数值位
			补码：	1			0000010
			
			反码：	1			0000001
			
			原码：	1			1111110
*/

不同类型的变量，参与运算：

关于D的解答：

/*
	看程序写结果
	
	通过字符和一个整数相加，我们给出一张表：ASCII码表。
		通过看完这张表以后，我们要记住三个值：
			'a'		97
			'A'		65
			'0'		48
*/
class DataTypeDemo8 {
	public static void main(String[] args) {
		//直接输出一个字符
		System.out.println('a'); //a
		//输出一个字符和一个整数做加法
		System.out.println('a'+1); //98
	}
}

byte、short、char参与运算都是先转为int类型，再参与运算
char根据ASCII码表进行转

关于E的解答：

/*
	看程序写结果
		字符串数据和其他数据做+，结果是字符串类型。
		这里的+不是加法运算，而是字符串连接符。
*/
class DataTypeDemo9 {
	public static void main(String[] args) {
		System.out.println("hello"+'a'+1); //helloa1
		System.out.println('a'+1+"hello"); //98hello
		
		System.out.println("5+5="+5+5); //5+5=55
		System.out.println(5+5+"=5+5"); //10=5+5
	}
}

5.4 基本数据类型的取值范围

byte 的取值范围：-128～127（-2的7次方到2的7次方-1）

short 的取值范围：-32768～32767（-2的15次方到2的15次方-1）

int 的取值范围：-2147483648～2147483647（-2的31次方到2的31次方-1）（负的21亿到21亿之间）

long 的取值范围：-9223372036854774808～9223372036854774807（-2的63次方到2的63次方-1

5.5 补充的问题

1:在定义Long或者Float类型变量的时候，要加L或者f。
  整数默认是int类型，浮点数默认是double。
  
  byte，short在定义的时候，他们接收的其实是一个int类型的值。
  这个是自己做了一个数据检测的，如果不再它们的范围内，就报错。
  
2:byte值的问题
	byte b1 = 127;
	byte b2 = (byte)128; //-128
	byte b3 = (byte)129; //-127
	byte b4 = (byte)130; //-126
	
	byte的范围：-128 ~ 127
	
	128：10000000
	-128：10000000 (这里的1即是符号位，也是数值位)
	
3:数据类型转换之默认转换
	byte,short,char -- int -- long -- float -- double
	
	long: 8个字节
	float：4个字节
	
	A:它们底层的数据存储结构不同。
	B:float表示的数据范围比long的范围要大
		long：2^63-1
		float：3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1

4:Java语言中的字符char可以存储一个中文汉字吗?为什么呢?
	可以。因为java语言中的字符占用两个字节。
	
	Java语言采用的是Unicode编码。

6 运算符

运算符：就是对常量和变量进行操作的符号。
分类：算术运算符，赋值运算符，关系运算符，逻辑运算符，位运算符，三目运算符(条件运算符)

6.1 算术运算符：

算术运算符
		A:+,-,*,/,%,++,--
		B:+的用法
			a:加法
			b:正号
			c:字符串连接符
		C:/和%的区别
			数据做除法操作的时候，/取得是商，%取得是余数
		D:++和--的用法
			a:他们的作用是自增或者自减
			b:使用
				**单独使用
					放在操作数据的前面和后面效果一样。
					a++或者++a效果一样。
				**参与操作使用
					放在操作数的前面：先自增或者自减，再参与操作
						int a = 10;
						int b = ++a;
					放在操作数的后面：先参与操作，再自增或者自减
						int a = 10;
						int b = a++;

6.2 赋值运算符

赋值运算符
	A:=,+=,-=,*=,/=,%=等
	B:=叫做赋值运算符，也是最基本的赋值运算符
		int x = 10; 把10赋值给int类型的变量x。
	C:扩展的赋值运算符的特点
		隐含了自动强制转换。
		
		面试题：
			short s = 1;
			s = s + 1;
			
			short s = 1;
			s += 1;
			请问上面的代码哪个有问题?

解答：

/*
	面试题：
		short s=1;s = s+1; 
		
		short s=1;s+=1;
		上面两个代码有没有问题，如果有，那里有问题。
		
		为什么第二个木有问题呢?
			扩展的赋值运算符其实隐含了一个强制类型转换。
			
			s += 1;
			不是等价于 s = s + 1;
			而是等价于 s = (s的数据类型)(s + 1);
*/
class OperatorTest {
	public static void main(String[] args) {
		//short s = 1;
		//s = s + 1;
		//System.out.println(s);
		
		short s = 1;
		s += 1; //好像是 s = s + 1;
		//反编译后 实际是：s = (short)(s + 1);
		System.out.println(s);
	}
}

6.3 比较运算符

比较运算符
	A:==,!=,>,>=,<,<=
	B:无论运算符两端简单还是复杂最终结果是boolean类型。
	C:千万不要把==写成了=

6.4 逻辑运算符

逻辑运算符
	A:&,|,^,!,&&,||
	B:逻辑运算符用于连接boolean类型的式子
	C:结论
		&:有false则false
		|:有true则true
		^:相同则false，不同则true。
			情侣关系。
		!:非true则false，非false则true
		
		&&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。
		||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。

&&和&的区别? 同理||和|的区别?
	A:最终结果一样。
	B:&&具有短路效果。左边是false，右边不执行。
	
开发中常用的逻辑运算符：
	&&,||,!

6.5 位运算符

逻辑运算符与位运算符的区别：

1. 针对数据类型不同：逻辑运算符只能针对boolean类型进行逻辑运算 ，位运算符还可以对数值进行逻辑运算。
2. 逻辑运算符存在短路的现象，即前边的表达式可以得到最终结果是，后面的表达式讲不被执行。而位运算符不存在短路现象，位运算是把两边的数据全部变成二进制补码的形式，然后进行计算的。

位运算符：
		&,|,^,~
		<<,>>,>>>
		
	注意：
		要做位运算，首先要把数据转换为二进制。
	A:^的特殊用法
		一个数据针对另一个数据位异或两次，该数不变
	B:面试题
		a:请实现两个变量的交换
			**采用第三方变量
			**用位异或运算符
				左边a,b,a
				右边a^b
		b:请用最有效率的方式计算出2乘以8的结果
			2<<3

关于A：

/*
	^的特点：一个数据对另一个数据位异或两次，该数本身不变。
*/
class OperatorDemo2 {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		
		System.out.println(a ^ b ^ b); //10 a对b异或两次得a
		System.out.println(a ^ b ^ a); //20 b对a异或两次得b
	}
}

关于B的a：

/*
	面试题：
		请自己实现两个整数变量的交换
		注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
*/
class OperatorTest {
	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		
		System.out.println("a:"+a+",b:"+b);
		
		//方式1：使用第三方变量(开发中用的)
		/*
		int c = a;
		a = b;
		b = c;
		System.out.println("a:"+a+",b:"+b);
		System.out.println("------------");
		*/
		
		//方式2：用位异或实现(面试用)
		//左边：a,b,a
		//右边：a ^ b
		/*
		a = a ^ b;
		b = a ^ b; //a ^ b ^ b = a
		a = a ^ b; //a ^ b ^ a = b
		System.out.println("a:"+a+",b:"+b);
		*/
		
		//方式3：用变量相加的做法
		/*
		a = a + b; //a=30
		b = a - b; //b=10
		a = a - b; //a=20
		System.out.println("a:"+a+",b:"+b);
		*/
		
		//方式4：一句话搞定
		b = (a+b) - (a=b); //b=30-20=10,a=20
		System.out.println("a:"+a+",b:"+b);
	}
}

关于B的b：

/*
	<<:左移	左边最高位丢弃，右边补齐0（左移乘以2的幂）
	>>:右移	最高位是0，左边补齐0；最高为是1，左边补齐1（右移除以2的幂）
	>>>:无符号右移 无论最高位是0还是1，左边补齐0
	
	面试题：
		请用最有效率的方式写出计算2乘以8的结果?
			2 * 8  换算 2*  2的3次幂等于2*8那么左移3位2 << 3

*/
class OperatorDemo3 {
	public static void main(String[] args) {
		//<< 把<<左边的数据乘以2的移动次幂
		System.out.println(3 << 2); //3  *2^2 = 3*4 = 12;
	
		//>> 把>>左边的数据除以2的移动次幂
		System.out.println(24 >> 2); //24  /2^2 = 24 / 4 = 6
		System.out.println(24 >>> 2);
		
		System.out.println(-24 >> 2); 
		System.out.println(-24 >>> 2);
	}
}

6.6 三元运算符

A:格式
	比较表达式?表达式1:表达式2;
B:执行流程：
	首先计算比较表达式的值，看是true还是false。
	如果是true，表达式1就是结果。
	如果是false，表达式2就是结果。
C:案例：
	a:比较两个数据是否相等
	b:获取两个数据中的最大值
	c:获取三个数据中的最大值

//获取三个整数中的最大值
int a = 10;
int b = 30;
int c = 20;

//分两步：
//A:先比较a,b的最大值
//B:拿a,b的最大值在和c进行比较
int temp = ((a > b)? a: b);
//System.out.println(temp);
int max1 = (temp > c? temp: c);
System.out.println("max1:"+max1);

//一步搞定
int max2 = (a > b)?((a > c)? a: c):((b > c)? b: c);
//这种做法不推荐。加括号，让结构清晰
//int max2 = a > b?a > c? a: c:b > c? b: c;
//System.out.println("max2:"+max2);