尚硅谷-java基础-java基本语法

一、关键字与保留字

1.关键字

• 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
• 特点：关键字中所有字母都为小写

2.保留字

• Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使 用。自己命名标识符时要避免使用这些保留字 goto 、const

二、标识符

1.标识符概念

• Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
• 技巧：凡是自己可以起名字的地方都叫标识符。

2.定义规则

• 由26个英文字母大小写，0-9 ，_或 $ 组成
• 数字不可以开头。
• 不可以使用关键字和保留字，但能包含关键字和保留字。
• Java中严格区分大小写，长度无限制。
• 标识符不能包含空格。

3.命名规范

• 包名：多单词组成时所有字母都小写：xxxyyyzzz
• 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个 单词首字母大写：xxxYyyZzz
• 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ 

注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

三、变量

1.变量的概念

• 内存中的一个存储区域
• 该区域的数据可以在同一类型范围内不断变化
• 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值

2.变量的作用

• 用于保存内存中的数据

3.变量使用的注意事项

• Java中每个变量必须先声明，后使用
• 使用变量名来访问这块区域的数据
• 变量的作用域：其定义所在的一对{ }内
• 变量只有在其作用域内才有效
• 同一个作用域内，不能定义重名的变量

4.变量的分类

4.1按照数据类型分类

• 对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分 配了不同大小的内存空间。

 4.2按照声明位置不同

• 在方法体外，类体内声明的变量称为成员变量。
• 在方法体内部声明的变量称为局部变量。

 5.变量类型-整数类型

• 整数类型包括：byte、short、int、long
• Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保 证java程序的可移植性。
• java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’
• java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long

 注：2字节=8bit*2，即2的16次幂，第一位符号位

6.变量类型-浮点类型

