笔记整理1----Java语言基础（一）01 变量与数据类型+02 运算符与表达式+03 条件判断与循环语句+04 JAVA数组+05 函数与方法

# 01 变量与数据类型+02 运算符与表达式+03 条件判断与循环语句+04 JAVA数组+05 函数与方法
## 第01天 java基础知识
今日内容介绍
 Java概述、helloworld案例
 工具安装、配置环境变量、注释、关键字
 常量、变量、数据类型、标识符
### 第1章 Java概述
1.1 Java语言发展史和平台概述
A:Java语言发展史
詹姆斯•高斯林（James Gosling）1977年获得了加拿大卡尔加里大学计算机科学学士学位，1983年获得了美国卡内基梅隆大学计算机科学博士学位，毕业后到IBM工作，设计IBM第一代工作站NeWS系统，但不受重视。后来转至Sun公司，1990年，与Patrick，Naughton和Mike Sheridan等人合作“绿色计划”，后来发展一套语言叫做“Oak”，后改名为Java。
SUN(Stanford University Network，斯坦福大学网络公司)
B:Java语言版本
* JDK 1.1.4 Sparkler 宝石 1997-09-12
* JDK 1.1.5 Pumpkin 南瓜 1997-12-13
* JDK 1.1.6 Abigail 阿比盖尔--女子名 1998-04-24
* JDK 1.1.7 Brutus 布鲁图--古罗马政治家和将军 1998-09-28
* JDK 1.1.8 Chelsea 切尔西--城市名 1999-04-08
* J2SE 1.2 Playground 运动场 1998-12-04
* J2SE 1.2.1 none 无 1999-03-30
* J2SE 1.2.2 Cricket 蟋蟀 1999-07-08
* J2SE 1.3 Kestrel 美洲红隼(sǔn) 2000-05-08
* J2SE 1.3.1 Ladybird 瓢虫 2001-05-17
* J2SE 1.4.0 Merlin 灰背隼 2002-02-13
* J2SE 1.4.1 grasshopper 蚱蜢 2002-09-16
* J2SE 1.4.2 Mantis 螳螂 2003-06-26
* JAVASE 5.0 (1.5.0) Tiger 老虎
* JAVASE 5.1 (1.5.1) Dragonfly 蜻蜓
* JAVASE 6.0 (1.6.0) Mustang 野马
* JAVASE 7.0 (1.7.0) Dolphin 海豚

1.2 JVM,JRE,JDK的概述

1.2.1 什么是跨平台?
平台：指的是操作系统(Windows，Linux，Mac)
跨平台：Java程序可以在任意操作系统上运行，一次编写到处运行
原理：实现跨平台需要依赖Java的虚拟机 JVM （Java Virtual Machine）

1.2.2 JVM JRE JDK说明

A:什么是JVM
JVM是java虚拟机(JVM Java Virtual Machine)，java程序需要运行在虚拟机上，不同平台有自己的虚拟机，因此java语言可以跨平台
B:什么是JRE
包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。
JRE:JVM+类库。
C:什么是JDK
JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。
其中的开发工具：编译工具(javac.exe) 打包工具(jar.exe)等
JDK:JRE+JAVA的开发工具。
D:为什么JDK中包含一个JRE
为什么JDK中包含一个JRE呢？
开发完的程序，需要运行一下看看效果。
E:JDK,JRE,JVM的作用和关系
JDK包含JRE 和开发工具包
JRE 包含核心类库和JVM

1.3 常用dos命令
1.3.1 打开控制台
– win + R，然后cmd回车
1.3.2 常用命令
– d: 回车盘符切换
– dir(directory):列出当前目录下的文件以及文件夹
– cd (change directory)改变指定目录(进入指定目录)
• 进入 cd 目录；cd 多级目录
• 回退 cd.. ；cd\
– cls : (clear screen)清屏
– exit : 退出dos命令行
1.4 下载安装JDK
请参考《JDK下载安装文档.doc》安装步骤

1.5 helloworld案例
1.5.1 执行流程

1.5.2 编写代码步骤
首先定义一个类
public class 类名
在类定义后加上一对大括号
{}
在大括号中间添加一个主(main)方法/函数
public static void main(String [] args){ }
在主方法的大括号中间添加一行输出语句
System.out.println(“HelloWorld”);

1.5.3 案例代码一

public class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWorld");
}
}

运行代码步骤：
• 在命令行模式中，输入javac命令对源代码进行编译，生成字节码文件
– javac 源文件名.java
• 编译完成后，如果没有报错信息，输入java命令对class字节码文件进行解释运行,执行时不需要添加.class扩展名
– java HelloWorld
1.5.4 HelloWorld案例常见问题
A:找不到文件(都演示一下，让学生看看出现的都是什么问题)
a:文件扩展名隐藏导致编译失败
b:文件名写错了
B:单词拼写问题(都演示一下，让学生看看出现的都是什么问题)
a:class写成Class
b:String写成string
c:System写成system
d:main写成mian
C:括号匹配问题(都演示一下，让学生看看出现的都是什么问题)
a:把类体的那对大括号弄掉一个
b:把方法体的那对大括号弄掉一个
c:把输出语句的那对小括号弄掉一个
D:中英文问题(都演示一下，让学生看看出现的都是什么问题)
a:提示信息：错误: 非法字符: \????的格式
注意：java编程中需要的基本上都是英文字符

### 第2章环境配置
2.1 工具安装
2.1.1 Notepad软件的安装和配置
为了让我们写的程序错误看起来更直接，我们安装一款高级记事本软件。
Notepad软件的安装和配置
设置 – 首选项 – 新建 – 默认语言和编码
2.2 环境变量配置
2.2.1 案例说明
为什么要配置
– 程序的编译和执行需要使用到javac和java命令，所以只能在bin目录下写程序
– 实际开发中，不可能把程序写到bin目录下，所以我们必须让javac和java命令在任意目录下能够访问
如何配置
– 创建新的变量名称：JAVA_HOME
计算机-右键属性-高级系统设置-高级-环境变量-系统变量
– 为JAVA_HOME添加变量值：JDK安装目录
– 在path环境变量最前面添加如下内容
%JAVA_HOME%\bin;

2.3 注释
2.3.1 注释概述
A: 什么是注释
– 用于解释说明程序的文字
B: Java中注释分类
单行注释
– 格式： //注释文字
多行注释
– 格式： /* 注释文字 */
文档注释
– 格式：/** 注释文字 */
C: 注释的作用
a:解释说明程序
b:帮助我们调试错误
2.3.2 案例代码二
```java
/*
注释：用于解释说明程序的文字

分类：
单行
多行

作用：解释说明程序，提高程序的阅读性
*/

//这是我的HelloWorld案例
public class HelloWorld {
/*
这是main方法
main是程序的入口方法
所有代码的执行都是从main方法开始的
*/
public static void main(String[] args) {
//这是输出语句
System.out.println("HelloWorld");
}
}
```
2.4 关键字
2.4.1 关键字概述
– 被Java语言赋予特定含义的单词
2.4.2 关键字特点
– 组成关键字的字母全部小写
– 常用的代码编辑器,针对关键字有特殊的颜色标记，非常直观，所以我们不需要去死记硬背，在今后的学习中重要的关键字也会不断的出来。
2.4.3 案例代码三:
```java
/*
关键字：被Java语言赋予特定含义的单词

特点：
A:组成关键字的字母全部小写
B:常见的代码编辑器,针对关键字有特殊的颜色标记
*/
public class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWorld");
}
}
```
关键字举例:

### 第3章语法格式
3.1 常量
3.1.1 常量概述
– 在程序执行的过程中，其值不可以发生改变的量
3.1.2 常量分类
– 字符串常量用双引号括起来的内容(“HelloWorld”)
– 整数常量所有整数(12,-23)
– 小数常量所有小数(12.34)
– 字符常量用单引号括起来的内容(‘a’,’A’,’0’)
– 布尔常量较为特有，只有true和false
– 空常量 null(数组部分讲解)
3.1.3 案例代码四:
```java
/*
常量：在程序执行的过程中，其值不可以发生改变的量

常量分类：
A:字符串常量 "HelloWorld"
B:整数常量 12,-23
C:小数常量 12.34
D:字符常量 'a','0'
E:布尔常量 true,false
F:空常量 null(后面讲解)
*/
public class ChangLiang {
public static void main(String[] args) {
//字符串常量
System.out.println("HelloWorld");

//整数常量
System.out.println(12);
System.out.println(-23);

//小数常量
System.out.println(12.34);

//字符常量
System.out.println('a');
System.out.println('0');

//布尔常量
System.out.println(true);
System.out.println(false);
}
}
```
3.2 变量
3.2.1 变量概述
– 在程序执行的过程中，在某个范围内其值可以发生改变的量
– 从本质上讲，变量其实是内存中的一小块区域
3.2.2 变量定义格式
– 数据类型变量名 = 初始化值;
– 注意：格式是固定的，记住格式，以不变应万变
3.2.3 变量图解

3.3 数据类型
3.3.1 计算机存储单元
变量是内存中的小容器，用来存储数据。那么计算机内存是怎么存储数据的呢？无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母b表示。而计算机最小的存储单元叫“字节（byte）”，通常用大写字母B表示，字节是由连续的8个位组成。
除了字节外还有一些常用的存储单位，大家可能比较熟悉，我们一起来看看：
– 1B（字节） = 8bit
– 1KB = 1024B
– 1MB = 1024KB
– 1GB = 1024MB
– 1TB = 1024GB

3.3.2 数据类型概述和分类
A:为什么有数据类型
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
B:Java中数据类型的分类
基本数据类型
引用数据类型
面向对象部分讲解

3.4 标识符
3.4.1 标识符概述
A 作用
– 给包,类,方法,变量等起名字
B 组成规则
– 由字符，下划线_，美元符$组成
• 这里的字符采用的是unicode字符集，所以包括英文大小写字母，中文字符，数字字符等。
– 注意事项
– 不能以数字开头
– 不能是Java中的关键字

