zoukankan html css js c++ java

Java基础笔记01-02-03-04

一、今日内容介绍

1、Java开发环境搭建
2、HelloWorld案例
3、注释、关键字、标识符
4、数据（数据类型、常量）

01java语言概述

* A: java语言概述
	* a: Java是sun公司开发的一门编程语言,目前被Oracle公司收购，编程语言就是用来编写软件的。
	* b: Java的应用
		* 开发QQ、迅雷程序(桌面应用软件)
		* 淘宝、京东(互联网应用软件)
	* c: Java的擅长
		* 互联网：电商、P2P等等
		* 企业级应用：ERP、CRM、BOS、OA等等
	* d: Java语言平台
		* JavaSE（标准版）部分,基础班学习JavaSE,JavaSE并不能开发大型项目。
		* JavaEE（企业版）部分,就业班学习JavaEE,学习完JavaEE部分就可以开发各种大型项目了。

02常用的DOS命令

* A: 常用的DOS命令
	* a: 打开Dos控制台
		* win+r--cmd--回车			
	* b: 常用dos命令
		* cd.. : 退回到上一级目录
		* cd  : 退回到根目录
		* cd tools: 进入tools文件夹
		* d:   : 回车	盘符切换
		* cd d:234 :进入d盘的234文件夹,再切换盘符(d:)才能进入d:234
		* dir  : 列出当前目录下的文件以及文件夹
		* cls  : 清除屏幕
		* ipconfig: 查看本机的相关网络配置
	* c: dos控制台运行记事本程序
		* D:>C:windows
otepad.exe
		* 还可以省略“.exe”后缀，例如：D:>C:windows
otepad

03java语言开发环境JDK

* A: java语言开发环境JDK
	* a: JDK是Java开发环境
	* b: 课程中使用的JDK版本是JDK7，当前最新版本是JDK8

04JDK的下载和安装

* A: JDK的下载
	* a: 官网 http://www.oracle.com/cn/index.html
	* b: 演示下载流程
* B: JDK的安装
	* a: 傻瓜式安装
		* 双击安装程序，然后一路next即可(但是不建议)
	* b: 安装的推荐方式
		* 安装路径不要有中文或者特殊符号如空格等。
		* 所有和开发相关的软件最好安装目录统一。
			* 举例：我的JDK安装路径
				* D:developJavajdk1.7.0_72
		* 当提示安装JRE时，可以选择不安装。建议还是安装上。
				* D:developJavajre
		* 安装路径中没有的文件夹,会自动创建
		

* C: 验证安装是否成功
	* a:通过DOS命令，切换到JDK安装的bin目录下。
		* D:developJavajdk1.7.0_72in
	* b:然后分别输入javac和java，如果正常显示一些内容，说明安装成功

05JDK和JRE跨平台

* A: JDK与JRE的关系
	* a: JDK：它是Java开发运行环境，在程序员的电脑上当然要安装JDK；
	* b: JRE：Java Runtime Environment它是Java运行环境，如果你不需要开发只需要运行Java程序，那么你可以安装JRE。例如程序员开发出的程序最终卖给了用户，用户不用开发，只需要运行程序，所以用户在电脑上安装JRE即可。
	* c: JDK包含了JRE。
* B: 跨平台特性
	* a: 平台指的是操作系统 （Windows，Linux，Mac）。
	* b: Java程序可以在任意操作系统上运行，一次编写到处运行
	* c: 实现跨平台需要依赖Java的虚拟机 JVM （Java Virtual Machine）

06编写HelloWorld程序

* A: 编写步骤(初学者)
	* a: 创建一个普通文本文件，将其修改为.java文件。
	* b: 完成模板代码：
		public class HelloWorld{
			public static void main(String[] args) {
					System.out.println("Hello World!");
			}
		}
* B: 实际开发步骤
	* a: 定义类
	* b: 写main方法
	* c: 写输出语句(注意：下面的代码是原代码，是不能运行的)	
		public class HelloWorld {
			public static void main(String[] args) {
				System.out.println("HelloWorld");
			}
		} 
	* d：注意：
		* 不要隐藏文件的扩展名
		* 类名和文件名要保持一致
* C: Java代码的编写执行过程
	* a: 源文件：编写Java源文件（我们也称之为源代码文件），它的扩展名为.java；
	* b: 编译：然后通过编译器把源文件编译成字节码文件，字节码文件扩展名为.class；
	* c: 运行：最后使用解释器来运行字节码文件。

07编译Java程序

* A：程序编译
	* 作用：将程序员写的java源代码生成可以运行的Java程序(.class文件)
	* 过程：
		* a:开启DOS窗口并切换到.java文件所在的目录 比如HelloWord.java存放于d:234day01code 中
		* b:切换到HelloWorld.java所在目录,但是此目录中没有javac命令,所以在编译时要写出javac命令的全路径
		* c: d:234day01code>d:developjavajdk1.7.0_72injavac HelloWorld.java 回车
		* d:在d:234day01code文件夹中多了个HelloWorld.class文件(又叫做字节码文件)

08运行Java程序

* A：运行程序
	* a: 开启DOS窗口并切换到.class文件所在的目录
	* b: 此目录中没有java命令,所以在运行时也要写出java命令的全路径
	* c: d:234day01code>d:developjavajdk1.7.0_72injava HelloWorld 回车(注意:运行时不用后缀名.class)
	* d: 控制台打印显示结果"HelloWorld"

09环境变量的配置

