Java基础2---Java语言基础

最新推荐文章于 2022-05-29 20:11:12 发布

Sky_LBK

最新推荐文章于 2022-05-29 20:11:12 发布

阅读量323

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/weixin_41944347/article/details/88657686

版权

Java基础专栏收录该内容

15 篇文章 1 订阅

订阅专栏

知识点的根据黑马程序员视频总结

(常量的概述和使用)(掌握)

A:什么是常量
- 在程序执行的过程中其值不可以发生改变
B:Java中常量的分类
- 字面值常量
- 自定义常量(面向对象部分讲)
C:字面值常量的分类
- 字符串常量用双引号括起来的内容
- 整数常量所有整数
- 小数常量所有小数
- 字符常量用单引号括起来的内容,里面只能放单个数字,单个字母或单个符号
- 布尔常量较为特殊，只有true和false
- 空常量 null(数组部分讲解)

(不同进制数据的表现形式)(掌握)

A:二进制的数据表现形式
- 由0,1组成。以0b(b可以大写也可以小写)开头(JDK1.7版本可以表示二进制了)
B:八进制的数据表现形式
- 由0,1,…7组成。以0开头
C:十进制的数据表现形式
- 由0,1,…9组成。整数默认是十进制的
D:十六进制的数据表现形式
- 由0,1,…9,a,b,c,d,e,f(大小写均可)。以0x开头

(快速的进制转换法)(了解)

A:8421码及特点
- 8421码是中国大陆的叫法，8421码是BCD代码中最常用的一种。在这种编码方式中每一位二值代码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数码。
B:通过8421码的方式进行二进制和十进制的相互转换
C:二进制到八进制的简易方式
D:二进制到十六进制的简易方式

(原码反码补码)(了解)

A:为什么要学习原码反码补码?
- 后面要学习强制类型转换,如果不知道有原反补会看不懂结果
B:有符号数据表示法的几种方式
- 原码
  - 就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
  - 通过一个字节,也就是8个二进制位表示+7和-7
  - 0(符号位) 0000111
  - 1(符号位) 0000111
- 反码
  - 正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
- 补码
  - 正数的补码与其原码相同；负数的补码是在其反码的末位加1。

(变量的概述及格式)(掌握)

A:什么是变量
- 在程序执行的过程中，在某个范围内其值可以发生改变的量
B:变量的定义格式
- 数据类型变量名 = 变量值;
C:为什么要定义变量
- 用来不断的存放同一类型的常量，并可以重复使用

(数据类型的概述和分类)(掌握)

A:为什么有数据类型
- Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
B:Java中数据类型的分类
- 基本数据类型
- 引用数据类型
  - 面向对象部分讲解
C:基本数据类型分类(4类8种)
- 整数型
  - byte 占一个字节 -128到127
  - short 占两个字 -2¹⁵~2¹⁵-1
  - int 占四个字节 -2³¹~2³¹-1
  - long 占八个字节 -2⁶~2⁶³-1
- 浮点型
  - float 占四个字节 -3.403E38~3.403E38 单精度
  - double 占八个字节-1.798E308~1.798E308 双精度
- 字符型
  - char 占两个字节 0~65535
  - 没有复数
- 布尔型
  - boolean
    - boolean理论上是占八分之一个字节,因为一个开关就可以决定是true和false了,但是java中boolean类型没有明确指定他的大小

(使用变量的注意事项)(掌握)

a:作用域问题
- 同一个区域不能使用相同的变量名
b:初始化值问题
- 局部变量在使用之前必须赋值
c:一条语句可以定义几个变量
- int a,b,c…;

(数据类型转换之隐式转换)(掌握)

A:案例演示
- a:int + int
- b:byte + int
B:Java中的默认转换规则
- 取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算

(数据类型转换之强制转换)(掌握)

A:强制转换问题
- int a = 10;
- byte b = 20;
- b = a + b;
B:强制转换的格式
- b = (byte)(a + b);
C:强制转换的注意事项
- 如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同

(面试题之变量相加和常量相加的区别)(掌握)

A:案例演示
- 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
- byte b1 = 3;
- byte b2 = 4;
- byte b3 = b1 + b2;
  - 从两方面去回答这个题
  - b1和b2是两个变量,变量里面存储的值都是变化的,所以在程序运行中JVM是无法判断里面具体的值
  - byte类型的变量在进行运算的时候,会自动类型提升为int类型
- byte b4 = 3 + 4;
  - 3和4都是常量,java有常量优化机制,就是在编译的的时候直接把3和4的结果赋值给b4了

Java语言基础(long与float的取值范围谁大谁小)(了解)

进行混合运算的时候,byte,short,char不会相互转换,都会自动类型提升为int类型,其他类型进行混合运算的是小的数据类型提升为大的
- byte,short,char – int – long – float – double
- long: 8个字节
- float：4个字节
- IEEE754:0代表0，255表示无穷大
- float 4个字节是32个二进制位
- 1位是符号位
- 8位是指数位
- 00000000 — 11111111
- 0到255
- 1到254
- -126到127
- 23位是尾数位
- 每个指数位减去127
- A:它们底层的存储结构不同。
- B:float表示的数据范围比long的范围要大
  - long：2⁶³-1
  - float：3.4x10³⁸ > 2 x10³⁸ > 2x8³⁸= 2x2^3*38 = 2 x 2¹¹⁴ > 2⁶³-1

Java语言基础(字符和字符串参与运算)(掌握)