C : 命名原则:见名知意
a包
最好是域名倒过来,要求所有的字母小写
b类或者接口
如果是一个单词首字母大写
如果是多个单词每个单词首字母大写(驼峰标识)
c方法或者变量
如果是一个单词全部小写
如果是多个单词,从第二个单词首字母大写
d常量
如果是一个单词,所有字母大写
如果是多个单词,所有的单词大写,用下划线区分每个单词
3.4.2 案例代码五
```java
/*
标识符：就是给包,类,方法,变量起名字的符号。
组成规则：
A:unicode字符
数字字符,英文大小写,汉字(不建议使用汉字)
B:下划线_
C:美元符$
注意事项
A:不能以数字开头
B:不能是java中的关键字

常见命名规则：
A:基本要求
见名知意
B:常见的命名
a:包(其实就是文件夹,用于对类进行管理)
全部小写,多级包用.隔开
举例：com，com.itheima
b:类
一个单词首字母大写
举例：Student,Car
多个单词每个单词的首字母大写
举例：HelloWorld
c:方法和变量
一个单词首字母小写
举例：age,show()
多个单词从第二个单词开始每个单词的首字母大写
举例：maxAge,getAge()
*/
public class BiaoZhiFu {
public static void main(String[] args) {
//定义变量
//数据类型变量名 = 初始化值;
int a = 10;

//正确
int b2 = 20;
//错误
//int 2b = 30;

//不能是java中的关键字
//错误
//int public = 40;
}
}
```
3.5 定义变量
3.5.1 基本数据类型变量的定义和使用
变量的定义格式：
数据类型变量名 = 初始化值;
基本数据类型：
byte,short,int,long,float,double,char,boolean
注意：
整数默认是int类型，定义long类型的数据时，要在数据后面加L。
浮点数默认是double类型，定义float类型的数据时，要在数据后面加F。
3.5.2 案例代码六
```java
public class VariableDemo {
public static void main(String[] args) {
//定义byte类型的变量
byte b = 10;
System.out.println(10);
System.out.println(b);

//定义short类型的变量
short s = 100;
System.out.println(s);

//定义int类型的变量
int i = 10000;
System.out.println(i);

//定义long类型的变量
long l = 1000000000000000L;
System.out.println(l);

//定义float类型的变量
float f = 12.34F;
System.out.println(f);

//定义double类型的变量
double d = 12.34;
System.out.println(d);

//定义char类型的变量
char c = 'a';
System.out.println(c);

//定义boolean类型的变量
boolean bb = false;
System.out.println(bb);
}
}
```
3.5.3 变量定义的注意事项
• 变量未赋值,不能直接使用
– 引出变量的第二种使用格式
• 变量只在它所属的范围内有效。
– 变量在哪对大括号内，变量就属于哪对大括号
• 一行上可以定义多个变量，但是不建议
3.5.4 案例代码七
```java
/*
变量定义注意事项：
1:变量未赋值,不能直接使用
2:变量只在它所属的范围内有效
变量属于它所在的那对大括号
3:一行上可以定义多个变量,但是不建议
*/
public class VariableDemo2 {
public static void main(String[] args) {
//定义变量
int a = 10;
System.out.println(a);

int b;
b = 20; //变量在使用前赋值都是可以的
System.out.println(b);

{
int c = 100;
System.out.println(c);
}
//System.out.println(c);

/*
int aa,bb,cc;
aa = 10;
bb = 20;
cc = 30;
*/

/*
int aa = 10;
int bb = 20;
int cc = 30;
*/

int aa=10,bb=20,cc=30;
}
}
```
3.6 数据类型转换
3.6.1 隐式数据类型转换
取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算
3.6.2 案例代码八
```java
/*
+:是一个运算符，做加法运算的。
我们在做运算的时候，一般要求参与运算的数据类型必须一致。

类型转换：
隐式转换
强制转换

隐式转换
byte,short,char -- int -- long -- float -- double
*/
public class TypeCastDemo {
public static void main(String[] args) {
//直接输出了运算的结果
System.out.println(3 + 4);

//定义两个int类型的变量
int a = 3;
int b = 4;
int c = a + b;
System.out.println(c);

//定义一个byte类型,定义一个int类型
byte bb = 2;
int cc = 5;
System.out.println(bb + cc);

//我能不能不直接输出，用一个变量接受呢?
//用变量接受，这个变量应该有类型
//可能损失精度
//byte dd = bb + cc;
int dd = bb + cc;
System.out.println(dd);
}
}
```
3.6.3 强制类型数据转换
强制转换的格式
* b = (byte)(a + b);
强制转换的注意事项
* 如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同
3.6.4 案例代码九
```java
/*
强制转换：
目标类型变量名 = (目标类型) (被转换的数据);
不建议强制转换，因为会有精度的损失。
*/
public class TypeCastDemo2 {
public static void main(String[] args) {
int a = 3;
byte b = 4;
int c = a + b;
//byte d = a + b;
byte d = (byte) (a + b);
}
}
```
## 第02天 java基础知识
今日内容介绍
 Eclipse的安装、配置及使用
 运算符
 键盘录入
### 第1章 Eclipse开发工具
1.1 Eclipse概述和安装
Eclipse是一个IDE(集成开发环境)IDE(Integrated Development Environment)
集成了代码编写功能，分析功能，编译功能，调试功能等一体化的开发软件。
Eclipse的特点描述：免费、纯Java语言编写、免安装、扩展性强
下载和安装、下载 http://eclipse.org/
安装：绿色版、解压就可以使用(Eclipse)
1.2 Eclipse的基本使用
1.2.1 Eclipse基本操作
选择工作空间
工作空间其实就是我们写的源代码所在的目录
用Eclipse来完成一个HelloWorld案例
A:创建Java项目：点击File或者在最左侧空白处，选择Java项目，在界面中写一个项目名称，然后Finish即可。
B:创建包：展开项目，在源包src下建立一个包com.itheima
C:创建类：在com.ithiema包下建立一个类HelloWorld
在界面中写一个类名：HelloWorld，然后finish即可。
D:编写代码：在HelloWorld类写main方法，在main方法中写
一条输出语句：我是黑马程序员，我骄傲，我自豪。
E:编译：自动编译，在保存的那一刻帮你做好了
F:运行选择要运行的文件或者在要运行的文件内容中
右键 -- Run as - Java Application即可
1.2.2 代码案例一
```java
package com.itheima;

public class HelloWorld {
public static void main(String[] args) {
System.out.println("我是黑马程序员,我骄傲,我自豪");
}
}
```
1.3 Eclipse工作空间的基本配置
A:行号的显示和隐藏
显示：在代码区域的最左边的空白区域，右键 -- Show Line Numbers即可。
隐藏：把上面的动作再做一次。
B:字体大小及颜色
a:Java代码区域的字体大小和颜色：
window -- Preferences -- General -- Appearance -- Colors And Fonts -- Java -- Java Edit Text Font
b:控制台
window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console font
c:其他文件
window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text Font
C:窗体给弄乱了，怎么办?
window -- Perspective -- Reset Perspective
D:控制台找不到了，怎么办?
Window--Show View—Console
1.4 Eclipse中辅助键和快捷键的使用
1.4.1 常用辅助键和快捷键概述
内容辅助键 alt+/
main 然后alt+/
syso 然后alt+/

快捷键
注释
单行选中内容，ctrl+/, 再来一次取消
多行选中内容，ctrl+shift+/, ctrl+shift+\
格式化 ctrl+shift+f
1.4.2 代码案例二
```java
package com.itheima_02;
/*
* 内容辅助键：alt+/
* A:main方法
* main,然后alt+/,回车
* B:输出语句
* syso,然后然后alt+/,回车
*
* 快捷键：
* A:注释
* 单行选中内容，ctrl+/,再来一次就是取消
* 多行选择内容，ctrl+shift+/,ctrl+shift+\
* B:格式化
* ctrl+shift+f
*/
public class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWorld1");
System.out.println("HelloWorld2");
System.out.println("HelloWorld3");
System.out.println("HelloWorld4");
System.out.println("HelloWorld5");
}
}
```
1.5 Eclipse中项目的删除和导入
A:删除项目
选中项目 – 右键 – 删除
从项目区域中删除
从硬盘上删除
B:导入项目
在项目区域右键找到import
找到General，展开，并找到
Existing Projects into Workspace
点击next,然后选择你要导入的项目
注意：这里选择的是项目名称

### 第2章运算符
2.1 算数运算符
• 运算符
对常量和变量进行操作的符号称为运算符
• 表达式
用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式。不同运算符连接的式子体现的是不同类型的表达式。
定义两个int类型的变量a,b，做加法(a + b)
• 常用运算符
算术运算符
赋值运算符
关系运算符
逻辑运算符
三元运算符