* A: Path环境变量配置方式一
	* a: 安装高级文本编辑器notepad++
	* b: 配置Windows的path环境变量
		* 环境变量的作用：让Java的bin目录下的javac命令可以在任意目录下执行
		* 配置方法：
			* 右键点击计算机  →  选择属性  →  更改设置  →  点击高级  →  点击环境变量  →  找到系统变量中的path  →  将java安装目录下javac所在的bin目录路径配置到path变量中，用；(英文)与其他变量分隔
		* 注意：
			* 配置path后文件的访问顺序：先访问当前路径，如果当前路径没有该文件，则再访问path配置的路径
* B:配置过程(建议使用这种方式配置)
	* a：右键点击计算机  →  选择属性  →  更改设置  →  点击高级  →  点击环境变量  →  创建名为JAVA_HOME的环境变量  →  将jdk所在的目录路径(bin所在的路径)配置到JAVA_HOME变量中
	* b: 用;与其他变量分隔  →  在path环境变量中添加%JAVA_HOME%in

10notepad软件安装

* A: 安装
	* 双击.exe文件安装 即可

11注释

* A: 注释
	* a: 定义：用来解释和说明程序的文字，注释是不会被执行的
	* b: 分类：
		* 1：单行注释    //注释内容
		* 2：多行注释    /*注释内容*/
		* 3：文档注释	/**注释内容*/
	* c: 注意：
		* 1：对于单行和多行注释，被注释的文字，不会被JVM解释执行
		* 2：对于文档注释，可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档
		* 3：单行注释可以嵌套使用，多行注释不能嵌套使用
	* d: 案例代码
		/*
			 实现了一个Java的HelloWorld程序
			 实现步骤：
			   1. 定义类
			   2. 定义主方法
			   3. 一条命令，控制台输出了HelloWorld
		*/
		public class HelloWorld{
			//main主方法，固定格式，程序的入口点
			public static void main(String[] args){
				//系统 输出 打印    打印的内容
				System.out.println("HelloWorld");
			}
		}

12关键字

* A: 关键字
	* a: 定义
		* 是被Java语言赋予特殊含义，具有专门用途的单词，比如之前接触的class，int，double均为Java已经预设好的
	* b: 特点
		* 组成关键字的字母全部小写(代码中的蓝色部分) ,注意String不是关键字
	* c: 常见关键字
		* public static void class等
	* d: 注意事项
		* goto与const是Java中的保留字，即没有赋予特殊含义却仍被Java占用的单词,类似Editplus这样的高级记事本,针对关键字有特殊的颜色标记，非常直观

13标识符

* A: 标识符
	* a: 定义
		* 就是给类,接口,方法,变量等起名字时使用的字符序列
	* b: 组成规则(只能包含下面的内容,不能有其它内容)
		* 1: 英文大小写字母
		* 2：数字字符
		* 3：$和_
	* c: 注意事项
		* 1：数字不能开头
		* 2：不可以使用关键字
		* 3：严格区分大小写，不限制长度
		* 4：起名时，尽量达到见名知意
* B：标识符中常见的命名规则(这些规定是不受语法约束的)
	* a: 包名：多单词组成时所有字母均小写，使用.连接  aaa.bbb.ccc

 * b: 类名&接口名：大驼峰式 AaaBbbCcc
 * c: 变量名&方法名：小驼峰式 aaaBbbCcc
 * d: 常量名：多单词组成是所有字母均大写，使用_连接AAA_BBB_CCC
* C: 案例代码
/*
标识符
Java中，自己定义的内容
自定义类的名字，上一个案例 HelloWorld
标识符的规则：
组成：字母52个A-Z a-z 数字0-9 _ 下划线 $ 美元符

		 注意： 不能数字开头，不能是关键字
		 
		 定义名字：
			_abc  0a  a0  a#a  a$a   void
			 YES  NO  YES NO   YES   NO
			 
		 类的名字： 首字母大写，第二个单词首字母大写
		  BeiJingShiHaiDianQuYiYuan
		  MeiGuoJiaLiFuNiYa
		 
		 方法的名字：首字母小写，每个单词首字母大写
		   addStudent  
	*/
	public class Demo{
		
	}

14Java中的数据类型

* A:为什么有数据类型
	* Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型
* B:Java中数据类型的分类
	* 基本数据类型: 基本数据类型是Java语言中内置的类型，分别是整数类型、小数类型、字符类型、布尔类型。
		这四类基本类型是最简单、最基础的类型。
		* 整数(byte、short、int、long)、小数(float、double)、字符类型(char)、布尔类型(boolean)
	* 引用数据类型: 是强大的数据类型，它是基于基本数据类型创建的。JavaSE中提供了一个超级类库，类库中包含了近万种引用数据类型。
		不过现在我们先要学习的是基本类型！
		* 数组、类、接口

15Java中的常量

* A: 常量的定义
	* 常量就是不变的数据量, 在程序执行的过程中其值不可以发生改变
* B: 常量分类
	* a: 整数类型
		* 十进制表示方式：正常数字   如 13、25等
		* 二进制表示方式：以0b(0B)开头    如0b1011 、0B1001 
		* 十六进制表示方式：以0x(0X)开头   数字以0-9及A-F组成  如0x23A2、0xa、0x10 
		* 八进制表示方式：以0开头   如01、07、0721
	* b: 小数类型
		* 如1.0、-3.15、3.168等
	* c: 布尔类型
		* true、false
	* d: 字符类型
		* 如'a'，'A', '0', '家'
		* 字符必须使用’’ 包裹，并且其中只能且仅能包含一个字符。
	* e: 字符串类型
		* 字符串String类型是一种引用类型，我们先了解作为常量类型的使用方式
		* 如“我爱Java”，“0123”，“”，“null”
		* 字符串必须使用“”包裹，其中可以包含0~N个字符。

