疯狂java讲义--李刚 上课笔记之欧阳体创编

第一章到第十二章
day01Java开发前奏（第1章）
IT行业
硬件
- 各种硬件，技术含量越高，价格越贵。

软件
- 看不到，摸不着。

软件比硬件值钱得多！！！
iPhone 5 - 5000
制造成本400块——其他在品牌，在软件。

美国几乎不造硬件——硬件不如软件挣钱。

程序——软件的核心部分
程序：当我们要做一件事情时，需要按一种既定的流程、步骤，依次完成每个过程，
——最后结果就出来了。

真正的程序员，会影响他的生活习惯，做所有事情，都会有计划，有步骤。

计算机程序：驱动机器去为我们按既定流程、步骤去完成某件事情。

=======计算机是很蠢的！它只会按我们规定的步骤去做事
=======
Java能做什么？
1. 做桌面软件。

——针对个人。

Java在桌面软件领域、并不流行。

MS，win8向“移动操作系统”转型。

2. 大型信息化系统。

（Java最擅长）——针对企业。

taobao（阿里软件）、各种银行系统、证券、电信、移动……
3. 移动互联网软件。

——针对个人。

Android
编程语言的运行机制
程序：驱动机器去为我们按既定流程、步骤去完成某件事情。

能直接驱动计算机的——机器指令。

（难度非常大）
→ 汇编→ 高级语言（C、Java……）
高级语言编程：源代码就像“作文”一样，容易编写。

但高级语言的源代码，机器看不懂，但人容易看懂、容易编写。

学编程的所有工具安装准则：
1. 不要安装在有空格的路径下。

2. 不要安装在有中文的路径下。

（1）安装JDK.
（2）既然要使用Java开发，经常需要使用javac、java命令。

执行计算机命令的两个方法
A。

每次运行命令时，都输入该命令的绝对路径。

——可行，坏处是麻烦。

B。

告诉系统，总是到某些目录下去找命令。

这就需要PATH环境变量：它的值是N条路径。

中间以分号隔开。

用于告诉操作系统，以后操作系统要找命令时，就依次在这N条路径中找，
如果找到了，操作系统就执行这些命令。

如果没找到，操作系统就提示：“不是内部或外部命令，也不是可运行的程序”
PATH环境变量的作用：告诉【操作系统】到哪些路径下去找【命令】。

/*******************
绝对路径：以盘符开始的路径，就是绝对路径。

c:\abc\t.txt
相对路径：不以盘符开始的路径，就是相对路径。

abc\t.txt
*******************/
/**********
启动dos窗口，运行→ cmd
打开“快速编辑模式”，即可用“右键”完成复制、粘贴。

cd 路径进入指定路径。

特殊路径：
\ 根路径。

. 当前路径。

>符号前的就是当前路径。

.. 上一级路径。

dir: 列出该路径下的所有文件和目录。

切换盘符：直接输入盘符:即可。

**********/
Java程序的最小程序单元：类。

要定义类
[修饰符] class <类名>
{
}
[修饰符] ，只能是public。

Java程序，如果要运行，必须有个入口方法：main方法：public static void main(String[] args)
{
}
Java源文件的命名规则：
1. 文件名必须以.java为后缀
2. 如果源文件中定义了public修饰的类，主文件名必须与类名相同。

一个Java源文件，可以包含多个类定义。

但一个Java源文件最多只能包含一个public修饰的类。

编译Java程序的命令：
javac -d 目录源文件的文件名
指定将生成的新文件放在哪里。

javac生成的新文件名的命名规则：类名.class
（每个类，对应一个class文件）
运行Java程序的命令：
java 类名
关于CLASSPATH环境变量的解释：
1. CLASSPATH环境变量可以不设置。

2. CLASSPATH环境变量的作用？
CLASSPATH环境变量的作用：告诉【JVM】到哪些路径下去找【类】。

CLASSPATH环境变量的值，依然是N条路径，路径之间用分号隔开。

3. 如果你不设置CLASSPATH环境变量，相当于CLASSPATH的值是一个点（.）
如果你设置CLASSPATH环境变量，记得要加上一点（.）。