2.1.1 算数运算符的基本用法
2.1.2 算数运算符概述
A:什么是运算符
就是对常量和变量进行操作的符号。
B:算数运算符有哪些
* +,-,*,/,%,++,--
2.1.3 代码案例三
```java
package com.itheima_01;
/*
* 运算符：对常量和变量进行操作的符号
* 表达式：用运算符连接起来的符合java语法的式子。不同类型的运算符连接起来的式子是不同的表达式。
* 举例：定义两个int类型的变量a,b,
* a + b
*
* 运算符分类：
* 算术运算符，赋值运算符，关系运算符，逻辑运算符，三元运算符。
*
* 算术运算符：
* +，-，*，/的基本使用
*/
public class OperatorDemo {
public static void main(String[] args) {
// 定义两个变量
int a = 3;
int b = 4;

System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);

// 整数相除只能得到整数，要想得到小数，就必须有浮点数参与运算
System.out.println(3 / 4.0);
System.out.println(3.0 / 4);
}
}
```
2.1.4 算数运算符取余和除法的区别
%：取余运算符。得到的是两个相除数据的余数。
/:除法运算符。得到是两个相除数据的商。
使用场景： %：判断两个数据是否整除。
2.1.5 代码案例四
```java
public class OperatorDemo2 {
public static void main(String[] args) {
int a = 5;
int b = 3;

System.out.println(a / b);
System.out.println(a % b);
}
}
```
2.1.6 字符和字符串参与加法操作
字符参与运算
其实是拿该字符对应的数值来操作
‘a’ 97
‘A’ 65
‘0’ 48
字符串参与运算
这里其实做的不是加法运算，而是字符串拼接。
字符串和其他类型的数据做拼接，结果是字符串类型的。
2.1.7 代码案例五
```java
package com.itheima_01;
/*
* 整数的加法。
* 字符参与加法操作。拿字符在计算机中底层存储对应的数据值来参与运算的。
* '0' 48
* 'a' 97
* 'A' 65
* 字符串参与加法操作。
* 这里的+其实不是加法，而是字符串连接符。
*/
public class OperatorDemo3 {
public static void main(String[] args) {
// 整数加法
int a = 10;
int b = 20;
System.out.println(a + b);
System.out.println("------------------");

// 字符参与加法操作
char c = '0';
char c2 = 'a';
System.out.println(a + c);
System.out.println(a + c2);
System.out.println("------------------");

// 字符串参与加法操作
System.out.println("hello" + a);
System.out.println("hello" + a + b); // "hello"+10,然后再和b进行拼接
System.out.println(a + b + "hello");
}
}
```
2.1.8 算数运算符++和- - 的用法
++,--运算符：对变量做加1或者减1的操作。
++或者--既可以放在变量的后面，也可以放在变量的前面。
单独使用的时候，++或者--无论是放在变量的前面还是后面，结果是一样的。
参与操作的时候：
如果++或者--在变量的后面，先拿变量参与操作，后变量做++或者--
如果++或者--在变量的前面，先变量做++或者--，后拿变量参与操作
2.1.9 代码案例六
```java
public class OperatorDemo4 {
public static void main(String[] args) {
int a = 10;
System.out.println("a:" + a);

// 单独使用
// a++;
// ++a;
// System.out.println("a:" + a);

// 参与操作使用
// int b = a++;
int b = ++a;
System.out.println("a:" + a);
System.out.println("b:" + b);
}
}
```
2.2 赋值运算符
2.2.1 赋值运算符分类
基本的赋值运算符：=
扩展的赋值运算符：+=,-=,*=,/=,%=
+=: a+=20;相当于a = (a的数据类型)(a + 20);
2.2.2 代码案例七
```java
package com.itheima_02;
/*
* 赋值运算符：
* A:基本 =
* B:扩展 +=,-=,*=,...
*
* +=:
* a+=20;
* 相当于
* a = (a的数据类型)(a + 20);
*/
public class OperatorDemo {
public static void main(String[] args) {
// 把10赋值给int类型的变量a
int a = 10;

// += 把左边和右边的数据进行运算，最后赋值给左边。左边的只能是变量
a += 10;// 相当于a = a + 10
System.out.println("a:" + a);
System.out.println("----------------------");

short s = 10;
// s += 20; // 相当于 s = s + 20;
s = (short) (s + 20);
System.out.println("s:" + s);
}
}
```
2.3 关系运算符
2.3.1 基本使用及注意事项
关系运算符包含以下内容:
==,!=,>,>=,<,<=
关系运算符的结果都是boolean型，也就是要么是true，要么是false。
注意事项:
关系运算符“==”不能误写成“=”。
2.3.2 代码案例八
```java
package com.itheima_03;

/*
* 关系运算符：
* ==,!=,>,>=,<,<=
* 关系运算符的结果是boolean类型。
*
* 注意：
* 千万不要把==写成=
*/
public class OperatorDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 10;

System.out.println(a == b);
System.out.println(a == c);
System.out.println("-----------------");
System.out.println(a != b);
System.out.println(a != c);
System.out.println("-----------------");
System.out.println(a > b);
System.out.println(a > c);
System.out.println("-----------------");
System.out.println(a >= b);
System.out.println(a >= c);
System.out.println("-----------------");

int x = 3;
int y = 4;
// System.out.println(x == y);
// System.out.println(x = y);// 把y赋值给x，把x的值输出
boolean bb = (x == y);
// 报错
// boolean cc = (x = y);
int cc = (x = y);
}
}
```
2.4 逻辑运算符
2.4.1 逻辑运算符概述
A:逻辑运算符有哪些
&,|,^,!
&&,||
B:案例演示
逻辑运算符的基本用法

C:注意事项：
a:逻辑运算符一般用于连接boolean类型的表达式或者值。
b:表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
算术表达式：a + b
比较表达式：a == b(条件表达式)
D:结论：
&逻辑与:有false则false。
|逻辑或:有true则true。
^逻辑异或:相同为false，不同为true。
!逻辑非:非false则true，非true则false。
特点：偶数个不改变本身。
2.4.2 代码案例九
```java
package com.itheima_04;
/*
* 逻辑运算符：用于连接关系表达式。
* &,|,^,!
* &&,||
*
* 与：& 有false则false
* 或：| 有true则true
* 异或：^ 相同则false,不同则true。(男女朋友)
* 非：! true则false,false则true
*/
public class OperatorDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;

System.out.println((a > b) & (a > c));// false & false
System.out.println((a < b) & (a > c)); // true & false
System.out.println((a > b) & (a < c)); // false & true
System.out.println((a < b) & (a < c)); // true & true
System.out.println("---------------");
System.out.println((a > b) | (a > c));// false | false
System.out.println((a < b) | (a > c)); // true | false
System.out.println((a > b) | (a < c)); // false | true
System.out.println((a < b) | (a < c)); // true | true
System.out.println("---------------");
System.out.println((a > b) ^ (a > c));// false ^ false
System.out.println((a < b) ^ (a > c)); // true ^ false
System.out.println((a > b) ^ (a < c)); // false ^ true
System.out.println((a < b) ^ (a < c)); // true ^ true
System.out.println("---------------");
System.out.println((a > b)); // false
System.out.println(!(a > b)); // !false
System.out.println(!!(a > b)); // !!false
}
}
```
2.4.3 逻辑运算符&&与&的区别
A:&&和&的区别?
a:最终结果一样。
b:&&具有短路效果。左边是false，右边不执行。
&是无论左边是false还是true,右边都会执行
B:||和|的区别?
a:最终结果一样
b:||具有短路效果.左边是true,右边不执行
|是无论左边是false还是true,右边都会执行
2.4.4 代码案例十:
```java
package com.itheima_04;

/*
* &&和&的结果一样
* ||和|的结果一样
*
* &&和&的区别：
* &&如果左边是false，右边不执行。
* &无论左边是true还是false，右边都会执行。
*/
public class OperatorDemo2 {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;

System.out.println((a > b) && (a > c));// false && false
System.out.println((a < b) && (a > c)); // true && false
System.out.println((a > b) && (a < c)); // false && true
System.out.println((a < b) && (a < c)); // true && true
System.out.println("---------------");
System.out.println((a > b) || (a > c));// false || false
System.out.println((a < b) || (a > c)); // true || false
System.out.println((a > b) || (a < c)); // false || true
System.out.println((a < b) || (a < c)); // true || true
System.out.println("---------------");

int x = 3;
int y = 4;
// System.out.println((x++ > 4) & (y++ > 5)); // false & false
System.out.println((x++ > 4) && (y++ > 5)); // false && false
System.out.println("x:" + x);
System.out.println("y:" + y);
}
}
```
2.5 三元运算符
2.5.1 三元运算符概述
A:格式
(关系表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
B:示例：
获取两个数中大数。
int x=3,y=4,z;
z = (x>y)?x:y;//z变量存储的就是两个数的大数
2.5.2 代码案例十一
```java
package com.itheima_05;
/*
* 三元运算符：
*
* 格式：
* (关系表达式)?表达式1:表达式2;
* 执行流程:
* A:计算关系表达式的值，看是true还是false
* B:如果是true,表达式1就是运算结果
* 如果是false,表达式2就是运算结果
*/
public class OperatorDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;

int c = (a > b) ? a : b;
System.out.println("c:" + c);
}
}
```
2.5.3 代码案例十二(比较两个数是否相同)
```java
package com.itheima_05;

/*
* 三元运算符的练习
* 比较两个整数是否相同
*/
public class OperatorTest {
public static void main(String[] args) {
// 定义两个int类型的变量
int a = 10;
int b = 20;

boolean flag = (a == b) ? true : false;
// boolean flag = (a == b);
System.out.println(flag);
}
}
```
2.5.4 代码案例十三(获取三个数中的最大值)
```java
package com.itheima_05;
/*
* 获取三个整数中的最大值
*/
public class OperatorTest2 {
public static void main(String[] args) {
// 定义三个int类型的变量
int a = 10;
int b = 30;
int c = 20;

// 先比较两个整数的大值
int temp = ((a > b) ? a : b);
int max = ((temp > c) ? temp : c);
System.out.println("max:" + max);
}
}
```
### 第3章键盘录入
3.1 键盘录入的基本步骤
3.1.1 键盘录入数据概述
我们目前在写程序的时候，数据值都是固定的，但是实际开发中，数据值肯定是变化的，所以，把数据改进为键盘录入，提高程序的灵活性。
键盘录入数据的步骤:
A:导包(位置放到class定义的上面)
import java.util.Scanner;
B:创建对象
Scanner sc = new Scanner(System.in);
C:接收数据
int x = sc.nextInt();

3.1.2 代码案例十四
```java
package com.itheima;
import java.util.Scanner;
/*
* 为了提高程序的灵活性，我们就把数据改进为键盘录入。
* 如何实现键盘录入呢?目前我们只能使用JDK提供的类Scanner。
* 这个使用的步骤，目前大家记住就可以了。
*
* 使用步骤：
* A:导包
* import java.util.Scanner;
* 类中的顺序：package > import > class
* B:创建对象
* Scanner sc = new Scanner(System.in);
* C:接收数据
* int i = sc.nextInt();
*/

public class ScannerDemo {
public static void main(String[] args) {
//创建键盘录入数据的对象
Scanner sc = new Scanner(System.in);

//接收数据
System.out.println("请录入一个整数：");
int i = sc.nextInt();

//输出数据
System.out.println("i:"+i);
}
}
```
3.2 键盘录入的练习
3.2.1 键盘录入两个数据并求和
键盘录入两个数据，并对这两个数据求和，输出其结果
键盘录入：
A:导包
B:创建对象
C:接收数据
3.2.2 代码案例十五
```java
package com.itheima;

import java.util.Scanner;
public class ScannerTest {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);

// 接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();

System.out.println("请输入第二个数据：");
int b = sc.nextInt();

// 对数据进行求和
int sum = a + b;
System.out.println("sum:" + sum);
}
}
```
3.2.3 键盘录入两个数据比较是否相等
键盘录入两个数据，比较这两个数据是否相等
3.2.4 代码案例十六
```java
package com.itheima;
import java.util.Scanner;

/*
* 键盘录入两个数据，比较这两个数据是否相等
*/
public class ScannerTest2 {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);

// 接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();

System.out.println("请输入第二个数据：");
int b = sc.nextInt();

// 比较两个数据是否相等
// boolean flag = ((a == b) ? true : false);
boolean flag = (a == b);
System.out.println("flag:" + flag);
}
}
````
3.2.5 键盘录入三个数据获取最大值
键盘录入三个数据，获取这三个数据中的最大值
3.2.6 代码案例十七
```java
package com.itheima;

import java.util.Scanner;

/*
* 键盘录入三个数据，获取这三个数据中的最大值
*/
public class ScannerTest3 {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);

// 接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();

System.out.println("请输入第二个数据：");
int b = sc.nextInt();

System.out.println("请输入第三个数据：");
int c = sc.nextInt();

// 如何获取三个数据的最大值
int temp = (a > b ? a : b);
int max = (temp > c ? temp : c);

System.out.println("max:" + max);
}
}
```
## 第03天 java基础知识
今日内容介绍
 选择流程控制语句
 循环流程控制语句
 控制循环语句
### 第1章选择流程控制语句
1.1 顺序结构的基本使用
1.1.1 顺序结构概述
是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的
1.1.2 顺序流程流程图

1.1.3 代码案例一
```java
package com.itheima_01;