A:案例演示
- System.out.println(‘a’); //97
- System.out.println(‘a’+1); //98,因为由ASCII码表，a字符对应的是int类型的97
- 通过看结果知道’a’的值是多少,由此引出ASCII码表
B:ASCII码表的概述
- 记住三个值：
  - ’0’ 48
  - ’A’ 65
  - ’a’ 97
C:案例演示
- System.out.println(“hello”+‘a’+1);//helloa1
- System.out.println(‘a’+1+“hello”);//98hello
D:+在有字符串参与中被称为字符串连接符任何数据类型用+与字符串相连接都会产生一个新的字符串
- System.out.println(“5+5=”+5+5);//5+5=55
- System.out.println(5+5+"=5+5");//10=5+5

Java语言基础(char数据类型)(掌握)

A:char c = 97; 0到65535
B:Java语言中的字符char可以存储一个中文汉字吗?为什么呢?
- 可以。因为Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。中文也是占的两个字节
- 所以，Java中的字符可以存储一个中文汉字

(算术运算符的基本用法)(掌握)

A:什么是运算符
- 就是对常量和变量进行操作的符号。
B:运算符的分类
- 算术运算符，赋值运算符，比较(关系或条件)运算符，逻辑运算符，位运算符，三目(元)运算符
C:算数运算符有哪些
- +,-,*,/,%(取模，取余数),++,–
D:注意事项：
- a:+号在java中有三种作用,代表正号,做加法运算,字符串的连接符
- b:整数相除只能得到整数。如果想得到小数，必须把其中一个数据变化为浮点数类型，另一个数在运算时会自动类型提升
- c:/获取的是除法操作的商，%获取的是除法操作的余数
- %运算符
  - 当左边的绝对值小于右边绝对值时,结果是左边
  - 当左边的绝对值等于右边或是右边的倍数时,结果是0
  - 当左边的绝对值大于右边绝对值时,结果是余数
  - %运算符结果的符号只和左边有关系,与右边无关
  - 任何一个正整数%2结果不是0就是1可以用来当作切换条件

(算术运算符++和–的用法)(掌握)

A:++,–运算符的作用
- 自加（++）自减（–）运算
- ++:自加。对原有的数据进行+1
- – -:自减。对原有的数据进行-1
B:案例演示
- a:单独使用：
  - 放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
- b:参与运算使用：
  - 放在操作数的前面，先自增或者自减，然后再参与运算。
  - 放在操作数的后面，先参与运算，再自增或者自减。

(算术运算符++和–的练习)(掌握)

A:案例演示

请分别计算出a,b,c的值?

  int a = 10;
  int b = 10;
  int c = 10;

  a = b++;		//a =10,b=11
  c = --a;			//a=9,c=9
  b = ++a;		//a=10,b=10
  a = c--;			//a=9,c=8

B:案例演示

请分别计算出x,y的值?

  int x = 4;
  int y = (x++)+(++x)+(x*10);//70
  		//	4 +6 +60

C:面试题
```
	byte b = 10;
	b++;
	b = b + 1;`