Java程序的注释：
注释的作用：给人（包括自己）看的。

注释：对程序本身，不存在任何影响。

建议：总是为程序添加合适的注释。

注释：还可用于调试程序，可以把程序中某段代码先注释掉。

对于程序员来说，还有一个更重要的能力：排错。

1. 先多遇到错误，多解决错误。

2. 常见的错误，记下来引起错误的原因。

注释分为3种：
单行注释：//
多行注释：/* */
文档注释：/** */
——它可用于生成API文档。

作业：
10个类，分别在屏幕上打印不同的形状：三角形、正方形、长方形……
day02数据类型与运算符（第3章）
Java语言的运行机制：
它既想吸收编译型语言的速度快的优点，又想吸收解释型语言“跨平台”的优点
它变成了一个“既需【编译】（平台无关的字节码文件）、又需要JVM的【解释】”的语言。

Java语言的程序，速度快，而且能跨平台。

编译Java程序的命令：
javac -d <目录> 源文件的路径
运行Java程序的命令：
java 类名
只要做Java开发，javac、java这两个命令是必需的。

是由Oracle的JDK所提供的。

SDK(Software Develop Kits)
JDK (Java 的SDK)
开发Java之前的准备：
（1）安装JDK。

Java for Developer（JDK）JRE + 各种编译工具。

Java for Your Computer（JRE）
JRE （Java的Runtime Enviorment）＝JVM + 基础类库、程序
（2）由于我们需要使用javac、java命令。

如果不配置环境变量，每次使用javac、java命令时，都需要输入命令的绝对路径。

可以配置PATH环境变量，它的值是N条路径（以;隔开），以后你输入任何命令时，操作系统都会在PATH所指定的系列路径中搜索。

Java程序的最小结构单元：类。

面向对象。

【C程序的最小结构单元：函数。

面向过程】
写Java程序，定义类：
[修饰符] class <类名>
{
// 入口方法、开始点
public static void main(String[] args)
{
// 执行性代码
System.out.println();
}
}
注释：
1. 单行注释。

//
2. 多行注释。

/* */
3. 文档注释。

/** */
文档注释的作用：
javadoc可以直接提取源代码中文档注释，生成对应的【API文档】。

何为API文档？
当我们写了一些类之后，应该为这些类编写“使用说明书”。

javadoc命令：程序员只要在源代码中添加文档注释，javadoc就可以为提取注释，生成使用说明书【API文档】。

API文档
包列表区| 详细说明区
---------|
类列表区|
文本编辑器：notopad、vim（最老牌、经典文本编辑工具）、ultraedit、editplus。

生成API文档的步骤：
（1）在源代码中添加文档注释。

文档注释必须添加在类、方法、field、内部类之前才有效。

——如果你把文档注释放在其他地方，它只能多行注释。

（2）使用javadoc命令：
javadoc -d <路径> 源文件
变量
－编程就要操作数据。

数据就要放在“东西”中。

－变量的作用：“装”一切的数据。

通俗理解：可以把变量理解成“瓶子”。

－变量需要有个名字（标识符）。

通过该名字即可访问变量
分隔符：
所有的符号，都是英文符号。

空格、花括号、[] 、() .
标识符：（identifier）
名字
－只能由于字母（包括中文字符）、数字、下划线、$组成，其中数字不能开头。

－标识符不能是Java的关键字或保留字。

关键字：
48个。

2个保留字：（goto、const）——现在还没有使用，也许以后会用。

3个直接量：true、false、null。

就是值。

这53个都不能作为标识符。

Java语言是“强类型”的语言：
－所有变量，必须先声明（声明时就必须指定类型）、后使用。

－“什么样的瓶子只能转什么东西”，指定类型的变量，只能装相应类型的值。

Java的数据类型可分为2大类：
－基本类型。

－引用类型。

整型（byte、short、int、long)
↗
浮点型(float、double)
↗
基本类型→ 字符型（char）
↘
布尔型（boolean）只有2个值：true、false
整型：
byte（1个字节(byte)=8个位(bit)）
8个bit表示2的8次方种状态。