• 浮点类型包括：float、double
• 浮点型常量有两种表示形式：
  • 十进制数形式：如：5.12 512.0f .512 (必须有小数点）
  • 科学计数法形式:如：5.12e2 512E2 100E-2
• float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。 double:双精度，精度是float的两倍。通常采用此类型。
• Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’

7.变量类型-字符串类型

• char 型数据用来表示通常意义上“字符”(2字节，18bit位)
• Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
• 字符型变量的三种表现形式：
  • 字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';
  • Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。 例如：char c3 = ‘\n’; // '\n'表示换行符
  • 直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表 一个十六进制整数。如：\u000a 表示 \n。
• char类型是可以进行运算的。因为它都对应有Unicode码。

8.变量类型-布尔类型

• boolean 类型用来判断逻辑条件，一般用于程序流程控制：
  • if条件控制语句；
  • while循环控制语句；
  • do-while循环控制语句；
  • for循环控制语句；
• boolean类型数据只允许取值true和false，无null。
  • 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
  • Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的 boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false 用0表示。———《java虚拟机规范 8版》

四、运算符

1.运算符介绍

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

2.运算符分类

算数运算符、赋值运算符、比较运算符、逻辑运算符、位运算符、三元运算符

3.算术运算符

• 自增运算符与自减运算符
  • 两点注意：
    • （1）注意++a1与a1++都是使得a1自增，单独进行时没有区别，但是当存在赋值的时候有区别，见下面
    • （2）自增或自减不会改变数据的数据类型

//(前)++ :先自增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);
#a1=11 b1=10


short s1 = 10;
//s1 = s1 + 1;//编译失败
//s1 = (short)(s1 + 1);//正确的
s1++;//自增1不会改变本身变量的数据类型
System.out.println(s1);

4.赋值运算符

• 符号：=
  • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制 类型转换原则进行处理。
  • 支持连续赋值。
• 扩展赋值运算符： +=, -=, *=, /=, %=
  • 注意：不会改变数据类型

5.比较运算符

• 比较运算符的结果都是boolean型，也就是要么是true，要么是false。
• 比较运算符“==”不能误写成“=”

 6.逻辑运算符

• 分类：&—逻辑与 、| —逻辑或 、！—逻辑非、 && —短路与 、|| —短路或 、^ —逻辑异或
• “&”和“&&”的区别：
  • 单&时，左边无论真假，右边都进行运算；  
  • 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。 
• “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。

class LogicTest {
	public static void main(String[] args) {
		
		//区分& 与 &&
		//相同点1：& 与  && 的运算结果相同
		//相同点2：当符号左边是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 = " + num1);
		

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

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

		// 区分：| 与 || 
		//相同点1：| 与  || 的运算结果相同
		//相同点2：当符号左边是false时，二者都会执行符号右边的运算
		//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
		//开发中，推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num3 = " + num3);


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

7.三元运算符

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

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 num = (m > n)? 2 : 1.0;

		//(m > n)? 2 : "n大";//编译错误

		//**************************
		n = 12;
		String maxStr = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
		System.out.println(maxStr);

		//*****************************
		//获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;
		
		int max1 = (n1 > n2)? n1 : n2;
		int max2 = (max1 > n3)? max1 : n3;
		System.out.println("三个数中的最大值为：" + max2);

		//不建议
		//int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
		System.out.println("三个数中的最大值为：" + max3);

		//该写成if-else:
		if(m > n){
			System.out.println(m);
		}else{
			System.out.println(n);
		}
	}
}

8.运算符优先级

• 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运算符总优先于下一行。
• 只有单目运算符、三元运算符、 赋值运算符是从右向左运算的。

五、程序流程控制

1.程序流程控制介绍

• 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组 合成能完成一定功能的小逻辑模块。
• 程序流程控制分类：顺序结构、分支结构、循环结构
  • 顺序结构
    • 程序从上到下逐行地执行，中间没有任何判断和跳转。
  • 分支结构
    • 根据条件，选择性地执行某段代码。
    • 有if…else和switch-case两种分支语句。
  • 循环结构
    • 根据循环条件，重复性的执行某段代码。
    • 有while、do…while、for三种循环语句。

注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

2.程序流程控制-顺序结构

• java中定义成员变量时采用合法的前向引用

3.程序流程控制-分支结构

(1)if else

• 语法结构：

第一种：
if(条件表达式){
	执行表达式
}

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

第三种：n选一
if(条件表达式){
	执行表达式1
}else if(条件表达式){
	执行表达式2
}else if(条件表达式){
	执行表达式3
}
...
else{
	执行表达式n
}

•  注意事项：
  • 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
  • 语句块只有一条执行语句时，一对{}可以省略，但建议保留
  • if-else语句结构，根据需要可以嵌套使用
  • 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
  • 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓 当多个条件是“包含”关系时，“小上大下 / 子上父下”
• 案例:

class IfTest {
	public static void main(String[] args) {
		
		//举例1
		int heartBeats = 79;
		if(heartBeats < 60 || heartBeats > 100){
			System.out.println("需要做进一步检查");
		}

		System.out.println("检查结束");
		
		//举例2
		int age = 23;
		if(age < 18){
			System.out.println("你还可以看动画片");
		}else{
			System.out.println("你可以看成人电影了");
		}

		//举例3
		if(age < 0){
			System.out.println("您输入的数据非法");
		}else if(age < 18){
			System.out.println("青少年时期");
		}else if(age < 35){
			System.out.println("青壮年时期");
		}else if(age < 60){
			System.out.println("中年时期");
		}else if(age < 120){
			System.out.println("老年时期");
		}else{
			System.out.println("你是要成仙啊~~");
		}
	}
}

(2)switch-cae

•  语法结构：

switch(表达式){
case 常量1:
	执行语句1;
	//break;

case 常量2:
	执行语句2;
	//break;

...

default:
	执行语句n;
	//break;

}

• 注意事项：
  • 根据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结构是可选的，而且位置是灵活的
• 案例：

class SwitchCaseTest {
	public static void main(String[] args) {
		
		int number = 5;
		switch(number){
		
		case 0:
			System.out.println("zero");
			break;
		case 1:
			System.out.println("one");
			break;
		case 2:
			System.out.println("two");
			break;
		case 3:
			System.out.println("three");
			break;
		default:
			System.out.println("other");
			//break;
		}


		String season = "summer";
		switch (season) {
		case "spring":
			System.out.println("春暖花开");
			break;
		case "summer":
			System.out.println("夏日炎炎");
			break;
		case "autumn":
			System.out.println("秋高气爽");
			break;
		case "winter":
			System.out.println("冬雪皑皑");
			break;
		default:
			System.out.println("季节输入有误");
			break;
		}



		//**************如下的两种情况都编译不通过*********************
		//情况一
		/*
		boolean isHandsome = true;
		switch(isHandsome){
		
		case true:
			System.out.println("我好帅啊~~~");
			break;
		case false:
			System.out.println("我好丑啊~~~");
			break;
		default:
			System.out.println("输入有误~~~");
		}
		*/
		//情况二
		/*
		int age = 10;
		switch(age){
		case age > 18:
			System.out.println("成年了");
			break;
		default:
			System.out.println("未成年");
		}
		*/
	}
}

if与swich语句对比

• 如果判断的具体数值不多，而且符合byte、short 、char、int、String、枚举等几 种类型。虽然两个语句都可以使用，建议使用swtich语句。因为效率稍高。
• 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。 也就是说，使用switch-case的，都可以改写为if-else。反之不成立。

3.程序流程控制-循环结构

• 循环结构分类：for循环、while循环、do-while循环

 3.1 for循环

• For循环结构的使用
  • 循环结构的4个要素
    • ① 初始化条件
    • ② 循环条件  --->是boolean类型
    • ③ 循环体
    • ④ 迭代条件
  • for循环的结构
    • for(①;②;④){
    •     ③
    • }
  • 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
  • 案例

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

		/*
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		*/

		for(int i = 1;i <= 5;i++){//i:1,2,3,4,5
			System.out.println("Hello World!");
		}
		//i:在for循环内有效。出了for循环就失效了。
		//System.out.println(i);
		
		//练习：
		int num = 1;
		for(System.out.print('a');num <= 3;System.out.print('c'),num++){
			System.out.print('b');
		}
		//输出结果：abcbcbc

		System.out.println();

		//例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
		int sum = 0;//记录所有偶数的和
		int count = 0;//记录偶数的个数
		for(int i = 1;i <= 100;i++){
			
			if(i % 2 == 0){
				System.out.println(i);
				sum += i;
				count++;
			}
			//System.out.println("总和为：" + sum);
		}

		System.out.println("总和为：" + sum);
		System.out.println("个数为：" + count);

	}
}