16程序中输出Java中的常量

* A: 案例代码
	/*
	   Demo_1类，演示Java中的所有类型的常量
	   程序当中输出：
		 输出整数常量
		 小数常量
		 布尔常量
		 字符常量
		 字符串常量
	*/
	public class Demo_1{
		public static void main(String[] args){
			//输出整数 十进制
			System.out.println(50);
			

			//输出整数，二进制, 数字开头0B
			System.out.println(0B11);
			
			//输出整数，八进制，数字开头0
			System.out.println(051);
			
			//输出整数，十六进制，数组开头0X  0-9 A-F
			System.out.println(0XE);
			
			//输出浮点数据
			System.out.println(5.0);
			
			//输出布尔数据，只有2个值，true，false 关键字
			System.out.println(true);
			System.out.println(false);
			
			//输出字符常量，单引号包裹，只能写1个字符
			System.out.println('a');
			
			//输出字符串常量，双引号包裹，可以写0-n个字符
			System.out.println("HelloWorld");
		}
	}

17总结

把今天的知识点总结一遍。

二、今日内容介绍

1、流程控制语句switch
2、数组
3、随机点名器案例

01switch语句解构

* A:switch语句解构

a:switch只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。
- b:格式如下:
  swtich(表达式){
  case 常量1 :
  要执行的语句;
  break;
```
    case 常量2 :
      要执行的语句;
    break;
    
    case 常量3 :
      要执行的语句;
    break;
    
    default:
      要执行的语句;
    break;
}
```
- c: 执行流程: 表达式,和case后面的常量进行比较和哪个case后的常量相同,就执行哪个case后面的程序,遇到break,就全结束
- d: 关键字: switch case default break
- e:举例
  
  如果等于1，则输出星期一
  如果等于2，则输出星期二
  如果等于3，则输出星期三
  如果等于4，则输出星期四
  如果等于5，则输出星期五
  如果等于6，则输出星期六
  如果等于7，则输出星期天

02switch语句的星期判断

* A: switch语句的星期判断
	* a: 明确需求
		需求:初始化int类型变量(1-7)代表星期几,使用switch语句进行判断,并打印出该整数对应的星期.
							

	* b: 代码实现
		 public class SwitchDemo01 {
			public static void main(String[] args) {
				int week = 5;
				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;
				}
			}
		}

03switch语句接受的数据类型

* A: switch语句接受的数据类型
* a:注意事项
switch语句中的表达式的数据类型,是有要求的
JDK1.0 - 1.4 数据类型接受 byte short int char
JDK1.5 数据类型接受 byte short int char enum(枚举)
JDK1.7 数据类型接受 byte short int char enum(枚举), String

04case穿透

* A:case穿透
	* a: 在使用switch语句的过程中，如果多个case条件后面的执行语句是一样的，则该执行语句只需书写一次即可，这是一种简写的方式。
	* b: 例如，要判断一周中的某一天是否为工作日，同样使用数字1~7来表示星期一到星期天，当输入的数字为1、2、3、4、5时就视为工作日，否则就视为休息日。

05数组的概述

* A: 数组的概述
	* a:数组的需求
		现在需要统计某公司员工的工资情况，例如计算平均工资、最高工资等。假设该公司有50名员工，用前面所学的知识完成，
		那么程序首先需要声明50个变量来分别记住每位员工的工资，这样做会显得很麻烦.

 	* b:数组的概述
 		数组是指一组数据的集合，数组中的每个数据被称作元素。在数组中可以存放任意类型的元素，但同一个数组里存放的元素类型必须一致。

06数组的定义

* A：数组的定义
* b:格式:
		 数据类型[] 数组名 = new 数据类型[元素个数或数组长度];

	* c:举例:
		int[] x = new int[100];
* c:要点说明
  	1)数据类型: 数组中存储元素的数据类型
	2) [] 表示数组的意思
	3) 变量名  自定义标识符  
	4) new  创建容器关键字
	5)数据类型: 数组中存储元素的数据类型
	6)[]  表示数组的意思
	7)元素个数,就是数组中,可以存储多少个数据 (恒定, 定长)
	  
	数组是一个容器: 存储到数组中的每个元素,都有自己的自动编号
	自动编号,最小值是0, 最大值,长度-1
	自动编号专业名次, 索引(index), 下标, 角标
	访问数组存储的元素,必须依赖于索引, 公式 数组名[索引]
	
	Java提供一个属性,操作索引的
	数组的一个属性,就是数组的长度, 属性的名字 length
	使用属性:  数组名.length  数据类型 int
	
	数组的最小索引是0, 最大索引数组.length-1

07JVM内存划分

* A：内存划分
* JVM对自己的内存划分为5个区域
  	* a: 寄存器:内存和CUP之间
  	* b: 本地方法栈: JVM调用了系统中的功能
  	* c: 方法和数据共享: 运行时期class文件进入的地方
  	* d: 方法栈:所有的方法运行的时候进入内存
  	* e: 堆:存储的是容器和对象

08数组的内存