因此一个bit只能表示256个数。

byte的取值范围：-128~0~127
short（2个字节(byte)=16个位(bit)）
16个bit表示2的16次方种状态。

能表示65536个数。

short的取值范围：-32768~0~32767
int （4个字节(byte)=32个位(bit)）
int的取值范围：负的2的31次方~0~2的31次方-1 long （8个字节(byte)=64个位(bit)）
long的取值范围：负的2的63次方~0~2的63次方-1 /**********************
2的10次方：1024 －1K
2的20次方：1M(百万)
2的30次方：1G（十亿）
2的40次方：1T
***********************/
1. 当我们直接给出一个整数值时，它默认是int型。

系统绝不会把它当成long处理。

2. 当我们直接给出一个在指定取值范围内的整数时，系统也可把它当成byte、short使用。

3. 如果你系统把一个整数当成long使用，应该在整数后添加l或L。

数值的下划线用法。

可以在数值中任意添加下划线（_）作为分隔符。

整数一共支持4种表示形式：
10进制值。

默认。

16进制Ox或0X开头0～9、a、b～f(15)
8进制O开头0~7
2进制b或B开头0~1
123 1 * 【进制】的2次方+ 2 * 【进制】的1次方+ 3 * 【进制】的0次方。

0x1a = 1 * 16的1次方+ a * 16的0次方= 26
整数不能除以0，否则会引发“算术异常：ArithmeticException”
浮点型：
float ：4个字节，32位。

double：8个字符，64位。

带小数的数值，就是浮点型。

－当你直接给出一个带小数的数值时，它默认是double 型。

如果希望当成float使用，应该在数值后添加f或F。

－浮点数支持2种形式：
－给出带小数的数。

－科学计数法。

2.11133E3
－浮点型有3个特殊值：
正无穷大Infinty 正数除以0，得到无穷大。

● 所有正无穷大都相等。

负无穷大-Infinity 负数除以0，得到无穷大。

● 所有负无穷大都相等。

非数NaN : 0 除以0，对负数开方等。

非数与任何数都不相等，包括它自己！
字符型
char
Java用就是Unicode字符集
字符型占2个字节，16位，65536种状态。

－字符型也可以当成无符号整型（0～65535）（每个字符都有编号）用。

－字符型的值，应该用单引号引起来。

（双引号引起来的是字符串）。

－字符型有3种形式：
A。

'字符'
B。

转义字符。

'\n' '\t' P50的表3.2
C。

直接用字符的Unicode编号。

布尔型
boolean
它只有两个值：true、false。

数值型：byte、short、int、long、char、float、double
↗
基本类型
↘
布尔型：boolean
/****************************************
字符集
计算机底层、内存中都无法记录字符，它们只能记录010101这种二进制位。

但我们有字符需要保存到计算机中，计算机科学家想了一个办法，给字符编号
计算机底层使用、保存这些字符时，其实用的的这些字符的编号。

——如果给所有字符都编号，这就叫字符集。

所谓字符集：就是给所有字符编个号。

字符集：保存（写入）文件、恢复（读取）文件用的字符集要一致。

ASCII －每个字符占一个字节，8bit，总共能表示256个字符。

A（65）－Z（65+25）
a（97）－z（97+25）
0（48）－9（57）
GB2312
GBK
GB18030
Unicode ：16位、能表示65536个字符。

utf-8、utf-16。

编程：建议使用utf-8字符集。

*****************************************/
▲ 类型转换
☆自动转换
取值范围小的类型，可以自动转换为取值范围大的类型。

(-128~127) (-32768~32767) (-20亿～20亿)
byte → short → int → long → float → double
↗
char
(0~65535)
－所有数值型，都可自动转换为double。

－所有整型，都可自动转换为long。

－所有整型，都可自动转浮点型。

☆强制转换。

当数值类型之间，不能自动转换时就需要进行强制转换。

强制转换的语法格式是：(类型)
【注意】，强制转换，可能会溢出。