```

* 问哪句会报错,为什么 
	* b++==> b=(byte)b+1;不报错
	* 当byte与int进行混合运算时，会提升为int类型，结果为int类型，再赋值给byte时会损失精度，报错

(赋值运算符的基本用法)(掌握)

A:赋值运算符有哪些
- a:基本的赋值运算符：=
  - 把=右边的数据赋值给左边。
- b:扩展的赋值运算符：+=,-=,*=,/=,%=
  - += 把左边和右边做加法，然后赋值给左边。

(赋值运算符的面试题)(掌握)

A:案例演示

面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
	short s=1;s = s+1;//报错，会提升为int类型，结果为int类型，再赋值给short时会损失精度，报错
	short s=1;s+=1；//没错，

(关系运算符的基本用法及其注意事项)(掌握)

A:关系运算符有哪些(比较运算符,条件运算符)
- ==,!=,>,>=,<,<=
注意事项：
- 无论你的操作是简单还是复杂，结果是boolean类型。
- “==“不能写成”=”。

(逻辑运算符的基本用法)(掌握)

A:逻辑运算符有哪些
- &,|,^,!
- &&,||
B:案例演示
- 逻辑运算符的基本用法

		//逻辑与 & 并且and 遇false则false
		int a = 10;
		int b = 20;
		int c = 30;
		/*System.out.println(a < b & b < c);			//true & true = true
		System.out.println(a < b & b > c);				//true & false = false
		System.out.println(a > b & b < c);				//false & true = false
		System.out.println(a > b & b > c);				//false & false = false*/

		//逻辑或 或or 遇true则true
		/*System.out.println(a < b | b < c);			//true | true = true
		System.out.println(a < b | b > c);				//true | false = true
		System.out.println(a > b | b < c);				//false | true = true
		System.out.println(a > b | b > c);				//false | flase = false*/

		//逻辑异或 ^ 两边相同为false,两边不同为true
		/*System.out.println(a < b ^ b < c);			//true | true = false
		System.out.println(a < b ^ b > c);				//true | false = true
		System.out.println(a > b ^ b < c);				//false | true = true
		System.out.println(a > b ^ b > c);				//false | flase = false*/

		//逻辑非!
		System.out.println(!true);
		System.out.println(!!true);

注意事项：
- a:逻辑运算符一般用于连接boolean类型的表达式或者值。
- b:表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
  - 算术表达式：a + b
  - 比较表达式：a == b(条件表达式)
C:结论：
- &逻辑与:有false则false。
- |逻辑或:有true则true。
- ^逻辑异或:相同为false，不同为true。
- !逻辑非:非false则true，非true则false。
  - 特点：偶数个不改变本身。

(逻辑运算符&&和&的区别)(掌握)

A:案例演示
- &&和&的区别?
  - a:最终结果一样。
  - b: &&具有短路效果。左边是false，右边不执行。
  - c: &是无论左边是false还是true,右边都会执行

/*      int a = 10;
		int b = 20;
		int c = 30;
		System.out.println(a < b && b < c);				//true && true = true
		System.out.println(a < b && b > c);				//true && false = false
		System.out.println(a > b && b < c);				//false && true = false
		System.out.println(a > b && b > c);				//false && false = false   */

		int x = 3;
		int y = 4;
		//System.out.println((++x == 3) & (++y == 4));	//false & false = false
		//System.out.println("x = " + x);					//x = 4
		//System.out.println("y = " + y);					//y = 5
		System.out.println("---------------------------");
		System.out.println((++x == 3) && (++y == 4));	//false & false = false
		System.out.println("x = " + x);					//x = 4
		System.out.println("y = " + y);					//y = 4

B:同理||和|的区别?
C:开发中常用谁?
- &&,||,!

(位运算符的基本用法1)(了解)

A:位运算符有哪些
- &,|,^,~ ,>>,>>>,<<
B:案例演示
- 位运算符的基本用法1

		* &,|,^,~ 的用法
		* &:有0则0
		* |:有1则1
		* ^:相同则0，不同则1
		* ~:按位取反

		System.out.println(6 & 3);				//2
		System.out.println(6 | 3);				//7
		System.out.println(6 ^ 3);				//5	
		System.out.println(~6);					//-7?
		/*
				110
			&	011
			-----------
			    010
			
				110
			|	011
			-----------
			    111
			
				110
			^	011
			-----------
			    101
			
				00000000 00000000 00000000 00000110		6的原码反码补码都是本身
				11111111 11111111 11111111 11111001		对6取反
			-	00000000 00000000 00000000 00000001      -1
		---------------------------------------
			11111111 11111111 11111111 11111000		反码
			10000000 00000000 00000000 00000111		原码(-7)
	*/

(位异或运算符的特点及面试题)(掌握)

A:案例演示
- 位异或运算符的特点
- ^的特点：一个数据对另一个数据位异或两次，该数本身不变。
B:面试题：
- 请自己实现两个整数变量的交换（不需要定义第三方变量）
- 注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。

public static void main(String[] args) {
		int x = 10;
		int y = 5;

		//需要第三方变量,开发推荐用这种
		/*int temp;
		temp = x;
		x = y;
		y = temp;*/

		//不需要定义第三方变量,有弊端,有可能会超出int的取值范围
		/*x = x + y;			//10 + 5 = 15
		y = x - y;				//15 - 5 = 10
		x = x - y;				//15 - 10 = 5*/

		//不需要第三方变量,通过^来做
		x = x ^ y;				// 10 ^ 5 
		y = x ^ y;				// 10 ^ 5 ^ 5	y = 10
		x = x ^ y;				// 10 ^ 5 ^ 10  x = 5

		System.out.println("x = " + x + ",y = " + y);
	}

(位运算符的基本用法2及面试题)(了解)

A:案例演示 >>,>>>,<<的用法:
<<:左移左边最高位丢弃，右边补齐0
>>:右移最高位是0，左边补齐0;最高为是1，左边补齐1
>>>:无符号右移无论最高位是0还是1，左边补齐0
最有效率的算出2 * 8的结果
2<<3:

(三元运算符的基本用法)(掌握)

A:三元运算符的格式

  (关系表达式) ? 表达式1 : 表达式2;

B:三元运算符的执行流程
C:案例演示
- 获取两个数中的最大值

		int x = 10;
		int y = 5;
		int z;
		z = (x > y) ? x : y;

		System.out.println("z = " + z)

(三元运算符的练习)(掌握)

A:案例演示
- 比较两个整数是否相同
B:案例演示
- 获取三个整数中的最大值

###03.08_Java语言基础(键盘录入的基本格式讲解)(掌握)

A:为什么要使用键盘录入数据
- a:为了让程序的数据更符合开发的数据
- b:让程序更灵活一下
B:如何实现键盘录入呢?
- 先照格式来。
- a:导包
  - 格式：
    - import java.util.Scanner;
  - 位置：
    - 在class上面。
- b:创建键盘录入对象
  - 格式：
    - Scanner sc = new Scanner(System.in);
- c:通过对象获取数据
  - 格式：
    - int x = sc.nextInt();
C:案例演示
- 键盘录入1个整数，并输出到控制台。
- 键盘录入2个整数，并输出到控制台。

/*
* a:导包
		* 格式：
			* import java.util.Scanner; 
		* 位置：
			* 在class上面。
	* b:创建键盘录入对象
		* 格式：
			* Scanner sc = new Scanner(System.in);
	* c:通过对象获取数据	
		* 格式：
			* int x = sc.nextInt();
*/
import java.util.Scanner;
class Demo2_Scanner {
	public static void main(String[] args) {
		/*Scanner sc = new Scanner(System.in);			//创建键盘录入对象
		System.out.println("请输入一个整数:");
		int x = sc.nextInt();							//将键盘录入的数据存储在x中
		System.out.println(x);*/

		//录入两个整数
		Scanner sc = new Scanner(System.in);			//创建键盘录入对象
		System.out.println("请输入第一个整数:");
		int x = sc.nextInt();							//将键盘录入的数据存储在x中
		System.out.println(x);

		System.out.println("请输入第二个整数:");
		int y = sc.nextInt();							//将键盘录入的数据存储在y中
		System.out.println(y);
	}
}

(键盘录入的练习1)(掌握)

A:案例演示
- 键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果
B:案例演示
- 键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值

import java.util.Scanner;						//导入包中的类Scanner
class Test2_Scanner {
	/*
	* A:案例演示
		* 键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果
	* B:案例演示
		* 键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值

	*/
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);	//创建键盘录入对象
		
		//键盘录入练习：键盘录入两个数据，并对这两个数据求和，输出其结果
		/*System.out.println("请输入第一个整数:");
		int x = sc.nextInt();					//将键盘录入的数据存储在x中
		System.out.println("请输入第二个整数:");
		int y = sc.nextInt();					//将键盘录入的数据存储在y中
		int sum = x + y;
		System.out.println(sum);*/

		//键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值
		System.out.println("请输入第一个整数:");
		int x = sc.nextInt();					//将键盘录入的数据存储在x中
		System.out.println("请输入第二个整数:");
		int y = sc.nextInt();					//将键盘录入的数据存储在y中

		int max = (x > y) ? x : y;				//获取x和y中的最大值
		System.out.println("max = " + max);
	}
}

(键盘录入的练习2)(掌握)

/*
* A:案例演示
	* 键盘录入练习：键盘录入两个数据，比较这两个数据是否相等
* B:案例演示
	* 键盘录入练习：键盘录入三个数据，获取这三个数据中的最大值
*/
import java.util.Scanner;							//导包
class Test3_Scanner {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);		//创建键盘录入对象

		//键盘录入练习：键盘录入两个数据，比较这两个数据是否相等
		/*System.out.println("请输入第一个整数:");
		int x = sc.nextInt();						//将键盘录入的数据存储在x中
		System.out.println("请输入第二个整数:");
		int y = sc.nextInt();						//将键盘录入的数据存储在y中

		//boolean b = (x == y)? true : false;
		boolean b = (x == y);
		System.out.println(b);*/

		//键盘录入练习：键盘录入三个数据，获取这三个数据中的最大值
		System.out.println("请输入第一个整数:");
		int x = sc.nextInt();						//将键盘录入的数据存储在x中
		System.out.println("请输入第二个整数:");
		int y = sc.nextInt();						//将键盘录入的数据存储在y中
		System.out.println("请输入第三个整数:");
		int z = sc.nextInt();						//将键盘录入的数据存储在y中

		//定义临时变量记录住比较出前两个变量中的最大值
		int temp = (x > y) ? x : y;
		//将比较后的结果与第三个变量中的值比较,比较出三个数中的最大值
		int max = (temp > z) ? temp : z;
		System.out.println(max);
	}
}

(顺序结构语句)(了解)

A:什么是流程控制语句
- 流程控制语句：可以控制程序的执行流程。
B:流程控制语句的分类
- 顺序结构
- 选择结构
- 循环结构
C:执行流程：
- 从上往下，依次执行。
D:案例演示
- 输出几句话看效果即可

(选择结构if语句格式1及其使用)(掌握)

A:选择结构的分类
- if语句
- switch语句
B:if语句有几种格式
- 格式1
- 格式2
- 格式3
C:if语句的格式1

  if(比较表达式) {
  	语句体;
  }

D:执行流程：
- 先计算比较表达式的值，看其返回值是true还是false。
- 如果是true，就执行语句体；
- 如果是false，就不执行语句体；

(选择结构if语句注意事项)(掌握)

A:案例演示
- a:比较表达式无论简单还是复杂，结果必须是boolean类型
- b:if语句控制的语句体如果是一条语句，大括号可以省略；
  - 如果是多条语句，就不能省略。建议永远不要省略。
- c:一般来说：有左大括号就没有分号，有分号就没有左大括号

(选择结构if语句格式2及其使用)(掌握)

A:if语句的格式2

  if(比较表达式) {
  	语句体1;
  }else {
  	语句体2;
  }

B:执行流程：
- 首先计算比较表达式的值，看其返回值是true还是false。
- 如果是true，就执行语句体1；
- 如果是false，就执行语句体2；
C:案例演示
- a:获取两个数据中较大的值
- b:判断一个数据是奇数还是偶数,并输出是奇数还是偶数
- 注意事项：else后面是没有比较表达式的，只有if后面有。

(if语句的格式2和三元的相互转换问题)(掌握)

A:案例演示
- if语句和三元运算符完成同一个效果
B:案例演示
- if语句和三元运算符的区别
  - 三元运算符实现的，都可以采用if语句实现。反之不成立。
- 什么时候if语句实现不能用三元改进呢?
  - 当if语句控制的操作是一个输出语句的时候就不能。
  - 为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。

(选择结构if语句格式3及其使用)(掌握)

A:if语句的格式3：

  if(比较表达式1) {
  	语句体1;
  }else if(比较表达式2) {
  	语句体2;
  }else if(比较表达式3) {
  	语句体3;
  }
  ...
  else {
  	语句体n+1;
  }

B:执行流程：
- 首先计算比较表达式1看其返回值是true还是false，
- 如果是true，就执行语句体1，if语句结束。
- 如果是false，接着计算比较表达式2看其返回值是true还是false，
- 如果是true，就执行语句体2，if语句结束。
- 如果是false，接着计算比较表达式3看其返回值是true还是false，
- 如果都是false，就执行语句体n+1。
C:注意事项:最后一个else可以省略,但是建议不要省略,可以对范围外的错误值提示

(选择结构if语句格式3练习)(掌握)

A:练习1

  需求：键盘录入一个成绩，判断并输出成绩的等级。
  90-100 优
  80-89  良
  70-79  中
  60-69  及
  0-59   差

B:练习

需求：
键盘录入x的值，计算出y的并输出。
x>=3 y = 2 * x + 1;
-1<x<3 y = 2 * x;
x<=-1 y = 2 * x - 1;

(选择结构if语句的嵌套使用)(掌握)

A:案例演示
- 需求：获取三个数据中的最大值
- if语句的嵌套使用。

(选择结构switch语句的格式及其解释)(掌握)

A:switch语句的格式

  switch(表达式) {
        case 值1：
  		语句体1;
  		break;
  	    case 值2：
  		语句体2;
  		break;
  	    …
  	    default：	
  		语句体n+1;
  		break;
  }

B:switch语句的格式解释
C:面试题
- byte可以作为switch的表达式吗?
- long可以作为switch的表达式吗？不可以
- String可以作为switch的表达式吗?
  - //基本数据类型可以接收byte,short,char,int
    //引用数据类型可以接收枚举(JDK1.5)String字符串(JDK1.7)
D:执行流程
* 先计算表达式的值
* 然后和case后面的匹配，如果有就执行对应的语句，否则执行default控制的语句

(选择结构switch语句的练习)(掌握)

A:整数(给定一个值,输出对应星期几)

class Test1_Switch {
	public static void main(String[] args) {
		//* A:整数(给定一个值,输出对应星期几)
		int week = 1;
		switch (week) {
		case 1:
			System.out.println("星期一");
		break;
		case 2:
			System.out.println("星期二");
		break;
		case 3:
			System.out.println("星期三");
		break;
		case 4:
			System.out.println("星期四");
		break;
		case 5:
			System.out.println("星期五");
		break;
		case 6:
			System.out.println("星期六");
		break;
		case 7:
			System.out.println("星期日");
		break;
		default:
			System.out.println("对不起没有对应的星期");
		break;
		}
	}
}

(选择结构switch语句的注意事项)(掌握)

A:案例演示
- a:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
- b:default可以省略吗?
  - 可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
  - 特殊情况：
    - case就可以把值固定。
    - A,B,C,D
- c:break可以省略吗?
  - 最后一个可以省略,其他最好不要省略
  - 会出现一个现象：case穿透。
  - 最终我们建议不要省略
- d:default一定要在最后吗?
  - 不是，可以在任意位置。但是建议在最后。
- e:switch语句的结束条件
  - a:遇到break就结束了
  - b:执行到switch的右大括号就结束了

(选择结构switch语句练习)(掌握)

A:看程序写结果：

  int x = 2;
  int y = 3;
  switch(x){
  	default:
  		y++;
  		break;
  	case 3:
  		y++;
  	case 4:
  		y++;
  }
  System.out.println("y="+y);

//y=4

B:看程序写结果：

  int x = 2;
  int y = 3;
  switch(x){
  	default:
  		y++;
  	case 3:
  		y++;
  	case 4:
  		y++;
  }
  System.out.println("y="+y);

y=6

(选择结构if语句和switch语句的区别)(掌握)

A:总结switch语句和if语句的各自使用场景
switch建议判断固定值的时候用
if建议判断区间或范围的时候用
B:案例演示
- 分别用switch语句和if语句实现下列需求：
  - 键盘录入月份，输出对应的季节(case穿透)

		Scanner sc = new Scanner(System.in);	//创建键盘录入对象
		System.out.println("请输入月份");
		int month = sc.nextInt();				//将键盘录入的结果存储在month
		/*switch (month) {
		case 3:
		case 4:
		case 5:
			System.out.println(month + "月是春季");
		break;
		case 6:
		case 7:
		case 8:
			System.out.println(month + "月是夏季");
		break;
		case 9:
		case 10:
		case 11:
			System.out.println(month + "月是秋季");
		break;
		case 12:
		case 1:
		case 2:
			System.out.println(month + "月是冬季");
		break;
		default:
			System.out.println("对不起没有对应的季节");
		break;
		}

		//用if语句来完成月份对应季节
		if (month > 12 || month < 1) {
			System.out.println("对不起没有对应的季节");
		}else if (month >= 3 && month <= 5) {
			System.out.println(month + "月是春季");
		}else if (month >= 6 && month <= 8) {
			System.out.println(month + "月是夏季");
		}else if (month >= 9 && month <= 11) {
			System.out.println(month + "月是秋季");
		}else {
			System.out.println(month + "月是冬季");
		}

(循环结构概述和for语句的格式及其使用)

A:循环结构的分类
- for,while,do…while
B:循环结构for语句的格式：

  for(初始化表达式;条件表达式;循环后的操作表达式) {
  	循环体;
  }

C执行流程：
- a:执行初始化语句
- b:执行判断条件语句,看其返回值是true还是false
  - 如果是true，就继续执行
  - 如果是false，就结束循环
- c:执行循环体语句;
- d:执行循环后的操作表达式
- e:回到B继续。
D:案例演示
- 在控制台输出10次"helloworld"

(循环结构for语句的练习之获取数据)

A:案例演示
- 需求：请在控制台输出数据1-10
- 需求：请在控制台输出数据10-1
B:注意事项
- a:判断条件语句无论简单还是复杂结果是boolean类型。
- b:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
- c:一般来说：有左大括号就没有分号，有分号就没有左大括号

(循环结构for语句的练习之求和思想)

A:案例演示
- 需求：求出1-10之间数据之和
B:学生练习
- 需求：求出1-100之间偶数和
- 需求：求出1-100之间奇数和

(循环结构for语句的练习之水仙花)

A:案例演示
- 需求：在控制台输出所有的”水仙花数”
  - 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
    - 举例：153就是一个水仙花数。
    - 153 = 111 + 555 + 333 = 1 + 125 + 27 = 153

public static void main(String[] args) {
		for (int i = 100;i <= 999 ;i++ ) {					//获取100到999之间的数
			int ge = i % 10;								//123 % 10 
			int shi = i / 10 % 10;							//12 % 10;
			int bai = i / 10 / 10 % 10;						//1 % 10

			if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
				System.out.println(i);
			}
		}
	}

(循环结构for语句的练习之统计思想)

A:案例演示
- 需求：统计”水仙花数”共有多少个

(循环结构while语句的格式和基本使用)

A:循环结构while语句的格式：

  while循环的基本格式：
  while(判断条件语句) {
  	循环体语句;
  }
  
  完整格式：
  	  初始化语句;
      while(判断条件语句) {
  		 循环体语句;
  		 控制条件语句;
  }

B:执行流程：
- a:执行初始化语句
- b:执行判断条件语句,看其返回值是true还是false
  - 如果是true，就继续执行
  - 如果是false，就结束循环
- c:执行循环体语句;
- d:执行控制条件语句
- e:回到b继续。
C:案例演示
- 需求：请在控制台输出数据1-10

(循环结构while语句的练习)

A:求和思想
- 求1-100之和
B:统计思想
- 统计”水仙花数”共有多少个

(循环结构do…while语句的格式和基本使用)

A:循环结构do…while语句的格式：

  do {
  	循环体语句;
  }while(判断条件语句);
  
  完整格式；
  初始化语句;
  do {
  	循环体语句;
  	控制条件语句;
  }while(判断条件语句);

B:执行流程：
- a:执行初始化语句
- b:执行循环体语句;
- c:执行控制条件语句
- d:执行判断条件语句,看其返回值是true还是false
  - 如果是true，就继续执行
  - 如果是false，就结束循环
- e:回到b继续。
C:案例演示
- 需求：请在控制台输出数据1-10

(循环结构三种循环语句的区别)

三种循环语句的区别:
- do…while循环至少执行一次循环体。
- 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
for循环和while循环的区别：
- A:如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用谁就用for循环。因为变量及早的从内存中消失，可以提高内存的使用效率。

(循环结构注意事项之死循环)

A:一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
B:两种最简单的死循环格式
- while(true){…}
- for(; ; ){…}

(循环结构循环嵌套输出4行5列的星星)

A:案例演示

需求：请输出一个4行5列的星星(*)图案。

  如图：
  	*****
  	*****
  	*****
  	*****
  	
  注意：
  	System.out.println("*");和System.out.print("*");的区别

B:结论：
- 外循环控制行数，内循环控制列数

(循环结构循环嵌套输出正三角形)

A:案例演示

  需求：请输出下列的形状
  *
  **
  ***
  ****
  *****

(循环结构九九乘法表)

A:案例演示
- 需求：在控制台输出九九乘法表。
B:代码优化

  注意：
  '\x' x表示任意，\是转义符号,这种做法叫转移字符。
  
  '\t'	tab键的位置
  '\r'	回车
  '\n'	换行
  '\"'
  '\''

(控制跳转语句break语句)

A:break的使用场景
- 只能在switch和循环中

(控制跳转语句continue语句)

A:continue的使用场景
- 只能在循环中，终止本次循环继续下次循环

(控制跳转语句标号)

标号:标记某个循环对其控制
标号组成规则:其实就是合法的标识符

class Demo3_Mark {										//mark 标记
	public static void main(String[] args) {
		/*outer: for (int i = 1;i <= 10 ;i++ ) {		//outer就是标号,只要是合法的标识符即可
			System.out.println("i = " + i);
			inner: for (int j = 1;j <= 10 ;j++ ) {
				System.out.println("j = " + j);
				break outer;
			}
		}*/

		System.out.println("大家好");
		http://www.heima.com               //http相当于标号
		System.out.println("才是真的好");
	}
}

(控制调整语句练习)

A:练习题

  for(int x=1; x<=10; x++) {
  	if(x%3==0) {
  		//在此处填写代码
  	}
  	System.out.println(“Java基础班”);
  }
  
  我想在控制台输出2次:“Java基础班“
  我想在控制台输出7次:“Java基础班“
  我想在控制台输出13次:“Java基础班“

/*
		for(int x=1; x<=10; x++) {
			if(x%3==0) {
				//在此处填写代码
			}
			System.out.println(“Java基础班”);
		}
		
		我想在控制台输出2次:“Java基础班“
		我想在控制台输出7次:“Java基础班“
		我想在控制台输出13次:“Java基础班“	
*/
class Test1 {
	public static void main(String[] args) {
		for(int x=1; x<=10; x++) {
			if(x%3==0) {
				//break;						//我想在控制台输出2次:“Java基础班“
				//continue;						//我想在控制台输出7次:“Java基础班“
				System.out.println("Java基础班");//我想在控制台输出13次:“Java基础班“	
			}
			System.out.println("Java基础班");
		}
	}
}

(控制跳转语句return语句)

A:return的作用
- 返回
- 其实它的作用不是结束循环的，而是结束方法的。
B:案例演示
- return和break以及continue的区别?
  - return是结束方法
  - break是跳出循环
  - continue是终止本次循环继续下次循环

(方法概述和格式说明)

A:为什么要有方法
- 提高代码的复用性
B:什么是方法
- 完成特定功能的代码块。
C:方法的格式

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

D:方法的格式说明
- 修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。
- 返回值类型：就是功能结果的数据类型。
- 方法名：符合命名规则即可。方便我们的调用。
- 参数：
  - 实际参数：就是实际参与运算的。
  - 形式参数；就是方法定义上的，用于接收实际参数的。
- 参数类型：就是参数的数据类型
- 参数名：就是变量名
- 方法体语句：就是完成功能的代码。
- return：结束方法的。
- 返回值：就是功能的结果，由return带给调用者。

(方法之求和案例及其调用)

A:如何写一个方法
- 1,明确返回值类型
- 2,明确参数列表
B:案例演示
- 需求：求两个数据之和的案例
C:方法调用图解

(方法的注意事项)

A:方法调用(有具体返回值)
- a:单独调用,一般来说没有意义，所以不推荐。
- b:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。
- c:赋值调用,推荐方案。
B:案例演示
- a:方法不调用不执行
- b:方法与方法是平级关系，不能嵌套定义
- c:方法定义的时候参数之间用逗号隔开
- d:方法调用的时候不用在传递数据类型
- e:如果方法有明确的返回值，一定要有return带回一个值

(方法的练习)

A:案例演示
- 需求：键盘录入两个数据，返回两个数中的较大值
B:案例演示
- 需求：键盘录入两个数据，比较两个数是否相等

(方法之输出星形及其调用)

A:案例演示
- 需求：根据键盘录入的行数和列数，在控制台输出星形
B:方法调用：(无返回值,void)
- 单独调用
- 输出调用(错误)
- 赋值调用(错误)

(方法的练习)

A:案例演示
- 需求：根据键盘录入的数据输出对应的乘法表

(方法重载概述和基本使用)

A:方法重载概述
- 求和案例
  - 2个整数
  - 3个整数
  - 4个整数
B:方法重载：
- 在同一个类中，方法名相同，参数列表不同。与返回值类型无关。
- 参数列表不同：
  - A:参数个数不同
  - B:参数类型不同
  - C:参数的顺序不同(算重载,但是在开发中不用)

(方法重载练习比较数据是否相等)

A:案例演示
- 需求：比较两个数据是否相等。
- 参数类型分别为两个int类型，两个double类型，并在main方法中进行测试

(数组概述和定义格式说明)(了解)

A:为什么要有数组(容器)
- 为了存储同种数据类型的多个值
B:数组概念
- 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
- 数组既可以存储基本数据类型，也可以存储引用数据类型。
C:数组定义格式
数据类型[] 数组名 = new 数据类型[数组的长度];

		左边:
		int:数据类型
		[]:代表的数组,几个中括号就代表几维数组
		arr:合法的标识符

		右边:
		new:创建新的实体或对象
		int:数据类型
		[]:代表的数组
		5:代表数组的长度

(数组的初始化动态初始化)(掌握)

A:什么是数组的初始化
- 就是为数组开辟连续的内存空间，并为每个数组元素赋予值
B:如何对数组进行初始化
- a:动态初始化只指定长度，由系统给出初始化值
  - int[] arr = new int[5];
- b:静态初始化给出初始化值，由系统决定长度
C:动态初始化的格式：
- 数据类型[] 数组名 = new 数据类型[数组长度];
D:案例演示
- 输出数组名称和数组元素

    整数类型:byte,short,int,long默认初始化值都是0
	浮点类型:float,double默认初始化值都是0.0
	布尔类型:boolean默认初始化值false
	字符类型:char默认初始化值'\u0000'
	char在内存中占的两个字节,是16个二进制位
	\u0000,每一个0其实代表的是16进制的0,那么四个0就是代表16个二进制位

	System.out.println(arr);			//[I@19bb25a
	[I@19bb25a
	[代表是数组,几个就代表几维
	I代表是int类型
	@是固定的
	19bb25a代表的是数组的地址值

(Java中的内存分配以及栈和堆的区别)

A:栈(掌握)
- 存储局部变量 :定义在方法声明上和方法中的变量
B:堆(掌握)
- 存储new出来的数组或对象
C:方法区
- 面向对象部分讲解
D:本地方法区
- 和系统相关
E:寄存器
- 给CPU使用

(数组的内存图解1一个数组)(掌握)

A:画图演示
- 一个数组

(数组的初始化静态初始化及内存图)(掌握)

A:静态初始化的格式：
- 格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
- 简化格式：
  - 数据类型[] 数组名 = {元素1,元素2,…};

(数组操作的两个常见小问题越界和空指针)(掌握)

A:案例演示
- a:ArrayIndexOutOfBoundsException:数组索引越界异常
  - 原因：你访问了不存在的索引。
- b:NullPointerException:空指针异常
  - 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

	    int[] arr = {1,2,3};
		arr = null;
		System.out.println(arr[0]);

(数组的操作1遍历)(掌握)

A:案例演示
- 数组遍历：就是依次输出数组中的每一个元素。
- 数组的属性:arr.length数组的长度
- 数组的最大索引:arr.length - 1;
```
  public static void print(int[] arr) {
  	for (int i = 0;i < arr.length ;i++ ) {
  		System.out.print(arr[i] + " ");
  	}
  }