* A: 数组的内存
* int[] x;	            	// 声明一个int[]类型的变量
*	x = new int[100];		// 创建一个长度为100的数组
*	接下来，通过两张内存图来详细地说明数组在创建过程中内存的分配情况。
*	第一行代码 int[] x; 声明了一个变量x，该变量的类型为int[]，即一个int类型的数组。变量x会占用一块内存单元，它没有被分配初始值
*	第二行代码 x = new int[100]; 创建了一个数组，将数组的地址赋值给变量x。在程序运行期间可以使用变量x来引用数组，这时内存中的状态会发生变化

09使用索引访问数组的元素

* A: 使用索引访问数组的元素
* 组中有100个元素，初始值都为0。数组中的每个元素都有一个索引(也可称为角标)，要想访问数组中的元素可以通过“x[0]、x[1]、……、x[98]、x[99]”的形式。
* 需要注意的是，数组中最小的索引是0，最大的索引是“数组的长度-1”

10数组的length属性

* A: lenth属性
	* a 在Java中，为了方便我们获得数组的长度，提供了一个length属性，在程序中可以通过“数组名.length”的方式来获得数组的长度，即元素的个数。
	* b 求数组的长度
		public class ArrayDemo01 {
	 		public static void main(String[] args) {
	 			int[] arr; // 声明变量
	 			arr = new int[3]; // 创建数组对象
	 			System.out.println("arr[0]=" + arr[0]); // 访问数组中的第一个元素
	 			System.out.println("arr[1]=" + arr[1]); // 访问数组中的第二个元素
	 			System.out.println("arr[2]=" + arr[2]); // 访问数组中的第三个元素
	 			System.out.println("数组的长度是：" + arr.length); // 打印数组长度
	 		}
		}

11为数组的元素赋值

* A: 为数组的元素赋值
	* a: 如果在使用数组时，不想使用这些默认初始值，也可以显式地为这些元素赋值。
	* 	赋值过的元素已经变为新的数值,没有赋值的元素默认初始化的数值
	* b: 案例
	 	public class ArrayDemo02 {
	 		public static void main(String[] args) {
	 			int[] arr = new int[4]; // 定义可以存储4个整数的数组
	 			arr[0] = 1; // 为第1个元素赋值1
	 			arr[1] = 2; // 为第2个元素赋值2
	 			// 下面的代码是打印数组中每个元素的值
	 			System.out.println("arr[0]=" + arr[0]);
	 			System.out.println("arr[1]=" + arr[1]);
	 			System.out.println("arr[2]=" + arr[2]);
				System.out.println("arr[3]=" + arr[3]);
	 		}
		}

12数组的定义_2

* A: 定义数组格式2
	* a: 数组初始化
		动态初始化 : 在定义数组时只指定数组的长度，由系统自动为元素赋初值的方式称作动态初始化。
		1、类型[] 数组名 = new 类型[长度];
		int[] arr = new int[4];
		静态初始化: 在初始化数组时还有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。
		2、类型[] 数组名 = new 类型[]{元素，元素，……};
		int[] arr = new int[]{1,2,3,4};
		3、类型[] 数组名 = {元素，元素，元素，……};	 
		int[] arr = { 1, 2, 3, 4 };

13遍历数组

* A:遍历数组
	* 在操作数组时，经常需要依次访问数组中的每个元素，这种操作称作数组的遍历
* B:练习
	public class ArrayDemo04 {
		public static void main(String[] args) {
			int[] arr = { 1, 2, 3, 4, 5 }; // 定义数组
			// 使用for循环遍历数组的元素
			for (int i = 0; i < arr.length; i++) {
				System.out.println(arr[i]); // 通过索引访问元素
			}
		}
	}
	上述代码中，定义一个长度为5的数组arr，数组的角标为0~4。由于for循环中定义的变量i的值在循环过程中为0~4，因此可以作为索引，依次去访问数组中的元素，并将元素的值打印出来

14数组中常见的异常

* A: 数组操作中,常见的两个异常
	 数组的索引越界异常
 	 空指针异常

* B: 练习
	public class ArrayDemo_4{
		public static void main(String[] args){
			//数组的索引越界异常
			//int[] arr = {5,2,1};
			//数组中3个元素,索引 0,1,2
			//System.out.println(arr[3]);//java.lang.ArrayIndexOutOfBoundsException: 3
			
			//空指针异常
			int[] arr2 = {1,5,8};
			System.out.println(arr2[2]);
			arr2 = null; // arr2 不在保存数组的地址了
			System.out.println(arr2[2]);//java.lang.NullPointerException
		}
	}

15数组最值

* A: 数组获取最值的原理思想
	* 定义数组的第一个元素arr[0]为最大值;循环arr数组,判断如果有比arr[0] 大的就交换,直到arr数组遍历完毕,那么arr[0]中就保存了最大的元素

16数组获取最值代码实现

* A: 代码实现
	public class ArrayDemo05 {
		public static void main(String[] args) {
			int[] arr = { 4, 1, 6, 3, 9, 8 }; 	// 定义一个数组
			int max = arr[0]; 					// 定义变量max用于记住最大数，首先假设第一个元素为最大值
			// 下面通过一个for循环遍历数组中的元素
			for (int x = 1; x < arr.length; x++) {
				if (arr[x] > max) { 			// 比较 arr[x]的值是否大于max
					max = arr[x]; 				// 条件成立，将arr[x]的值赋给max
				}
			}
			System.out.println("max=" + max); 	// 打印最大值
		}
	}

17二维数组的定义