/***********************************
数值的表示形式：
最高位是符号位，0代表正数；1代表负数。

原码－直接换算得到的2进制码。

反码－把原码，除符号位之外，其他位取反得到反码。

补码－正数的补码就是源码；负数的补码为反码+1
计算机底层，所有数值都用补码表示。

************************************/
随机的图形验证码
（1）只要生成一个97～122（汉字的范围）之间的随机整数（2）将随机整数，强转为char——这就是随机字符。

Math类：所有与数学计算相关的算法，都提供了相应的方法。

表达式类型的自动提升
所谓表达式：用运算符，将多个变量、值，串联成“四则混合运算”。

一个表达式，最终也会计算出一个结果，该结果的数据类型，
与整个表达式中等级最高的操作数的数据类型相同。

▲ 直接量
直接量，就是在源代码中直接给出的值。

int：20、0x12 、12、012
long：1L、23L
float：2.4f
double 2.3 3e2
char：'1' 、'\u2331'
boolean：true 、false
String："helloworld"
▲ 运算符
☆算术运算符：
+ ：加法运算符，也是连接运算符。

- ：减法运算符。

* ：乘法运算符。

/ ：除法
% ：取余。

++ ：必须操作【一个】【变量】，让变量的值加1
-- ：必须操作【一个】【变量】，让变量的值减1
++ 如果放在变量的前面，是先将变量加1，再用加1后的值；
如果放在变量的后面，是先用变量原始的值；将变量加
1。

-- 如果放在变量的前面，是先将变量减1，再用减1后的值；
如果放在变量的后面，是先用变量原始的值；将变量减1。

☆赋值运算符
=
☆位运算符
& ：按位与——当上下两位都是1，计算结果才是1.
| ：按位或——当上下两位都是0，计算结果才是0；只要有任何一个是1，结果就是1。

^ ：按位异或——当上下两位不同，计算结果才是1.
~ ：按位取反（按位非）。

直接取反——只要一个运算数即可。

>>：右移，右边移出去的位，将会被直接“砍掉”，左边空出来的位补符号位。

右移N位，相当于除以2的N次方。

<<：左移，右边空出来的位就会添加0；
左移N位，相当于乘以2的N次方。

>>>：无符号右移，右边移出去的位，将会被直接“砍掉”，左边空出来的位总是补0。

移出来的结果总是正数。

练习：
画出下面计算结果的过程
-12 & 34
(byte)234;
-3^34
20 | -124
~45
day03流程控制和数组（第4章）
数据类型与运算符
Java数据类型可分为2大类：
- 基本类型
- 引用类型
基本类型
A。

整型byte short int long
有4种表示形式：
10进制、8进制（以0开头）、16进制（以0X或0x开头）、2进制（以B或b开头、Java 7才支持）
B。

浮点型。

float（4个字节）、double（8个字节）
直接给出小数，默认是double类型；如果希望一个数字是float类型，需要添加f/F作为后缀。

C。

字符型。

字符型可以当成无符号整型使用（0～65535)
字符型有3种表示形式：
- 直接给出单个字符'A'
-转义字符。

- '\uXXXX'，用4位的16进制的Unicode值。

D。

布尔型。

true、false
另外一种分类规则：
A。

数值型：byte、short、int、long、char、float、double B。

布尔型：boolean
7个数值型之间可以相互转换，
- 自动转换：取值范围小的、向取值范围大的转换，就可自动转换。

byte → short → int → long → float → double
↗
char
- 强制转换：不能自动转换时，就需要进行强制转换。

语法格式是：(类型)
【强制转换可能导致溢出！！！！！！】
运算符：
算术运算符：+ - * % / ++ --
赋值运算符：=
位运算符：& | ^ ~ >>(左边高位补符号位，右移N位相当于除以2的N次方)、<<（左移N位相当于乘以2的N次方）、>>>
▲ 扩展后的赋值运算符：
所有【双目】运算符，都可以与=结合，结合成为扩展的赋值运算符。

a +=
b 相当于 a = (a的类型)(a + b)
a -= b
...
a &= b
▲ 比较运算符
比较运算符，返回的结果是true或false
> >= < <= == !=
【比较运算符的返回值总是boolean值！】
▲ 逻辑运算符
逻辑运算符的作用是：对两个boolean值进行逻辑运算。