/*
* 顺序结构：从上往下，依次执行
*/
public class OrderDemo {
public static void main(String[] args) {
System.out.println("开始");
System.out.println("语句A");
System.out.println("语句B");
System.out.println("语句C");
System.out.println("结束");
}
}
```
1.2 If语句的格式
1.2.1 If语句格式1及执行流程
if语句第一种格式：
if(关系表达式) {
语句体
}
执行流程:
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体
如果是false就不执行语句体
1.2.2 if语句格式1执行流程图

1.2.3 代码案例二
```java
package com.itheima_02;
/*
* if语句有三种格式。
*
* if语句格式1：
* if(关系表达式) {
* 语句体;
* }
*
* 执行流程：
* A:首先判断关系表达式看其结果是true还是false
* B:如果是true,就执行语句体
* C:如果是false,就不执行语句体
*/
public class IfDemo {
public static void main(String[] args) {
System.out.println("开始");
// 定义两个变量
int a = 10;
int b = 20;

if (a == b) {
System.out.println("a等于b");
}

int c = 10;
if (a == c) {
System.out.println("a等于c");
}

System.out.println("结束");
}
}
```
1.2.4 If语句格式2及执行流程
if语句第二种格式：
if(关系表达式) {
语句体1;
}else {
语句体2;
}
执行流程
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体1
如果是false就执行语句体2
1.2.5 if语句格式2执行流程图

1.2.6 代码案例三
```java
package com.itheima_02;
/*
* if语句格式2：
* if(关系表达式) {
* 语句体1;
* }else {
* 语句体2;
* }
*
* 执行流程：
* A:判断关系表达式的值是true还是false
* B:如果是true，就执行语句体1
* C:如果是false，就执行语句体2
*/
public class IfDemo2 {
public static void main(String[] args) {
System.out.println("开始");
// 判断给定的数据是奇数还是偶数
// 定义变量
int a = 100;
// 给a重新赋值
a = 99;

if (a % 2 == 0) {
System.out.println("a是偶数");
} else {
System.out.println("a是奇数");
}

System.out.println("结束");
}
}
```
1.2.7 If语句格式3及执行流程

if语句第三种格式：
if(关系表达式1) {
语句体1;
}else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
执行流程
首先判断关系表达式1看其结果是true还是false
如果是true就执行语句体1
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句体2
如果是false就继续判断关系表达式…看其结果是true还是false
…
如果没有任何关系表达式为true，就执行语句体n+1
1.2.8 if语句格式3执行流程图

1.2.9 代码案例四
```java
package com.itheima_02;

/*
* if语句格式3：
* if(关系表达式1) {
* 语句体1;
* }else if(关系表达式2) {
* 语句体2;
* }else if(关系表达式3) {
* 语句体3;
* }
* ...
* else {
* 语句体n+1;
* }
*
* 执行流程：
* A:首先判断关系表达式1看其结果是true还是false
* B:如果是true，就执行语句体1
* 如果是false，就继续进行关系表达式2的判断看其结果是true还是false
* C:如果是true，就执行语句体2
* 如果是false，就继续进行关系表达式...的判断看其结果是true还是false
* ...
* D:如果没有一个为true的，就执行语句体n+1
*
* if语句的三种格式：
* 第一种格式适合做一种情况的判断
* 第二种格式适合做二种情况的判断
* 第三种格式适合做多种情况的判断
*/
public class IfDemo3 {
public static void main(String[] args) {
// x和y的关系满足如下：
// x>=3 y = 2x + 1;
// -1<=x<3 y = 2x;
// x<=-1 y = 2x – 1;
// 根据给定的x的值，计算出y的值并输出。

// 定义变量
int x = 5;

/*
int y;
if (x >= 3) {
y = 2 * x + 1;
} else if (x >= -1 && x < 3) {
y = 2 * x;
} else if (x <= -1) {
y = 2 * x - 1;
}else {
y = 0;
}
*/

int y = 0;
if (x >= 3) {
y = 2 * x + 1;
} else if (x >= -1 && x < 3) {
y = 2 * x;
} else if (x <= -1) {
y = 2 * x - 1;
}

System.out.println("y的值是："+y);
}
}
```
1.3 If语句的练习
1.3.1 if语句实现获取两个数据较大值
1.3.2 代码案例五
```java
package com.itheima_02;

import java.util.Scanner;

/*
* 键盘录入两个数据，获取这两个数据的较大值
*
* 分析：
* A:看到键盘录入，我们就应该想到键盘录入的三步骤
* 导包，创建对象，接收数据
* B:获取这两个数据的较大值，其实就是判断两个数据谁大，把大的输出就可以了。
*
* 导包：
* A:手动导包
* import java.util.Scanner;
* B:鼠标点击红色叉叉，自动生成
* C:快捷键(推荐)
* ctrl+shift+o
*/
public class IfTest {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);

//接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();

System.out.println("请输入第二个数据：");
int b = sc.nextInt();

//采用if语句格式2实现
/*
if(a>b){
System.out.println("较大的值是："+a);
}else {
System.out.println("较大的值是："+b);
}
*/

//拿到较大的值之后，我未必想直接输出，所以我们定义变量接收这个较大的值
int max;
if(a>b){
max = a;
}else {
max = b;
}
//可能做其他的操作
//max += 100;
System.out.println("较大的值是："+max);
}
}
```
1.3.3 if语句实现判断学生等级
1.3.4 代码案例六
```java
package com.itheima_02;

import java.util.Scanner;

/*
* 键盘录入学生考试成绩，请根据成绩判断该学生属于哪个级别
* 90-100 优秀
* 80-90 好
* 70-80 良
* 60-70 及格
* 60以下不及格
*
* 分析：
* A:键盘录入学生考试成绩
* 三步骤
* B:通过简单的分析，我们决定采用if语句格式3来实现
*
* 程序一定要考虑周全了。
* 安全数据
* 边界数据
* 错误数据
*/
public class IfTest2 {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);

//接收数据
System.out.println("请输入学生的考试成绩：");
int score = sc.nextInt();

//if语句格式3
/*
if(score>=90 && score<=100){
System.out.println("你的成绩属于优秀");
}else if(score>=80 && score<90){
System.out.println("你的成绩属于好");
}else if(score>=70 && score<80){
System.out.println("你的成绩属于良");
}else if(score>=60 && score<70){
System.out.println("你的成绩属于及格");
}else {
System.out.println("你的成绩属于不及格");
}
*/

//我们发现程序不够健壮,加入错误数据的判断
if(score<0 || score>100){
System.out.println("你的成绩是错误的");
}else if(score>=90 && score<=100){
System.out.println("你的成绩属于优秀");
}else if(score>=80 && score<90){
System.out.println("你的成绩属于好");
}else if(score>=70 && score<80){
System.out.println("你的成绩属于良");
}else if(score>=60 && score<70){
System.out.println("你的成绩属于及格");
}else {
System.out.println("你的成绩属于不及格");
}
}
}
```
1.4 switch语句的格式及执行流程
1.4.1 格式解释:
switch表示这是switch语句
表达式的取值：byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是String
case后面跟的是要和表达式进行比较的值
语句体部分可以是一条或多条语句
break表示中断，结束的意思，可以结束switch语句
default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
1.4.2 执行流程
首先计算出表达式的值
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
1.4.3 switch语句执行流程图

1.5 switch语句的练习
1.5.1 switch语句实现根据数字输出对应星期
1.5.2 代码案例七
```java
package com.itheima_03;

import java.util.Scanner;

/*
* switch语句格式：
* switch(表达式) {
* case 值1:
* 语句体1;
* break;
* case 值2:
* 语句体2;
* break;
* ...
* default:
* 语句体n+1;
* break;
* }
* 格式解释：
* 表达式:byte,short,int,char
* JDK5以后可以是枚举
* JDK7以后可以是字符串
* case:就是要和表达式进行比较的值
* break:表示中断,结束的意思。
* default:表示所有的情况都不匹配的时候，就执行语句体n+1。和if语句的else相似。
* 执行流程：
* A:计算出表达式的值
* B:拿计算出来的值和case后面的值依次比较，一旦有对应的值，就执行该处的语句，在执行过程中，遇到 break，就结束。
* C:如果所有的case都不匹配，就会执行default控制的语句，然后结束。
* 需求：
* 根据键盘录入的数值1，2，3，…7输出对应的星期一，星期二，星期三…星期日。
*/
public class SwitchDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

//接收数据
System.out.println("请输入一个数字(1-7)：");
int weekday = sc.nextInt();