3.2while循环

• while循环
  • while循环结构
    • ① 初始化条件
    • ② 循环条件  --->是boolean类型
    • ③ 循环体
    • ④ 迭代条件
  • while循环的结构
    • ①
    • while(②){
    •     ③;
    •     ④;
    • }
  • 执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②
  • 案例

class  WhileTest{
	public static void main(String[] args) {
		
		//遍历100以内的所有偶数
		int i = 1;
		while(i <= 100){
			
			if(i % 2 == 0){
				System.out.println(i);
			}
			
			i++;
		}
		//出了while循环以后，仍可以调用。
		System.out.println(i);//101

	}
}

• 注意事项
  • 写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
  • 我们写程序，要避免出现死循环。
  • for循环和while循环是可以相互转换的！区别：for循环和while循环的初始化条件部分的作用范围不同。

3.3 do-while循环

•  do-while循环
  •  do-while循环结构的4个要素
    • ① 初始化条件
    • ② 循环条件  --->是boolean类型
    • ③ 循环体
    • ④ 迭代条件
  • do-while循环结构：
    • ①
    • do{
    •     ③;
    •     ④;
    • }while(②);
  • 执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②
  • 案例

class DoWhileTest {
	public static void main(String[] args) {
		
		//遍历100以内的偶数,并计算所有偶数的和及偶数的个数
		int num = 1;
		int sum = 0;//记录总和
		int count = 0;//记录个数
		do{
			
			if(num % 2 == 0){
				System.out.println(num);
				sum += num;
				count++;
			}

			num++;

		}while(num <= 100);
		

		System.out.println("总和为：" + sum);
		System.out.println("个数为：" + count);

		//*************体会do-while至少执行一次循环体***************
		int number1 = 10;
		while(number1 > 10){
			System.out.println("hello:while");
			number1--;
		}

		int number2 = 10;
		do{
			System.out.println("hello:do-while");
			number2--;
		}while(number2 > 10);

	}
}

• 注意事项
  • do-while循环至少会执行一次循环体！
  • 开发中，使用for和while更多一些。较少使用do-while

3.4 特殊流程控制语句

• break 语句
  • break语句用于终止某个语句块的执行
  • break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
• continue 语句
  • continue只能使用在循环结构中
  • continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
  • continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
• return语句
  • return并非专门用于结束循环的，它的功能是结束一个方法。 当一个方法执行到一个return语句时，这个方法将被结束。
  • 与break和continue不同的是，return直接结束整个方法，不管 这个return处于多少层循环之内
• 流程控制语句案例

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

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



*/
class BreakContinueTest {
	public static void main(String[] args) {

		for(int i = 1;i <= 10;i++){
		
			if(i % 4 == 0){
				break;//123
				//continue;//123567910
				//System.out.println("今晚迪丽热巴要约我！！！");
			}
			System.out.print(i);
		}

		System.out.println("\n");
		//******************************
		
		label:for(int i = 1;i <= 4;i++){
		
			for(int j = 1;j <= 10;j++){
				
				if(j % 4 == 0){
					//break;//默认跳出包裹此关键字最近的一层循环。
					//continue;

					//break label;//结束指定标识的一层循环结构
					continue label;//结束指定标识的一层循环结构当次循环
				}
				
				System.out.print(j);
			}
			
			System.out.println();
		}
	}
}

• 流程控制语句注意事项
  • break只能用于switch语句和循环语句中。
  • continue 只能用于循环语句中。
  • 二者功能类似，但continue是终止本次循环，break是终止本层循环。
  • break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
  • 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
  • 很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条 语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同 于goto的。

项目1（待完成...）