逻辑运算符，只能对boolean值进行运算。

&& ：与。

当两个操作数都是true时、才返回true。

&: 不短路与。

|| ：或。

当两个操作数只要有一个是true时、就会返回true。

|：不短路或
!：非：它是单目的。

相当于取反。

^：异或。

当两个操作数相同时，结果就会返回false。

&&与&的区别何在？
对于“求与”来说，当第一个操作数已经是false时、结果肯
定是false，第二个操作数根本不会影响结果。

&&，根本不会去计算第二个操作数。

&，它依然会去计算第二个操作数。

||与|的区别何在？
对于“求或”来说，当第一个操作数已经是true时、结果肯定是true，第二个操作数根本不会影响结果。

||，根本不会去计算第二个操作数。

|，它依然会去计算第二个操作数。

▲ 三目运算符
boolean表达式？value1 : value2
当boolean表达式返回true，整个表达式返回value1；否则，就返回value2
▲ 运算符的结合性与优先级
运算符有优先级，一共分成10多个级别的优先级。

参看P67.
规则：尽量多用()来保证哪些东西先算。

▲ 流程控制
目前，最主流、最常用的3种流程：
1. 顺序。

从上到下、依次执行每条代码。

如果没有流程控制，默认就是顺序结构。

在顺序结构中，如果后面代码得到了执行，表明前面代码已经执行完成。

2. 分支。

根据条件来执行执行代码。

if语句。

if语句的语法格式：
㊀
if(<逻辑表达式>)
｛
// 执行语句
｝
｛｝括起来的部分，称为“条件执行体”。

㊁
if(<逻辑表达式>)
{
// 执行语句
}
else
{
// 执行语句
}
㊂
if(<逻辑表达式>)
{
// 执行语句
}
else if(<逻辑表达式>) else if块可出现0～N 次。

{
// 执行语句
}
else else块可出现0～1次
{
// 执行语句
}
★if分支语句的注意点：
A. 如果if后的条件执行体只有一行代码，可以省略条件执行体的花括号。

如果if后省略花括号，if条件只控制到紧跟该if语句的第一个分号。

建议：总是保留条件执行体的花括号。

B. else包含了一个隐含的条件：该条件就是对前面条件取反。

建议：当有if...else if...时候，应该先判断【范围小】的条件。

Java 7增强后switch语句，
语法格式是这样的：
switch(<表达式>）// 此处的表达式可以是byte、short、char、int、String（Java7）、枚举
{
case 值1: case块可出现1～N次
break;
case 值2：
break;
case 值3：
break;
default: //
}
Java会去计算<表达式>的值，如果表达式的值与后面指定case的值相同时，就会进入执行对应的case代码块。

switch允许省略case块的break;
如果switch省略了case后面break后，从第一个能进入的case块开始，然后一直执行每个case块的代码（此时根本不判断case后的值），此时根本不会判断case后的值。

3. 循环（回圈）
控制程序将一段多次重复执行。

★ while循环
while(<逻辑表达式>)
{
// 循环体
}
每次进入循环体之前，会先去判断<逻辑表达式>，如果<逻辑表达式>返回true，就会进行循环体。

只要逻辑表达式为true，就会一直重复执行循环体。

当<逻辑表达式>为false时，此时就会跳出循环（执行循环体花括号后面的代码）。

<逻辑表达式>的执行次数= 循环体的执行次数+ 1
【注意：】如果while循环的循环体只有一行代码，可以省略循环体的花括号。

如果省略了while循环体的花括号，while只控制紧跟while的第一个分号。

【练习】用星号打印三角形
*
***
*****
*******
*********
***********
高：N
一共要打印6 行。

结论：每行打印的空格数：高度- 行数
每行打印的*数：2 * 行数- 1
★ do while循环
do
｛
// 循环体
}while(<逻辑表达式>);
先执行循环体，然后再去判断逻辑表达式，如果逻辑表达式为true，执行下一次循环。

- 即使逻辑表达式开始就是false，循环体也会执行一次。

do while循环的循环体至少会执行一次。