//switch语句实现选择
switch(weekday) {
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;
}
}
}
```
### 第2章循环流程控制语句
2.1 for循环的格式及基本使用
2.1.1 for循环语句格式：
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
2.1.2 执行流程
A:执行初始化语句
B:执行判断条件语句，看其结果是true还是false
如果是false，循环结束。
如果是true，继续执行。
C:执行循环体语句
D:执行控制条件语句
E:回到B继续
2.1.3 for循环的执行流程图

2.1.4 代码案例八
```java
package com.itheima_04;
/*
* for循环语句格式：
* for(初始化语句;判断条件语句;控制条件语句) {
* 循环体语句;
* }
*
* 执行流程：
* A:执行初始化语句
* B:执行判断条件语句，看结果是true还是false
* 如果是true，就继续执行
* 如果是false，就结束循环
* C:执行循环体语句
* D:执行控制条件语句
* E:回到B继续
*
* 需求：
* 在控制台输出10次”HelloWorld”的案例。
*/
public class ForDemo {
public static void main(String[] args) {
//原始写法
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("-------------------------");

//用循环改进
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
}
}
```
2.2 for循环的练习
2.2.1 for循环实现获取指定范围数据
2.2.2 代码案例九
```java
package com.itheima_04;
/*
* 需求：获取数据1-5和5-1
*/
public class ForTest {
public static void main(String[] args) {
//原始做法
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
System.out.println("-------------");

//用循环改进
for(int x=1; x<=5; x++) {
System.out.println(x);
}
System.out.println("-------------");

//1-5的数据我们获取到了，如何获取5-1呢?
for(int x=5; x>=1; x--){
System.out.println(x);
}
}
}
```
2.2.3 for循环实现1-5之间数据求和
2.2.4 代码案例十
```java
package com.itheima_04;
/*
* 需求：求出1-5之间数据之和
*
* 分析：
* A:定义求和变量，初始化值是0
* B:获取1-5之间的数据，用for循环实现
* C:把每一次获取到的数据，累加起来就可以了
* D:输出求和变量即可
*/
public class ForTest2 {
public static void main(String[] args) {
//定义求和变量，初始化值是0
int sum = 0;

//获取1-5之间的数据，用for循环实现
for(int x=1; x<=5; x++) {
//把每一次获取到的数据，累加起来就可以了
//sum = sum + x;
/*
* 第一次：sum = 0 + 1 = 1
* 第二次：sum = 1 + 2 = 3
* 第三次：sum = 3 + 3 = 6
* 第四次：sum = 6 + 4 = 10
* 第五次：sum = 10 + 5 = 15
*/
sum += x;
}

//输出求和结果
System.out.println("sum:"+sum);
}
}
```
2.2.5 for循环实现1-100之间偶数和
2.2.6 代码案例十一
```java
package com.itheima_04;
/*
* 需求：求出1-100之间偶数和
*
* 分析：
* A:定义求和变量，初始化值是0
* B:获取1-100之间的数据，用for循环实现
* C:把获取到的数据进行判断，看是否是偶数
* 如果是，就累加
* D:输出求和结果
*/
public class ForTest3 {
public static void main(String[] args) {
//定义求和变量，初始化值是0
int sum = 0;

//获取1-100之间的数据，用for循环实现
for(int x=1; x<=100; x++) {
//把获取到的数据进行判断，看是否是偶数
if(x%2 ==0) {
sum += x;
}
}

//输出求和结果
System.out.println("sum:"+sum);
}
}
````

2.2.7 for循环实现在控制台打印水仙花数
2.2.8 代码案例十二
```java
package com.itheima_04;
/*
* 需求：在控制台输出所有的”水仙花数”
*
* 分析：
* 什么是水仙花数呢?
* 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
* 举例：153就是一个水仙花数。
* 153 = 1*1*1 + 5*5*5 + 3*3*3
*
* A:三位数其实就告诉了我们水仙花数的范围
* 100-999
* B:如何获取一个数据的每一个位上的数呢?
* 举例：我有一个数据153，请问如何获取到个位，十位，百位
* 个位：153%10 = 3;
* 十位：153/10%10 = 5;
* 百位：153/10/10%10 = 1;
* 千位：...
* 万位：...
* C:让每个位上的立方和相加，并和该数据进行比较，如果相等，就说明该数据是水仙花数，在控制台输出
*/
public class ForTest4 {
public static void main(String[] args) {
//通过循环获取到每一个三位数
for(int x=100; x<1000; x++) {
//获取个位，十位，百位
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;

//让每个位上的立方和相加，并和该数据进行比较，如果相等，就说明该数据是水仙花数，在控制台输出
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
System.out.println(x);
}
}
}
}
```
2.2.9 for循环实现统计水仙花的个数
2.2.10 代码案例十三
```java
package com.itheima_04;
/*
* 需求：统计”水仙花数”共有多少个
*
* 分析：
* A:定义统计变量，初始化值是0
* B:获取三位数，用for循环实现
* C:获取三位数的个位，十位，百位
* D:判断这个三位数是否是水仙花数，如果是，统计变量++
* E:输出统计结果就可以了
*/
public class ForTest5 {
public static void main(String[] args) {
//定义统计变量，初始化值是0
int count = 0;

//获取三位数，用for循环实现
for(int x=100; x<1000; x++) {
//获取三位数的个位，十位，百位
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;

//判断这个三位数是否是水仙花数，如果是，统计变量++
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
count++;
}
}

//输出统计结果就可以了
System.out.println("水仙花数共有："+count+"个");
}
}
```
2.3 while循环的格式及基本使用
2.3.1 while循环语句格式
基本格式
while(判断条件语句) {
循环体语句;
}
扩展格式
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
2.3.2 执行流程图