```

(数组的操作2获取最值)(掌握)

A:案例演示

数组获取最值(获取数组中的最大值最小值)

  public static int getMax(int[] arr) {
  	int max = arr[0];
  	for (int i = 1;i < arr.length ;i++ ) {			//从数组的第二个元素开始遍历
  		if (max < arr[i]) {							//如果max记录的值小于的数组中的元素
  			max = arr[i];							//max记录住较大的
  		}
  	}

  	return max;
  }

(数组的操作3反转)(掌握)

A:案例演示

数组元素反转(就是把元素对调)

  public static void reverseArray(int[] arr) {
  	for (int i = 0;i < arr.length / 2 ; i++) {
  		//arr[0]和arr[arr.length-1-0]交换
  		//arr[1]和arr[arr.length-1-1]交换
  		//arr[2]和arr[arr.lentth-1-2]
  		//...

  		int temp = arr[i];
  		arr[i] = arr[arr.length-1-i];
  		arr[arr.length-1-i] = temp;
  	}
  }

(数组的操作4查表法)(掌握)

A:案例演示

数组查表法(根据键盘录入索引,查找对应星期)

  public static char getWeek(int week) {
  	char[] arr = {' ','一','二','三','四','五','六','日'};		//定义了一张星期表
  	return arr[week];											//通过索引获取表中的元素
  }

(数组的操作5基本查找)(掌握)

A:案例演示

数组元素查找(查找指定元素第一次在数组中出现的索引)

  public static int getIndex(int[] arr,int value) {
  	for (int i = 0;i < arr.length ;i++ ) {				//数组的遍历
  		if (arr[i] == value) {							//如果数组中的元素与查找的元素匹配
  			return i;
  		}
  	}
  	return -1;
  }

(二维数组概述和格式1的讲解)(了解)

A:二维数组概述
B:二维数组格式1
- int[][] arr = new int[3][2];
C:二维数组格式1的解释
D:注意事项
- a:以下格式也可以表示二维数组
  - 1:数据类型数组名[][] = new 数据类型[m][n];
  - 2:数据类型[] 数组名[] = new 数据类型[m][n];
- B:注意下面定义的区别
- ```
  int x;
  int y;
  int x,y;
  
  int[] x;
  int[] y[];
  
  int[] x,y[];	x是一维数组,y是二维数组