* A 二维数组的作用
	* 要统计一个学校各个班级学生的考试成绩，又该如何实现呢？
	* 这时就需要用到多维数组，多维数组可以简单地理解为在数组中嵌套数组。
* B 定义格式
	* a 第一种定义格式:
		*  int[][] arr = new int[3][4];
		*  上面的代码相当于定义了一个3*4的二维数组，即二维数组的长度为3，二维数组中的每个元素又是一个长度为4的数组
	* b 第二种定义格式
		*  int[][] arr = new int[3][];
		*  第二种方式和第一种类似，只是数组中每个元素的长度不确定
	* c 第三种定义格式
		*  	int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};
		*  	二维数组中定义了三个元素，这三个元素都是数组，分别为{1,2}、{3,4,5,6}、{7,8,9}

18二维数组元素的访问

 * A: 二维数组的访问
 * 案例:
  class ArrayDemo08 {
	public static void main(String[] args){
	

		//定义二维数组的方式
		int[][] arr = new int[3][4];
		System.out.println( arr );
		System.out.println("二维数组的长度: " + arr.length);
		//获取二维数组的3个元素
		System.out.println( arr[0] );
		System.out.println( arr[1] );
		System.out.println( arr[2] );
		
		System.out.println("打印第一个一维数组的元素值");
		System.out.println( arr[0][0] );
		System.out.println( arr[0][1] );//访问的为二维数组中第1个一维数组的第2个元素
		System.out.println( arr[0][2] );
		System.out.println( arr[0][3] );
		
		System.out.println("打印第二个一维数组的元素值");
		System.out.println( arr[1][0] );
		System.out.println( arr[1][1] );
		System.out.println( arr[1][2] );
		System.out.println( arr[1][3] );
		
		System.out.println("打印第三个一维数组的元素值");
		System.out.println( arr[2][0] );
		System.out.println( arr[2][1] );
		System.out.println( arr[2][2] );
		System.out.println( arr[2][3] );
	}
}

19二维数组内存图

 * A: 二维数组内存图
 * 举例:int[][] arr = new int[3][2];
 * 外层数组长在内存开辟连续的3个大的内存空间,每一个内存空间都对应的有地址值
 * 每一个大内存空间里又开辟连续的两个小的内存空间.

20二维数组的定义和访问

 * A: 二维数组的定义和访问
	 * 格式1: 
	 * 	int[][] arr = new int[3][]; 不推荐
	 * 格式2
	 *  int[][] arr = {{1,2,4},{4,7},{0,9,3}};
	 *  
 * B: 二维数组的访问
 	 举例:int[][] arr = {{1,2,4},{5,8,7},{0,9,3}};  
	  想要打印数组中7这个元素需要先找到大的元素索引{5,7} 索引为2 ,在找7在{5,7}中的索引2
	  那么结果为 arr[2][2]  第一个[2]代表大数组中{5,8,7}这个元素索引
	  第二个[2]代表{5,8,7}中7元素的索引

22二维数组的遍历

  * A:二维数组遍历
	 int[][] arr = {{1,2,4},{4,7},{0,9,3}};
	 先使用for循环遍历arr这个二维数组,得到每一个元素为arr[i]为一维数组
	 再外层for循环中嵌套一个for循环遍历每一个一维数组arr[i],得到每一元素

  *	B:举例:遍历二维数组
	public class ArrayArrayDemo_2{
		public static void main(String[] args){
			int[][] arr = { {1,2,3},{4,5},{6,7,8,9},{0} };
			
			//外循环,遍历二维数组
			for(int i = 0 ; i < arr.length ;i++){
				//内循环,遍历每个一维数组 arr[0] arr[1] arr[i]
				for(int j = 0 ; j < arr[i].length; j++){
					System.out.print(arr[i][j]);
				}
				System.out.println();
			}
		}
	
  * C:二维数组累加求和
   class ArrayDemo09 {
		public static void main(String[] args){
		  	int[][] arr2 = { {1,2},{3,4,5},{6,7,8,9,10} };
			int sum2 = 0;
			for (int i=0; i<arr2.length; i++) {
				for (int j=0; j<arr2[i].length; j++) {
	                 //System.out.println(arr2[i][j])
					sum2 += arr2[i][j];
				}
			}
			System.out.println("sum2= "+ sum2);
		}
	}

23二维数组的求和练习

 * A 例如要统计一个公司三个销售小组中每个小组的总销售额以及整个公司的销售额。如下所示
	* 第一小组销售额为{11, 12}万元
	* 第二小组销售额为{21, 22, 23}万元
	* 第三小组销售额为{31, 32, 33, 34}万元。

  * B 代码实现
   	public class ArrayDemo10 {
 		public static void main(String[] args) {
 			int[][] arr = new int[3][]; 			// 定义一个长度为3的二维数组
			arr[0] = new int[] { 11, 12 }; 			// 为数组的元素赋值
 			arr[1] = new int[] { 21, 22, 23 };
 			arr[2] = new int[] { 31, 32, 33, 34 };		
 			int sum = 0; 							// 定义变量记录总销售额
 			for (int i = 0; i < arr.length; i++) { // 遍历数组元素
 				int groupSum = 0; // 定义变量记录小组销售总额
 			for (int j = 0; j < arr[i].length; j++) { // 遍历小组内每个人的销售额
 					groupSum = groupSum + arr[i][j];
 			}
 				sum = sum + groupSum; 			// 累加小组销售额
 				System.out.println("第" + (i + 1) + "小组销售额为：" + groupSum + " 万元");
 			}
 			System.out.println("总销售额为: " + sum + " 万元");
 		}
 	}

24随机点名器案例分析

 * A 随机点名器案例分析
  

 * B: 需求
	 * 随机点名器，即在全班同学中随机的打印出一名同学名字。
  
 * C:分析:
	 * 1)定义数组存数全班同学
	 * 2)生成随机数范围0 到 数组长度-1
	 * 3)根据这个索引找到数组中的同学名称