2.3.3 代码案例十四
```java
package com.itheima_05;
/*
* while循环语句的基本格式：
* while(判断条件语句) {
* 循环体语句;
* }
* 扩展格式：
* 初始化语句;
* while(判断条件语句) {
* 循环体语句;
* 控制条件语句;
* }
*
* 回顾for循环的语句格式：
* for(初始化语句;判断条件语句;控制条件语句) {
* 循环体语句;
* }
*/
public class WhileDemo {
public static void main(String[] args) {
//输出10次HelloWorld
/*
for(int x=1; x<=10; x++) {
System.out.println("HellloWorld");
}
*/

//while循环实现
int x=1;
while(x<=10) {
System.out.println("HellloWorld");
x++;
}
}
}
```
2.4 while循环的练习
2.4.1 while循环实现1-100之间数据求和
2.4.2 代码案例十五
```java
package com.itheima_05;
/*
* 求1-100之和。
* 练习：统计水仙花个数。
*/
public class WhileTest {
public static void main(String[] args) {
//回顾for循环实现

/*
//定义求和变量
int sum = 0;
//获取1-100之间的数据
for(int x=1; x<=100; x++) {
//累加
sum += x;
}
System.out.println("1-100的和是："+sum);
*/

//while循环实现
//定义求和变量
int sum = 0;
int x = 1;
while(x<=100) {
sum += x;
x++;
}
System.out.println("1-100的和是："+sum);
}
}
```
2.5 do…while循环的格式及基本使用
2.5.1 do…while循环语句格式
基本格式
do {
循环体语句;
}while((判断条件语句);
扩展格式
初始化语句;
do {
循环体语句;
控制条件语句;
} while((判断条件语句);
2.5.2 执行流程图

2.5.3 代码案例十六
```java
package com.itheima_06;
/*
* do...while循环的基本格式：
* do {
* 循环体语句;
* }while(判断条件语句);
* 扩展格式：
* 初始化语句;
* do {
* 循环体语句;
* 控制条件语句;
* }while(判断条件语句);
* 执行流程：
* A:执行初始化语句;
* B:执行循环体语句;
* C:执行控制条件语句;
* D:执行判断条件语句，看是true还是false
* 如果是true，回到B继续
* 如果是false，就结束
*
* 练习：
* 求和案例
* 统计水仙花个数
*/
public class DoWhileDemo {
public static void main(String[] args) {
//输出10次 HelloWorld
/*
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
*/

//do...while改写
int x=1;
do {
System.out.println("HelloWorld");
x++;
}while(x<=10);
}
}
```
2.6 三种循环的区别
2.6.1 区别概述
虽然可以完成同样的功能，但是还是有小区别：
do…while循环至少会执行一次循环体。
for循环和while循环只有在条件成立的时候才会去执行循环体
for循环语句和while循环语句的小区别：
使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。

2.6.2 代码案例十七
```java
package com.itheima_06;
/*
* 三种循环的区别：
* A:do...while至少执行一次循环体
* B:for,while循环先判断条件是否成立，然后决定是否执行循环体
*
* for和while的小区别：
* for循环的初始化变量，在循环结束后，不可以被访问。而while循环的初始化变量，是可以被继续使用的。
* 如果初始化变量，后面还要继续访问，就使用while，否则，推荐使用for。
*
* 循环的使用推荐：
* for -- while -- do...while
*/
public class DoWhileDemo2 {
public static void main(String[] args) {
/*
int x = 3;
while(x<3) {
System.out.println("我爱林青霞");
x++;
}
System.out.println("--------------");
int y = 3;
do {
System.out.println("我爱林青霞");
y++;
}while(y<3);
*/

for(int x=1; x<=10; x++){
System.out.println("爱生活，爱Java");
}
//这里的x无法继续访问
//System.out.println(x);
System.out.println("-----------------");

int y = 1;
while(y<=10) {
System.out.println("爱生活，爱Java");
y++;
}
System.out.println(y);
}
}
```
### 第3章控制循环语句
3.1 控制跳转语句break
3.1.1 Break的使用场景和作用
break的使用场景：
在选择结构switch语句中
在循环语句中
离开使用场景的存在是没有意义的
break的作用：
跳出单层循环
3.1.2 代码案例十八
```java
package com.itheima_07;
/*
* break:中断的意思
* 使用场景：
* A:switch语句中
* B:循环中
* 注意：
* 离开使用场景是没有意义的。
* 作用：
* 跳出循环，让循环提前结束
*/
public class BreakDemo {
public static void main(String[] args) {
//break;

for(int x=1; x<=10; x++) {
if(x == 3) {
break;
}
System.out.println("HelloWorld");
}
}
}
```
3.2 控制跳转语句continue
3.2.1 continue的使用场景：
在循环语句中
离开使用场景的存在是没有意义的
continue的作用：
单层循环对比break，然后总结两个的区别
break 退出当前循环
continue 退出本次循环
3.2.2 代码案例十九
```java
package com.itheima_07;
/*
* continue:继续的意思
* 使用场景：
* 循环中
* 注意：
* 离开使用场景是没有意义的
* 作用：
* 结束一次循环，继续下一次的循环
* 区别：
* break:退出循环
* continue:结束一次循环，继续下一次的循环
*/
public class ContinueDemo {
public static void main(String[] args) {
//continue;

for(int x=1; x<=10; x++) {
if(x == 3) {
//break;
continue;
}
System.out.println("HelloWorld");
}
}
}
```
3.3 控制跳转语句练习
3.3.1 练习需求:
按要求分析结果，并验证
for(int x=1; x<=10; x++) {
if(x%3==0) {
//分别写break，continue，说说输出几次
}
System.out.println(“我爱林青霞”);
}

3.3.2 代码案例二十
```java
package com.itheima_07;
/*
* 按要求分析结果，并验证
*
* break：输出2次
* continue:输出7次
*/
public class BreakAndContinueDemo {
public static void main(String[] args) {

for (int x = 1; x <= 10; x++) {
if (x % 3 == 0) {
// 分别写break，continue，说说输出几次
//break;
continue;
}
System.out.println("我爱林青霞");
}

}
}
```
## 第04天 java基础语法
今日内容介绍
 Random
 数组
### 第1章 Random
1.1 产生整数随机数
1.1.1 Random的使用步骤
我们想产生1~100(包含1和100)的随机数该怎么办呢? 我们不需要自己去写算法,因为Java已经为我们提供好了产生随机数的类---Random:
作用：
– 用于产生一个随机数
• 使用步骤(和Scanner类似)
– 导包
• import java.util.Random;
– 创建对象
• Random r = new Random();
– 获取随机数
• int number = r.nextInt(10);
• 产生的数据在0到10之间，包括0，不包括10。
• 括号里面的10是可以变化的，如果是100，就是0-100之间的数据

1.1.2 案例代码一:
```java
package com.itheima;
import java.util.Random;

/*
* Random:用于产生随机数
*
* 使用步骤：
* A:导包
* import java.util.Random
* B:创建对象
* Random r = new Random();
* C:获取随机数
* int number = r.nextInt(10);
* 获取的是0-10之间的随机数，包括0，不包括10
*
* 需求：如何获取到一个1-100之间的随机数呢?
*/
public class RandomDemo {
public static void main(String[] args) {
// 创建对象
Random r = new Random();

for (int x = 0; x < 10; x++) {
// 获取随机数
int number = r.nextInt(10);
// 输出随机数
System.out.println("number:" + number);
}
System.out.println("--------------------");

// 如何获取到一个1-100之间的随机数呢?
int i = r.nextInt(100) + 1;
System.out.println("i:" + i);
}
}
```

1.2 猜数字小游戏案例:
1.2.1 系统产生一个1-100之间的随机数，请猜出这个数据是多少。
1.2.2 案例代码二:

```java
package com.itheima;

import java.util.Random;
import java.util.Scanner;

/*
* 猜数字小游戏案例
* 系统产生一个1-100之间的随机数，请猜出这个数据是多少。
* 分析：
* A:系统产生一个随机数1-100之间的。
* int number = r.nextInt(100) + 1;
* B:键盘录入我们要猜的数据
* 用Scanner实现
* C:比较这两个数据(用if语句)
* 大了：给出提示大了
* 小了：给出提示小了
* 猜中了：给出提示，恭喜你，猜中了
* D:多次猜数据，而我们不知道要猜多少次，怎么办呢?
* while(true) {循环的内容}
*/
public class RandomTest {
public static void main(String[] args) {
// 系统产生一个随机数1-100之间的。
Random r = new Random();
int number = r.nextInt(100) + 1;

while(true){
// 键盘录入我们要猜的数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要猜的数字(1-100)：");
int guessNumber = sc.nextInt();

// 比较这两个数据(用if语句)
if (guessNumber > number) {
System.out.println("你猜的数据" + guessNumber + "大了");
} else if (guessNumber < number) {
System.out.println("你猜的数据" + guessNumber + "小了");
} else {
System.out.println("恭喜你,猜中了");
break;
}
}
}
}
```
### 第2章数组
2.1 数组概述
需求：现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有80名员工，用前面所学的知识，程序首先需要声明80个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦。为了解决这种问题，Java就提供了数组供我们使用。
那么数组到底是什么呢?有什么特点呢?通过上面的分析：我们可以得到如下两句话：
数组是存储多个变量(元素)的东西(容器)
这多个变量的数据类型要一致

2.2 数组的定义格式
2.2.1 数组概念
数组是存储同一种数据类型多个元素的容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
2.2.2 数组的定义格式
格式1：数据类型[] 数组名;
格式2：数据类型数组名[];
注意：这两种定义做完了，数组中是没有元素值的。
2.3 数组的初始化
2.3.1 数组初始化概述：
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
2.3.2 数组的初始化方式
2.3.2.1 动态初始化:初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：
int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
2.3.2.2 案例代码三:
```java
package com.itheima_01;
/*
* 数组：存储同一种数据类型的多个元素的容器。
*
* 定义格式：
* A:数据类型[] 数组名;
* B:数据类型数组名[];
* 举例：
* A:int[] a; 定义一个int类型的数组，数组名是a
* B:int a[]; 定义一个int类型的变量，变量名是a数组
*
* 数组初始化：
* A:所谓初始化，就是为数组开辟内存空间，并为数组中的每个元素赋予初始值
* B:我们有两种方式对数组进行初始化
* a:动态初始化只指定长度，由系统给出初始化值
* b:静态初始化给出初始化值，由系统决定长度
*
* 动态初始化：
* 数据类型[] 数组名 = new 数据类型[数组长度];
*/
public class ArrayDemo {
public static void main(String[] args) {
//数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr = new int[3];
/*
* 左边：
* int:说明数组中的元素的数据类型是int类型
* []:说明这是一个数组
* arr:是数组的名称
* 右边：
* new:为数组分配内存空间
* int:说明数组中的元素的数据类型是int类型
* []:说明这是一个数组
* 3:数组的长度，其实就是数组中的元素个数
*/

}
}
```

2.3.2.3 静态初始化:初始化时指定每个数组元素的初始值，由系统决定数组长度
2.3.2.4 案例代码四:
```java
package com.itheima_01;
/*
* 静态初始化的格式：
* 数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
*
* 简化格式：
* 数据类型[] 数组名 = {元素1,元素2,...};
*
* 举例：
* int[] arr = new int[]{1,2,3};
*
* 简化后：
* int[] arr = {1,2,3};
*/
public class ArrayDemo2 {
public static void main(String[] args) {
//定义数组
int[] arr = {1,2,3};

//输出数组名和元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
```
2.4 数组的内存分配
2.4.1 JVM内存划分
Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈存储局部变量
堆存储new出来的东西
方法区 (面向对象进阶讲)
本地方法区 (和系统相关)
寄存器 (给CPU使用)

2.4.2 一个数组的内存图
定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素
2.4.2.1 案例代码五:
```java
package com.itheima_01;
/*
* 需求：定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。
*/
public class ArrayTest {
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[3];

//输出数组名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

//给数组中的元素赋值
arr[0] = 100;
arr[2] = 200;

//再次输出数组名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
```
2.4.2.2 代码内存图解:

2.4.3 两个数组的内存图
定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素
2.4.3.1 案例代码六:
```java
package com.itheima_01;
/*
* 需求：定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。
*/
public class ArrayTest2 {
public static void main(String[] args) {
//定义两个数组
int[] arr = new int[2];
int[] arr2 = new int[3];

//分别输出数组名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);

System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);

//然后分别给数组中的元素赋值
arr[1] = 100;

arr2[0] = 200;
arr2[2] = 300;

//再次输出数组名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);

System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}
```
2.4.3.2 代码内存图解:

2.4.4 两个数组指向同一个地址的内存图
定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素
2.4.4.1 案例代码七:
```java
/*
* 需求：定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
* 然后给第二个数组赋值，再次输出两个数组的名及元素。
*/
public class ArrayTest3 {
public static void main(String[] args) {
// 先定义一个数组，赋值，输出
int[] arr = new int[3];
arr[0] = 100;
arr[1] = 200;
arr[2] = 300;
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

// 然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组
int[] arr2 = arr;
// 然后给第二个数组赋值
arr2[0] = 111;
arr2[1] = 222;
arr2[2] = 333;

// 再次输出两个数组的名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}
```
2.4.4.2 代码内存图解:

2.5 数组的使用
2.5.1 数组的元素访问
2.5.1.1 案例代码八:
```java
package com.itheima_01;
/*
* 数组：存储同一种数据类型的多个元素的容器。
*
* 定义格式：
* A:数据类型[] 数组名;
* B:数据类型数组名[];
* 举例：
* A:int[] a; 定义一个int类型的数组，数组名是a
* B:int a[]; 定义一个int类型的变量，变量名是a数组
*
* 数组初始化：
* A:所谓初始化，就是为数组开辟内存空间，并为数组中的每个元素赋予初始值
* B:我们有两种方式对数组进行初始化
* a:动态初始化只指定长度，由系统给出初始化值
* b:静态初始化给出初始化值，由系统决定长度
*
* 动态初始化：
* 数据类型[] 数组名 = new 数据类型[数组长度];
*/
public class ArrayDemo {
public static void main(String[] args) {
//数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr = new int[3];
/*
* 左边：
* int:说明数组中的元素的数据类型是int类型
* []:说明这是一个数组
* arr:是数组的名称
* 右边：
* new:为数组分配内存空间
* int:说明数组中的元素的数据类型是int类型
* []:说明这是一个数组
* 3:数组的长度，其实就是数组中的元素个数
*/`

System.out.println(arr); //[I@3fa5ac,地址值
//我们获取到地址值没有意义，我要的是数组中的数据值，该怎么办呢?
//不用担心，java已经帮你想好了
//其实数组中的每个元素都是有编号的，编号是从0开始的，最大的编号就是数组的长度-1
//用数组名和编号的配合我们就可以获取数组中的指定编号的元素
//这个编号的专业叫法：索引
//格式：数组名[编号] -- 数组名[索引]
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
```
2.5.2 数组使用的两个小问题
2.5.2.1 案例代码九:
```java
package com.itheima_02;

/*
* 两个常见小问题：
* A:java.lang.ArrayIndexOutOfBoundsException
* 数组越界异常
* 产生的原因：就是你访问了不存在的索引元素。
* B:java.lang.NullPointerException
* 空指针异常
* 产生的原因：数组已经不指向堆内存的数据了，你还使用数组名去访问元素。
* 为什么我们要记住这样的小问题呢?
* 编程不仅仅是把代码写出来，还得在出现问题的时候能够快速的解决问题。
*/
public class ArrayDemo {
public static void main(String[] args) {
// 定义数组
int[] arr = { 1, 2, 3 };

//System.out.println(arr[3]);

//引用类型：类,接口,数组
//常量：空常量 null，是可以赋值给引用类型的
//arr = null;
System.out.println(arr[1]);
}
}
```
2.6 一维数组练习
2.6.1 一维数组遍历
2.6.1.1 案例代码十:
```java
package com.itheima_03;

/*
* 需求：数组遍历(依次输出数组中的每一个元素)
* 获取数组中元素的个数：数组名.length
*/
public class ArrayTest {
public static void main(String[] args) {
// 定义数组
int[] arr = { 11, 22, 33, 44, 55 };
// 原始做法
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println("--------------------");

// 用for循环改进
for (int x = 0; x < 5; x++) {
System.out.println(arr[x]);
}
System.out.println("--------------------");

//为了解决我们去数数组中元素个数的问题，数组就提供了一个属性：length
//用于获取数组的长度
//格式：数组名.length
System.out.println("数组共有："+arr.length+"个");
System.out.println("--------------------");

for(int x=0; x<arr.length; x++) {
System.out.println(arr[x]);
}
}
}
```
2.6.2 数组操作之获取最值:

2.6.2.1 案例代码十一:
```java
package com.itheima_03;
/*
* 需求：数组获取最值(获取数组中的最大值最小值)
*/
public class ArrayTest2 {
public static void main(String[] args) {
//定义数组
int[] arr = {12,98,45,73,60};

//定义参照物
int max = arr[0];

//遍历数组，获取除了0以外的所有元素，进行比较
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}
System.out.println("数组中的最大值是："+max);
}
}
```
2.7 二维数组
2.7.1 二维数组概述
我们黑马程序员的Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。这个也应该用一个数组来存储。如何来表示这样的数据呢?Java就提供了二维数组供我们使用。
由此可见：其实二维数组其实就是一个元素为一维数组的数组。

2.7.2 二维数组格式
定义格式
数据类型[][] 数组名;
数据类型数组名[][]; 不推荐
数据类型[] 数组名[]; 不推荐
初始化方式
数据类型[][] 变量名 = new 数据类型[m][n];
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

2.7.2.1 案例代码十二:
```java
package com.itheima_04;

/*
* 二维数组：就是元素为一维数组的数组。
*
* 定义格式：
* A:数据类型[][] 数组名;
* B:数据类型数组名[][]; 不推荐
* C:数据类型[] 数组名[]; 不推荐
*
* 如何初始化呢?
* A:动态初始化
* 数据类型[][] 数组名 = new 数据类型[m][n];
* m表示这个二维数组有多少个一维数组
* n表示每一个一维数组的元素有多少个
* B:静态初始化
* 数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},{元素...},...};
* 简化格式：
* 数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
*/
public class ArrayArrayDemo {
public static void main(String[] args) {
// 数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

System.out.println(arr); // [[I@104c575
System.out.println(arr.length); // 二维数组中的一维数组的个数
System.out.println(arr[0]);// [I@3fa5ac
System.out.println(arr[0].length);
System.out.println(arr[1]);// [I@95cfbe
System.out.println(arr[2]);// [I@179dce4

//我如何获取到一个二维数组的元素呢?
System.out.println(arr[0][0]);
System.out.println(arr[1][1]);
System.out.println(arr[2][0]);
}
}
```
2.7.3 二维数组的遍历
遍历思想:首先使用循环遍历出二维数组中存储的每个一维数组,然后针对每个遍历到的一维数组在使用循环遍历该一维数组中的元素
2.7.3.1 案例代码十三:
```java
package com.itheima_04;

/*
* 二维数组遍历
*
* System.out.println():输出内容并换行
* System.out.print():输出内容
* System.out.println():换行
*/
public class ArrayArrayTest {
public static void main(String[] args) {
// 定义二维数组
int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

// 二维数组中的一维数组名称：二维数组名[索引]
// arr[0] 其实就是二维数组中的第一个一维数组的名称
// arr[1] 其实就是二维数组中的第二个一维数组的名称
// arr[2] 其实就是二维数组中的第三个一维数组的名称

// for (int x = 0; x < arr[0].length; x++) {
// System.out.println(arr[0][x]);
// }

// System.out.println("hello");
// System.out.println("world");
// System.out.print("hello");
// System.out.print("world");

/*
// 第一个一维数组的元素
for (int x = 0; x < arr[0].length; x++) {
System.out.print(arr[0][x] + " ");
}
System.out.println();

// 第二个一维数组的元素
for (int x = 0; x < arr[1].length; x++) {
System.out.print(arr[1][x] + " ");
}
System.out.println();

// 第三个一维数组的元素
for (int x = 0; x < arr[2].length; x++) {
System.out.print(arr[2][x] + " ");
}
System.out.println();
*/

// for(int y=0; y<3; y++) {
// for (int x = 0; x < arr[y].length; x++) {
// System.out.print(arr[y][x] + " ");
// }
// System.out.println();
// }

for(int y=0; y<arr.length; y++) {
for (int x = 0; x < arr[y].length; x++) {
System.out.print(arr[y][x] + " ");
}
System.out.println();
}

}
}
```
## 第05天 java基础知识
今日内容介绍
 方法的概述及基本使用
 方法的练习及注意事项
 方法的重载及参数传递
 方法的操作数组的练习
### 第1章方法的概述及基本使用
1.1 方法定义格式及格式解释
1.1.1 方法的概述
假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要发射炮弹时调用该方法即可
简单的说：方法就是完成特定功能的代码块
在很多语言里面都有函数的定义 , 函数在Java中被称为方法
1.1.2 方法格式
修饰符返回值类型方法名(参数类型参数名1，参数类型参数名2…) {
方法体;
return 返回值;
}
1.1.3 方法格式解释
修饰符目前记住 public static
返回值类型用于限定返回值的数据类型
方法名一个名字，为了方便我们调用方法
参数类型用于接收调用方法时传入的数据的类型
参数名用于接收调用方法时传入的数据的变量
方法体完成功能的代码
return 结束方法，把返回值带给调用者
1.1.4 案例代码一
```java
package com.itheima_01;

/*
* 方法：就是完成特定功能的代码块。
*
* 定义格式：
* 修饰符返回值类型方法名(参数类型参数名1,参数类型参数名2...) {
* 方法体;
* return 返回值;
* }
* 格式解释：
* A:修饰符目前记住 public static
* B:返回值类型用于限定返回值的数据类型
* C:方法名一个名字，为了方便我们调用方法
* D:参数类型用于接收调用方法时传入的数据的类型
* E:参数名用于接收调用方法时传入的数据的变量
* F:方法体完成功能的代码
* G:return 结束方法，把返回值带给调用者
*
* 方法的两个明确：
* A:返回值类型明确功能结果的数据类型
* B:参数列表明确有几个参数，以及参数的类型
*
* 案例：
* 求两个数和的案例。
*/
public class MethodDemo {

}
```
1.2 求和方法的编写
1.2.1 定义方法注意事项
写一个方法首先有两点需要明确
返回值类型明确功能结果的数据类型
参数列表明确有几个参数，以及参数的类型
按照格式和两个明确来完成如下功能
1.2.2 案例代码二
```java
/ *
* 方法的两个明确：
* A:返回值类型明确功能结果的数据类型
* B:参数列表明确有几个参数，以及参数的类型
*
* 案例：
* 求两个数和的案例。
*/
public class MethodDemo {
/*
* 写一个方法，用于求和。两个明确：返回值类型 int 参数列表 int a,int b
*/
public static int sum(int a, int b) {
// int c = a + b;
// return c;

return a + b;
}

public static void main(String[] args) {

}
}
```
1.3 求和方法的调用
有明确返回值的方法调用：
单独调用，没有意义
输出调用，有意义，但是不够好，因为我不一定非要把结果输出
赋值调用，推荐方式
1.3.1 案例代码三
```java
package com.itheima_01;
/*
* 有明确返回值的方法的调用：
* A:单独调用,没有什么意义。
* B:输出调用,有意义,但是不够好，因为我可能需要对求和的结果进行进一步的操作
* C:赋值调用
*/
public class MethodDemo2 {
// 求和的方法
public static int sum(int a, int b) {
return a + b;
}

public static void main(String[] args) {
// 单独调用
// sum(10,20);

// 输出调用
// System.out.println(sum(10,20));

// 赋值调用
int s = sum(10, 20);
// s+=100;
System.out.println("s:"+s);
}
}
```
1.4 求和方法的调用图解
1.4.1 方法调用流程图

### 第2章方法的练习及注意事项
2.1 方法的练习
2.1.1 方法练习之获取两个数据中的较大
2.1.2 案例代码四
```java
package com.itheima_01;

import java.util.Scanner;

/*
* 需求：键盘录入两个数据，返回两个数中的较大值
*
* 两个明确：
* 返回值类型：int
* 参数列表：int a,int b
*/
public class MethodTest {
// 返回两个数中的较大值
public static int getMax(int a, int b) {
if (a > b) {
return a;
} else {
return b;
}
}

public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);

//接收数据
System.out.println("请输入第一个数据：");
int x = sc.nextInt();

System.out.println("请输入第二个数据：");
int y = sc.nextInt();

//调用方法
int max = getMax(x,y);
System.out.println("max:"+max);
}
}
```
2.1.3 方法练习之比较两个数据是否相等
2.1.4 案例代码五
```java
package com.itheima_01;