```
E:案例演示
- 定义二维数组，输出二维数组名称，一维数组名称，一个元素

class Demo1_Array {
	public static void main(String[] args) {
		int[][] arr = new int[3][2];
		/*
		这是一个二维数组
		这个二维数组中有3个一维数组
		每个一维数组中有2个元素

		[[I@19bb25a									//二维数组的地址值
		[I@da6bf4									//一维数组的地址值
		0											//元素值
		*/
		System.out.println(arr);					//二维数组
		System.out.println(arr[0]);					//二维数组中的第一个一维数组
		System.out.println(arr[0][0]);				//二维数组中的第一个一维数组的第一个元素
	}
}

(二维数组格式1的内存图解)(了解)

A:画图演示
- 画图讲解上面的二维数组名称，一维数组名称，一个元素的值的问题

(二维数组练习1遍历)(掌握)

A:案例演示

需求：二维数组遍历
外循环控制的是二维数组的长度，其实就是一维数组的个数。

内循环控制的是一维数组的长度。

  int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

  for (int i = 0;i < arr.length ;i++ ) {			//获取到每个二维数组中的一维数组
  	for (int j = 0;j < arr[i].length ;j++ ) {	//获取每个一维数组中的元素
  		System.out.print(arr[i][j] + " ");
  	}

  	System.out.println();
  }

(二维数组练习2求和)(掌握)

A:案例演示

  需求：公司年销售额求和
  某公司按照季度和月份统计的数据如下：单位(万元)
  第一季度：22,66,44
  第二季度：77,33,88
  第三季度：25,45,65
  第四季度：11,66,99
  
  int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

  int sum = 0;									//定义变量,记录每次相加的结果
  for (int i = 0;i < arr.length ;i++ ) {			//获取每一个一维数组
  	for (int j = 0;j < arr[i].length ;j++ ) {	//获取每一个一维数组中的元素
  		sum = sum + arr[i][j];					//累加
  	}
  }

  System.out.println(sum);

(思考题Java中的参数传递问题及图解)(掌握)

A:案例演示

  看程序写结果，并画内存图解释
  
  public static void main(String[] args) {
  	int a = 10;
  	int b = 20;
  	System.out.println("a:"+a+",b:"+b);
  	change(a,b);
  	System.out.println("a:"+a+",b:"+b);

  	int[] arr = {1,2,3,4,5};
  	change(arr);
  	System.out.println(arr[1]);
  }

  public static void change(int a,int b) {
  	System.out.println("a:"+a+",b:"+b);
  	a = b;
  	b = a + b;
  	System.out.println("a:"+a+",b:"+b);
  }

  public static void change(int[] arr) {
  	for(int x=0; x<arr.length; x++) {
  		if(arr[x]%2==0) {
  			arr[x]*=2;
  		}
  	}
  }

基本数据类型的值传递,不改变原值,因为调用后就会弹栈,局部变量随之消失
引用数据类型的值传递,改变原值,因为即使方法弹栈,但是堆内存数组对象还在,可以通过地址继续访问

Java中到底是传值还是传址
1,既是传值,也是传地址,基本数据类型传递的值,引用数据类型传递的地址
2,java中只有传值,因为地址值也是值(出去面试都说这种,支持者是高司令(java之父))

在这里插入图片描述