25随机点名器代码实现

 * A: 分析
   	 随机点名器:
     1  存储姓名
	 2. 预览所有人的姓名
	 3. 随机出一个人的姓名
 * B 代码实现
	import java.util.Random;
	public class CallName{
		public static void main(String[] args){
			//存储姓名,姓名存储到数组中
			//数组存储姓名,姓名的数据类型,String
			String[] names = {"张三","李四","王五","李蕾","韩梅梅","小名","老王","小华","约翰逊","爱丽丝"};
			

			//预览: 遍历数组,打印所有姓名
			for(int i = 0 ; i < names.length ; i++){
				System.out.println(names[i]);
			}
			System.out.println("=============");
			
			//随机出一个人的名
			//利用随机数,生成一个整数,作为索引,到数组中找到对应的元素
			Random ran = new Random();
			//随机数,范围必须是0-数组的最大索引
			int index = ran.nextInt(names.length);//index 就是随机数,作为索引
			System.out.println(names[index]);
		}
	}

25随机点名器代码实现_2

	* A 代码优化:
	import java.util.Random;
	public class CallName{
		public static void main(String[] args){
			String[] names = {"张三","李四","王五","李蕾","韩梅梅","小名","老王","小华","约翰逊","爱丽丝"};
			System.out.println(names[new Random().nextInt(names.length)]);
		}
	}

25总结

* 把今天的知识点总结一遍。

三、今日内容介绍

1、引用类型变量的创建及使用
2、流程控制语句之选择语句
3、流程控制语句之循环语句
4、循环高级

01创建引用类型变量公式

* A: 创建引用类型变量公式
	* a: 我们要学的Scanner类是属于引用数据类型，我们先了解下引用数据类型。
	* b: 引用数据类型的定义格式
		* 与定义基本数据类型变量不同，引用数据类型的变量定义及赋值有一个相对固定的步骤或格式。
		* 数据类型  变量名  =  new 数据类型();
	* c: 引用数据类型的使用
		* 每种引用数据类型都有其功能，我们可以调用该类型实例的功能。
		* 变量名.方法名();

02Scanner类的使用

* A: Scanner类的使用
	* a: 导包import java.util.Scanner;
	* b：创建键盘录入对象 Scanner sc = new Scanner(System.in);
	* c: 读取键盘录入的一个整数
		* int enterNumber = sc.nextInt();
	* d: 读取键盘录入的字符串
		* String enterString = sc.next();
* B: 案例代码
	import java.util.Scanner;
	public class Demo05Scanner{
		public static void main(String[] args) 
		{
			Scanner sc = new Scanner(System.in);

			int enterNumber = sc.nextInt();
			System.out.println("用户输入的整数为"+enterNumber);

			String enterString = sc.next();
			System.out.println("用户输入的字符串为"+enterString);
		}
	}

03Random随机数类的使用_1

* A: Random随机数类的使用_1
* a: 功能
* 生成随机数需要使用到引用类型随机数Random类
* b: 使用方式
* import导包：所属包java.util. Random
* 创建实例格式：Random random = new Random ();
* 调用方法
* nextInt(int maxValue) 产生[0,maxValue)范围的随机数,包含0不包含maxValue
* nextDouble() 产生[0,1)范围的随机数
如：
Random random = new Random ();
int myNumber = random.nextInt(100);//结果为0-99的一个数
* B: 案例代码
import java.util.Random;
public class RandomDemo{
public static void main(String[] args){
Random ran = new Random();
// Random类中的,产生随机数的功能
int i = ran.nextInt(100);
System.out.println(i);

		   //问题? 产生随机数,范围 1-100之间
		   // nextInt(100) 0-99 + 1
		}
	}

04Random随机数类的使用_2

* A: Random随机数类的使用_2
	* a: 调用方法
		* nextDouble()  产生[0,1)范围的随机数
		如：
			Random  random = new Random ();
			int  myNumber = random.nextDouble();//结果为0.0-1.0之间的数(包括0.0不包括1.0)

05if语句格式第一种

* A: if语句格式第一种
	* a: 书写格式
		if(比较表达式) {
			语句体;
		}
	* b：执行流程：
		* 先计算比较表达式的值，看其返回值是true还是false。
		* 如果是true，就执行语句体；
		* 如果是false，就不执行语句体；
* B: 案例代码
	public class IfDemo{
		public static void main(String[] args){
			  int i = 5 ;
			  //对变量i进行if判断
			  if(i > 5){
				  System.out.println("if中的条件是true");
				  i++;
			  }
			  

			  System.out.println(i);
		}
	}

06if语句格式第二种

* A: if语句格式第二种
	* a: 书写格式
		if(比较表达式) {
			语句体1;
		}else {
			语句体2;
		}
	* b：执行流程：
		* 首先计算比较表达式的值，看其返回值是true还是false。
		* 如果是true，就执行语句体1；
		* 如果是false，就执行语句体2；