import java.util.Scanner;

/*
* 需求：键盘录入两个数据，比较两个数是否相等
*
* 两个明确：
* 返回值类型：boolean
* 参数列表：int a,int b
*/
public class MethodTest2 {
//比较两个数是否相等
public static boolean compare(int a,int b){
if(a==b){
return true;
}else {
return false;
}
}

public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);

//接收数据
System.out.println("请输入第一个数据:");
int a = sc.nextInt();

System.out.println("请输入第二个数据:");
int b = sc.nextInt();

//调用方法
boolean flag = compare(a,b);
System.out.println("flag:"+flag);
}
}
```
2.1.5 方法练习之获取三个数据中的较大值
2.1.6 案例代码六
```java
package com.itheima_01;

import java.util.Scanner;

/*
* 需求：键盘录入三个数据，返回三个数中的最大值
*
* 两个明确：
* 返回值类型：int
* 参数列表：int a,int b,int c
*/
public class MethodTest3 {
// 返回三个数中的最大值
public static int getMax(int a, int b, int c) {
if (a > b) {
if (a > c) {
return a;
} else {
return c;
}
} else {
if (b > c) {
return b;
} else {
return c;
}
}
}

public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);

//接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();

System.out.println("请输入第二个数据：");
int b = sc.nextInt();