- 循环体的执行次数= 逻辑表达式的执行次数。

★ for循环
- 【语法更简洁】。

- 【内聚性更好】。

for(初始化语句; 逻辑表达式; 迭代语句)
{
// 循环体
}
◆初始化语句：仅在循环开始之前，执行一次！
◆逻辑表达式：每次进行循环体之前，都要先判断逻辑表达式的值。

当逻辑表达式返回true，就会进行循环体。

如果逻辑表达式返回false，跳出循环。

逻辑表达式的执行次数= 循环体的执行次数+ 1◆迭代语句：每次循环体执行完之后、判断循环条件之前，会自动执行迭代语句。

迭代语句的执行次数= 循环体的执行次数
可以用while循环来改写for循环，改写后为如下形式：
初始化语句
while (逻辑表达式)
{
// 循环体
迭代语句
}
【注意点】
- 如果在循环体中修改循环计数器的值，循环体的执行次数可能会发生变化。

- for循环中，只有两个分号是必须的。

如果没有逻辑表达式，相当于逻辑表达式总是true。

- for循环的初始化语句，可以一次声明多个变量。

这多个变量的类型必须相同。

/****** 死循环：无限循环*******/
课堂练习：打印99乘法表
1 * 1 = 1
1 *
2 = 2，2 * 2 = 4
1 * 3 = 3，
2 *
3 = 6 , 3 * 3 = 9
1 * 9 9 * 9 = 81
结论：
- 总共打印MAX_NUM行
- 每行要打的token数量= 行数
▲ 控制循环结构：
break - 跳出一个循环。

直接调到循环体的后一条代码。

即使是死循环，我们也可以使用break来跳出循环。

★默认情况，break只是跳出它所在的循环。

循环可以带标号——所谓标号，就是为循环起个名字。

标号的语法格式为：标识符: ——这就是为循环起了个名字。

★如果在break后添加标签，可以直接跳出标签代表的循环。

continue - 忽略本次循环剩下的语句、重新开始下一次循环。

结论：如果一个【不带标号】的continue语句，而且它是循环体的最后一条语句，这个continue语句没有作用。

★默认情况，continue只是忽略它所在的循环的剩下语句。

★如果在continue后添加标签，可以直接忽略标签所代表循环的剩下语句。

return - 可用于结束一个方法。

return 无论它在多深的嵌套循环中，只要遇到return语句，它会结束方法，整个循环将会完全结束。

1. 找出2000以内的所有“水仙花”数字
找出2000以内所有
各位的数值的立方的和= 该数本身。

比如：153 = 1 + 125 + 27
2. 打印圆
（对于有难度，就做将三角形再打个反向，就成了菱形）**
*************
*****************
*****************
*****************
************
day04流程控制和数组（第4章）**
Java的流程控制
第一种：顺序结构
如果我们要做的一件事情，本身是从上到下、按既定的步骤
依次执行，
此时就可考虑使用顺序结构。

编程思路：我要的事情，可定义为一个一个小任务，接下来就将每条任务都翻译为相应程序代码。

第二种：分支结构
如果我们要做的事情，要根据具体的条件来决定是否执行。

此时就可考虑使用分支结构。

Java的分支结构有两种：
★ if
if(条件)
{
// 条件执行体
}
else if( 条件) ——它可以出现0～N次
{
// 条件执行体
}
...
else ——它可以出现0～1次
{
// 条件执行体
}
1. 当条件执行体只有一行代码时，程序可以省略条件执行体的花括号。

省略花括号之后，if只控制到紧跟它的第一个分号。

2. else本身就是一个条件。

else相当于是对前面的条件取反。

经验：当有多个else if块，你应该先去处理范围小的条件。