* B: 案例代码
	public class IfElseDemo{
		public static void main(String[] args){
		     int i = 16 ;
			 //判断变量,是奇偶数, 除以2,看余数是0还是1
			 if( i % 2 == 0 ){
				 System.out.println(i+" 是偶数");
			 }else{
				 System.out.println(i+" 是奇数");
			 }
	    }
	}

07if语句格式第三种

* A: if语句格式第三种
	* a: 书写格式
			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。
* B: 案例代码
	public class IfElseIfDemo{
		public static void main(String[] args){
			//成绩判断要求 ,成绩>80  成绩>70  成绩>60  不及格
			//定义变量,保存成绩
			int grade = 75;
			//使用if else if 语句对成绩判断
			if( grade > 80 ){
				System.out.println(grade+" 成绩是优");
			}else if ( grade > 70){
				System.out.println(grade+" 成绩是良");
			}else if ( grade > 60){
				System.out.println(grade+" 成绩是中");
			}else{
				System.out.println(grade+" 成绩是差");
			}
		 	
		}
	}

08if语句和三元运算符的互换

* A: 三元运算符
	* a: 概念
		* 用来完成简单的选择逻辑，即根据条件判断，从两个选择中选择一种执行
	* b: 使用格式
		* (条件表达式)？表达式1：表达式2；
	* c: 运算规则
		* 1: 判断条件表达式，结果为一个布尔值
		* 2: true，运算结果为表达式1
		* 3: false，运算结果为表达式2
* B: 案例代码
	public class IfElseDemo_1{
		public static void main(String[] args){
			int j = 6;
			int i = 15;
			//使用if语句,判断出最大值
			if(i>j){
			int j = 6;
				System.out.println(i+" 是最大值");
			}else{
				System.out.println(j+" 是最大值");
			}
			

			//使用三元运算实现
			int k = i>j ? i : j;
			System.out.println(k+" 是最大值");
		}
	}
* C: 使用if语句还是三元表达式
	* 判断条件多,使用if
 	* 三元,必须有结果的, if 可以没有结果的

09while循环

* A: while循环结构
	* a: 使用格式
		初始化表达式；
		while(条件){
			循环体
		}
	* b: 执行顺序
		  当条件是true,就执行循环体,执行完循环体后
		  程序再次执行while中的条件,如果条件还是true,继续执行循环体
		  直到条件是false的时候,循环就结束
* B: 案例代码
	public class WhileDemo{
		public static void main(String[] args){
			//输出 1-4之间的整数
			//定义变量,整数类型, 循环的条件
			int i = 1;
			while( i < 5 ){
				System.out.println(i);
				i++;
			}
		}
	}

10for循环_1

* A: for循环_1
	* a: 使用格式
		 for(初始化变量 ; 条件 ; 增量){
			 循环体;
		 }
	* b: 各模块解释
		初始化变量: 定义变量,作用是用来控制循环的次数
	    条件: 当条件是true,执行循环体,条件是false,结束循环
	    增量: 变量自增情况 
* B: 案例代码
	public class ForDemo{
		public static void main(String[] args){
			//for循环,输出0-10
			for(int i = 0 ; i < 11 ; i++){
				System.out.println(i);
			}
		}
	}

11for循环_2

* A: for循环的执行流程
	for（① ; ② ; ③）{
		④
	}
	第一步，执行①
	第二步，执行②，如果判断结果为true，执行第三步，如果判断结果为false，执行第五步
	第三步，执行④
	第四步，执行③，然后重复执行第二步
	第五步，退出循环

12for循环_3

* A: 案例
	* a: 利用for循环,计算1+4的结果
* B: 案例代码
	public class ForDemo_1{
		public static void main(String[] args){
			// 定义变量,记录求和后的数据
			int sum = 0;
			// 利用循环,将变量从1变化到4
			for(int i = 1 ; i <= 4 ; i++){
				//对变量进行求和
				sum = sum + i;
			}
			System.out.println(sum);
		}
	}

13do_while循环

* A: do_while循环
	* a: 使用格式
		do{
		   循环体;
	    }while(条件);
	* b: 执行顺序
		先执行一次循环体，然后再判断条件，如果条件为true，继续执行循环体，
		如果条件为false，循环结束。
	* c: 特点
		* 无条件先执行一次
* B: 案例代码
	public class DoWhileDemo{
		public static void main(String[] args){
			int i = 0; 
			do{
				System.out.println(i);
				i++;
			}while( i <  5);
		}
	}

14死循环

* A: 死循环概述
	* 无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环
* B: 死循环格式
	* while(true){}
	* for(;;){}

15嵌套for循环_1

* A: 嵌套循环的概述
	* 嵌套循环是指在一个循环语句的循环体中再定义一个循环语句的语法结构。while、do…while、for循环语句都可以进行嵌套，并且它们之间也可以互相嵌套，如最常见的在for循环中嵌套for循环。
* B: 嵌套循环的格式
	for(初始化表达式; 循环条件; 操作表达式) {
		………
		for(初始化表达式; 循环条件; 操作表达式) {
			执行语句
			………
		}
		………
	}
* C: 各模块解释
	* 总的循环次数 =  内循环次数 * 外循环的次数
	* 内循环,是外循环的循环体
	   

	* 外循环,控制的是行数
	* 内循环,控制的是每行的个数

16嵌套for循环_2

* A: 案例
	* a: 打印正三角形
* B: 案例代码
	public class ForForDemo{
		public static void main(String[] args){
			for(int i = 0 ; i < 9 ; i++){
				for(int j = 0; j < i+1 ;j++){
					System.out.print("* ");
				}
				System.out.println();
			}
		}
	}