System.out.println("请输入第三个数据：");
int c = sc.nextInt();

//调用方法
int max = getMax(a,b,c);
System.out.println("max:"+max);
}
}
```
2.1.7 void修饰的方法的调用
写一个方法，在控制台输出10次HelloWorld案例。
没有明确返回值的函数调用：
其实就是void类型方法的调用
只能单独调用
2.1.8 案例代码七
```java
package com.itheima_02;
/*
* 需求：写一个方法，在控制台输出10次HelloWorld案例。
*
* 两个明确：
* 返回值类型：void
* 参数列表：无参数
*
* 如果一个方法没有明确的返回值类型，java提供了void进行修饰。
*
* void修饰的方法的调用：
* A:单独调用
*/
public class MethodDemo {
//在控制台输出10次HelloWorld案例。
public static void printHelloWorld() {
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
}

public static void main(String[] args) {
//单独调用
printHelloWorld();

//输出调用
//System.out.println(printHelloWorld());
//System.out.println(void);

//赋值调用
//void v = printHelloWorld();
}
}
```
2.1.9 打印1到n之间的数据
2.1.10 案例代码八
```java
package com.itheima_02;
/*
* 需求：写一个方法，传递一个整数(大于1)，在控制台打印1到该数据的值。
*
* 两个明确：
* 返回值类型：void
* 参数列表：int n
*/
public class MethodTest {
//在控制台打印1到该数据n的值
public static void printNumber(int n) {
for(int x=1; x<=n; x++) {
System.out.println(x);
}
}

public static void main(String[] args) {
printNumber(10);
System.out.println("-------------------");
printNumber(100);
}
}
```
2.1.11 打印所有的水仙花数
2.1.12 案例代码九
```java
package com.itheima_02;
/*
* 写一个方法，把所有的水仙花数打印在控制台
*
* 两个明确：
* 返回值类型：void
* 参数列表：无参数
*/
public class MethodTest2 {
//把所有的水仙花数打印在控制台
public static void printFlower() {
for(int x=100; x<1000; x++) {
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;

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

public static void main(String[] args) {
printFlower();
}
}
```
### 第3章方法的重载及参数传递
3.1 方法重载的概述和基本使用
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
方法重载特点
与返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法
3.1.1 案例代码十
```java
package com.itheima_03;

/*
* 方法重载：在同一个类中，出现了方法名相同的方法，这就是方法重载。
* 方法重载特点：
* 方法名相同，参数列表不同。与返回值无关。
* 参数列表不同：
* 参数的个数不同。
* 参数对应的类型不同。
* 注意：
* 在调用方法的时候，java虚拟机会通过参数列表的不同来区分同名的方法。
*/
public class MethodDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;

// 求和
int result = sum(a, b);
System.out.println("result:" + result);

int c = 30;
// 求和
//int result2 = sum2(a,b,c);
//System.out.println("result2:"+result2);
result = sum(a,b,c);
System.out.println("result:"+result);
}

//两个float类型的数据求和
public static float sum(float a,float b) {
return a + b;
}

// 三个整数的求和
public static int sum(int a,int b,int c) {
return a + b + c;
}

/*
public static int sum2(int a, int b, int c) {
return a + b + c;
}
*/

// 两个整数的求和
public static int sum(int a, int b) {
return a + b;
}
}
```
3.2 方法重载练习
3.2.1 方法重载练习之比较数据是否相等
3.2.2 代码案例十一
```java
package com.itheima_03;

/*
* 需求：比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，
* 并在main方法中进行测试
*/
public class MethodTest {
public static void main(String[] args) {
// 调用
System.out.println(compare(10, 20));
System.out.println("-------------");
System.out.println(compare((byte)10, (byte)20));
System.out.println("-------------");
System.out.println(compare((short)10, (short)20));
System.out.println("-------------");
//System.out.println(compare((long)10, (long)20));
System.out.println(compare(10L, 20L));
}

// 两个byte类型的
public static boolean compare(byte a, byte b) {
System.out.println("byte");
// 第一种写法
// boolean flag = a==b?true:false;
// return flag;
// 第二种写法
// boolean flag = a == b;
// return flag;
// 第三种写法
return a == b;
}

// 两个short类型的
public static boolean compare(short a, short b) {
System.out.println("short");
return a == b;
}

// 两个int类型的
public static boolean compare(int a, int b) {
System.out.println("int");
return a == b;
}

// 两个long类型的
public static boolean compare(long a, long b) {
System.out.println("long");
return a == b;
}
}
```
3.3 方法中参数传递
3.3.1 方法的形式参数为基本数据类型
方法的参数是基本类型的时候：
形式参数的改变不影响实际参数。
形式参数：用于接收实际数据的变量
实际参数：实际参与运算的变量
3.3.2 代码案例十二
```java
public class ArgsDemo {
public static void main(String[] args) {
// 定义变量
int a = 10;
int b = 20;
System.out.println("a:" + a + ",b:" + b);// a:10,b:20
change(a, b);
System.out.println("a:" + a + ",b:" + b);// a:10,b:20
}

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

}
```

3.3.3 方法的形式参数是基本类型图解

3.3.4 方法的形式参数为引用数据类型
3.3.5 代码案例十三
```java
package com.itheima_04;

/*
* 方法的参数是引用类型：
* 形式参数的改变直接影响实际参数
*/
public class ArgsDemo2 {
public static void main(String[] args) {
// 定义数组
int[] arr = { 1, 2, 3, 4, 5 };
// 遍历数组
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
System.out.println("----------------");
change(arr);
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
}

public static void change(int[] arr) {
for (int x = 0; x < arr.length; x++) {
// 如果元素是偶数，值就变为以前的2倍
if (arr[x] % 2 == 0) {
arr[x] *= 2;
}
}
}
}
```
3.3.6 方法的形式参数是引用类型图

### 第4章方法的操作数组的练习
4.1 方法操作数组练习
4.1.1 方法的练习之数组遍历
需求：把遍历数组改进为方法实现，并调用方法
4.1.2 代码案例十四
```java
package com.itheima_05;

/*
* 需求：把遍历数组改进为方法实现，并调用方法
*/
public class MethodTest {
public static void main(String[] args) {
// 定义数组
int[] arr = { 11, 22, 33, 44, 55 };

// 遍历
// for (int x = 0; x < arr.length; x++) {
// System.out.println(arr[x]);
// }

//用方法改进
//printArray(arr);

//这一次虽然可以，但是我觉得格式不好看，能不能打印成下面的格式呢?
//[元素1, 元素2, 元素3, ...]
printArray(arr);
}

public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++){
if(x==arr.length-1){
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}

/*
* 两个明确：
* 返回值类型：void
* 参数列表：int[] arr
*/
// public static void printArray(int[] arr) {
// for(int x=0; x<arr.length; x++){
// System.out.println(arr[x]);
// }
// }
}
```
4.1.3 方法的练习之数组获取最值
需求：把获取数组最值改进为方法实现，并调用方法
4.1.4 代码案例十五
```java
/*
* 需求：把获取数组最值改进为方法实现，并调用方法
*/
public class MethodTest2 {
public static void main(String[] args) {
// 定义数组
int[] arr = { 34, 67, 10, 28, 59 };

//获取数组中的最大值
// //定义参照物
// int max = arr[0];
// //遍历，依次比较，大的留下来
// for(int x=1; x<arr.length; x++) {
// if(arr[x] > max) {
// max = arr[x];
// }
// }

//用方法改进
int max = getMax(arr);
System.out.println("max:"+max);

//获取数组中的最小值，用方法实现
int min = getMin(arr);
System.out.println("min:"+min);

}

//获取数组中的最小值的方法
public static int getMin(int[] arr) {
int min = arr[0];

for(int x=1; x<arr.length; x++) {
if(arr[x] < min) {
min = arr[x];
}
}

return min;
}

/*
* 两个明确：
* 返回值类型：int
* 参数列表：int[] arr
*/
public static int getMax(int[] arr) {
int max = arr[0];

for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}

return max;
}
}
```
4.1.5 方法的练习之数组元素求和
需求：写一个方法，用于对数组进行求和，并调用方法。
4.1.6 代码案例十六
```java
package com.itheima_05;

/*
* 需求：写一个方法，用于对数组进行求和，并调用方法。
*/
public class MethodTest3 {
public static void main(String[] args) {
// 定义数组
int[] arr = { 1, 2, 3, 4, 5 };

// //定义求和变量
// int sum = 0;
// //获取数组中的每一个元素
// for(int x=0; x<arr.length; x++) {
// sum += arr[x];
// }

//用方法改进
int sum = sum(arr);

System.out.println("sum:"+sum);
}

/*
* 两个明确：
* 返回值类型：int
* 参数列表：int[] arr
*/
public static int sum(int[] arr) {
int sum = 0;

for(int x=0; x<arr.length; x++) {
sum += arr[x];
}

return sum;
}
}
```

笔记整理1----Java语言基础（一）01 变量与数据类型+02 运算符与表达式+03 条件判断与循环语句+04 JAVA数组+05 函数与方法

猜你喜欢