★ switch
switch(表达式）// 表达式的类型可以byte\short\char\int\String(Java 7)\枚举
｛
case 值1: ——可出现1～N次。

// 执行代码
break;
case 值2:
// 执行代码
break;
default: ——隐含条件是：表达式的值不等于前面任意一个值
｝
【注意点：】
如果省略了break，流程会从第一个能进入的case块开始，依次向下执行每个case块，根本不会比较case后面的值，——直到遇到break为止。

第二种：循环结构
如果有一件事情，需要多次重复执行，
此时就考虑使用循环结构。

Java的循环结构，一共有3种：
while(条件)
{
// 循环体
}
条件的计算次数= 循环体的执行次数+ 1
【注意点：】
当循环体只有一行代码时，程序就可以省略循环体的花括号。

如果省略了循环体的花括号，while只控制到紧跟它的第一个分号。

do
｛
// 循环体
｝while(条件)
即使条件开始就是false，循环体也会执行一次，循环体至少会执行一次。

for(初始化语句; 条件; 迭代语句)
{
// 循环体
}
初始化语句，只在循环开始之前执行一次。

条件，每次进入循环体之前，先要计算条件为true或false。

当条件为true时，才能进入循环体；为false将不能进入循环体。

条件的执行次数= 循环体的执行次数+ 1
迭代语句，每次循环体执行完之后，程序就会执行迭代语句。

迭代语句总是放在循环体之后执行。

▲ 数组：
变量- 程序中需要保存数据时，就可考虑使用变量来装数据。

变量，需要指定类型、名字。

数组- 当程序中有N个数据类型完全相同的变量时，此时就可考虑使用一个数组来代替这个N个变量。

当有一个数据需要保存时，就考虑使用变量；当有N个数据需要保存时，就考虑使用数组。

Java数据类型：
- 基本类型：8个。

- 引用类型：数组类型，类，接口。

8个基本类型、String。

★数组就是一种类型。

int → int[] (数组类型)
String → String[] （数组类型）
int[] → int[][] （数组类型）
int[][] → int[][][] （数组类型）
★定义数组变量的语法，应该是标准写法
int[] 变量名
String[] 变量名
早期定义数组变量的语法是：
int 变量名[]; ——这个写法几乎被淘汰了，
★数组类型的变量，只是一个引用变量。

定义数组变量，仅仅只是定义了一个指针。

何为引用变量、何为指针
1. 基本类型的值，需要的空间是固定。

2. 引用类型的值，需要的空间是不确定。

当我们把数据存在计算机的内存中之后，每个内存位都有自己的编号，
可以额外定义一个变量，该变量保存数组所在内存的编号。

——这种变量就叫“指针”。

引用变量, 本质就是指针。

但它是一个包装后、功能被限制、更安全的指针。

引用变量、存放的是内存编号。

引用变量所占的内存空间是确定、受平台所控制的。

定义数组变量时，数组本身并没有出现。

★创建数组（数组初始化）
new ——新建
几乎所有东西，都可以new出来。

创建数组的两种语法：
静态：
new 类型[] {元素1, 元素2 , 元素3 ...};
1. 程序员不指定长度。

2. 只列出元素的值；由系统来动态判断数组的长度。

动态：
new 类型[长度];
1. 程序员只指定长度。

2. 不给出数组元素的值，而是由系统地为每个元素分配元素值。

系统为数组元素分配值的规则为：
1. 所有整型，初始值都为0；
2. 所有浮点型，初始值都是0.0
3. 所有字符型，初始值都是'\u0000'
4. boolean型，初始值是false
5. 所有引用类型，初始值都是null
★使用数组：
1. 数组有一个length属性，用于返回该数组的长度。

2. 每个数组元素，相当于一个类型为数组类型去掉【一组】【方括号】的变量。

可通过数组变量[索引] 可代表数组元素，功能上相当于变量。

使用数组中两个常见的错误：
- 如果使用数组元素时，指定的索引值大于或等于length，将会引发ArrayIndexOutOfBoundsException。

- 当数组变量并未真正指向有效的数组时，，无论访问数组长度、还是访问数组元素时，都将引发NullPointException
★ for each循环
专门用于遍历数组、集合的元素
// 该循环的执行次数= 数组的长度
for(数组|集合【元素】的类型变量: 数组变量|集合变量)
{
// 在该循环体内，上面的变量将会依次等于每个数组元素的值。

}
很明显：for each循环，遍历数组时更加简洁。

foreach循环遍历数组时，一个最大的限制是：【在foreach。