17break语句

* A: break语句
	* a: 作用
		* 跳出所在的循环体
	* b: 书写位置
		* 必须出现在循环或选择结构内
	* c: 举例
		for(int i=0; i<10; i++) {
			if(i>5) {
			break;
		}
			System.out.println(“我爱Java”+i);
		}
		//会从0-5输出6次“我爱Java”
* B: break详细解释
	* a: 作用
		* 在loop/switch选择或者循环过程中，我们总是满足布尔表达条件才能执行对应的代码，然而在这些逻辑过程中，
			可以使用一些关键字直接跳出正在执行的代码，去执行后边或者指定位置的代码，
			这些关键字一旦出现就可以跳转语句执行顺序。
	* b: 使用方式
		* 无法单独使用，必须将break关键字置于switch或循环语句中
	* c: 运行规律
		* 不需要判断任何条件，只要遇到break变直接跳出执行后续代码。会完全跳出选择或者循环结构
		* 只能跳出最近的代码块，不能跨越多级代码块


* C：循环标号
	* a: 为什么使用循环标号
		* 当在双层循环或者循环内有switch选择语句时，我们发现，使用break或者continue所作用的对象均是内层语句，无法直接跳出外层循环，这时就需要使用标号语句跳转了.
	* b: 使用方式
		* 在外层循环外的某行前边，使用后边跟有冒号”:”的标识符，即定义完毕。
		  使用时当在内层循环使用break或continue时后边紧跟之前定义的标号即可
	* c: 运行规律
		* 当外层循环外定义了标号
		* 内层使用break，终止内外双层循环。
		* 内层使用continue，终止内层循环，继续外层循环。

18continue语句

* A: continue语句
	* a: 作用
		* 提前结束本次循环，继续进行下次循环
	* b: 使用方式
		* 无法单独使用，必须将continue关键字置于循环语句中
	* c：运行规律
		* 不需要判断任何条件，只要遇到continue变直接跳出本轮循环进行下次循环
	* d：案例代码
		public class ContinueDemo{
			public static void main(String[] args){
				for(int i = 0 ; i < 10 ; i++){
					if(i%2==0){
						continue;
					}
					System.out.println(i);
				}
			}
		}
		//会把0-9之间所有的奇数打印到控制台上

19猜数字小游戏

* A: 猜数字小游戏		
	* a: 分析
		* 用户给的数可能大于、小于、或等于被猜的数，这样就会出现三种情况，用前面讲的三元运算符可以实现，
			但是得用三元运算符的嵌套，比较麻烦！可以用更简单的方式if条件判断，可以有三个以上的条件
	* b: 需求分析
		* 后台预先生成一个随机数1-100，用户键盘录入猜数字
		* 如果猜对了，打印“恭喜您，答对了”
		* 如果猜错了
		* 猜大了：打印“sorry，您猜大了!”
		* 猜小了：打印“sorry，您猜小了!”
				直到数字猜到为止
				最多只能猜5次，否则提示“sorry，您没有机会了!”
* B: 案例代码
	/*
		猜数字小游戏
		

		完成猜数字小游戏：
		1、产生随机数
		后台预先生成一个随机数1-100，用户键盘录入猜数字
		2、通过if语句对用户猜的数与随机数进行比较
		如果猜对了，打印“恭喜您，答对了”
		如果猜错了
		猜大了：打印“sorry，您猜大了!”
		猜小了：打印“sorry，您猜小了!”
		3、通过for循环完成用户猜数的循环
		直到数字猜到为止
		最多只能猜5次，否则提示“sorry，您没有机会了!”

	*/
	import java.util.Random;
	import java.util.Scanner;
	//通过*的方式可以一次导入该包下所有的类，但是不建议使用。建议使用哪个导哪个。
	//import java.util.*;
	public class GuessNumber{
		public static void main(String[] args) {
			//1、产生随机数
			//后台预先生成一个随机数1-100，用户键盘录入猜数字
			//创建随机数对象
			Random random = new Random();
			//产生一个1-100的随机数
			int randomNumber = random.nextInt(100)+1;
			//System.out.println("我产生的随机数是："+randomNumber+"你猜猜是多少？");  作弊专用

			//产生控制台录入的Scanner对象
			Scanner sc = new Scanner(System.in);
			//3、通过for循环完成用户猜数的循环
			//通过for循环完成猜数字逻辑
			for(int i=1; i<=5; i++){
				//提示用户输入要猜的数，用变量接收
				System.out.println();
				System.out.println("请您输入一个1-100的数：");
				int guessNumber = sc.nextInt();
				
				//2、通过if语句对用户猜的数与随机数进行比较
				//如果猜对了
				if(guessNumber==randomNumber) {
					//打印猜对后的提示
					System.out.println("恭喜您，猜对了！");
					//跳出循环，不用再猜了
					break;
				}else {//如果猜错了
					//如果猜大了
					if(guessNumber>randomNumber) {
						System.out.println("sorry，您猜大了!");
					}else {//如果猜小了
						System.out.println("sorry，您猜小了!");
					}
				}
				//如果猜到了最后的第5次仍然没有猜对就跳出循环
				if(i==5) {
					System.out.println("对不起，点太背，下次再来吧！");
					break;
				}
				//每次猜错后，都提示还有多少次机会
				System.out.println("请注意，您还有"+(5-i)+"次机会，请慎重作答！");
			}
		}
	}

四、今日内容介绍