前言
因为前面的本人Java基础在别的博客上写了但是，博客园不支持【那个】博客搬家，所以就那这个记录一下Java基础
Java 入门
Java简史
1991年，Gree项目，开发语言最初命名为Oak(橡树)
1996年，发布JDK1.0
2004年，发布里程碑式版本，JDK 1.5，为此突破版本的重要性，更名 JDK 5.0.
2014年，发布JDK 8.0，是继JDK 5.0以来变化的版本
常用的 Windows--DOS命令
ws的DOS命令，其实是Windows系统的cmd命令，它是由原来的MS-DOS系统保留下来的。
MS-DOS称为微软磁盘操作系统，最开始从西雅图公司(蒂姆·帕特森)买过来
MS-DOS系统一般是需要使用命令行界面接收用户指令
DOS命名执行一般是需要借助于CMD控制台执行，我们可以通过win+R来调出运行窗口
Windows常用的DOS指令
记事本 notepad
计算器 calc
图画 mspaint
任务管理器 taskmgr
注册表编辑器 regedit
控制面板 control
命令行提示符 cmd
设备管理 devmgmt.msc
磁盘管理 diskmgmt.msc
常用的cmd命令
java -version 查看java版本
cd 切换目录
cd.. 切换上一级目录
tree 以树形状展示文件目录
exit 退出cmd命令
cd 目录路径 进入到某个目录中
路径：
绝对路径：是以盘符为开头的 C:/XX
相对路径：是以当前目录为参照的路径
D:或者E: 盘符切换
cls 清屏
dir 查看当前目录下的文件
md或者mkdir 创建目录
rd或者rmdir (remove director)删除目录
ren或者rename 重命名某个文件或者文件夹
copy 复制某个文件
move 剪切某个文件
tab 补齐功能，如果名字有重复，就不再提示
cd> 在某个路径下面创建一个文件
cd 进入盘符根目录
shotdown /s 关闭计算机
shotdown /r 完全关闭计算器，并重启
adapter /all 显示完整配置信息
net start 查看当前开启哪些服务
net start ServiceName（服务名称） net命令加上参数可以启动服务程序
net stop ServiceName（服务名称） 停止服务程序
echo ...... > A.txt 重定向输出，此时创建文本文件A.txt;
cd> A.txt 创建文本文件
配置环境变量：
右键电脑属性，高级系统设置，环境变量，系统环境变量选择新建，
变量名：JAVA_HOME 变量值：(JDK安装的位置不包含bin目录)
选择新建，变量名：CLASSPATH 变量值：.;%JAVA_HOME%ilb
找Path，新建 %JAVA_HOME%in 然后确定即可
Helloword代码了解
//文件的名称和类名称需要完全一致(单行注释)
/*(多行注释)
代码的第一行：public class HelloWord
public 公共的，开放的 起到一个修饰的作用，修饰 HelloWord这个名字
class 类 作用是声明类的作用
HelloWord 类的名字
代码的第二行：public static void main(String [] args)
public 公共的，开放的 起到一个修饰的作用，修饰 main这个名字
static 静态的 起到一个修饰的作用，修饰main这个名字
void 空的没有的 结果值
main() 方法名字 方法的名字就叫main (程序的入口)
String[] String 字符串 [] 数组
args 参数名字 args
代码的的第三行：System.out.println("hello word");
system 系统
out 向外，往外，输出
println (print 打印 ln 换行)打印换行
"hello world" 打印的内容
*/
public class HelloWorld{
public static void main(String [] args){
System.out.println("今天是我学习Java的第一天，好开心啊！");
}
}
运行java文件出现cmd出现编码GBK的不可映射字符解决
记事本打开，文件，另存为，然后编码选择ANSI，确定，保持即可。
ANSI 代表系统当前的字符集 会切换系统当前默认的字符集。
ANSI 使一种字符代码，能够识别不同国家的计算机语言，如果把文件的编码字符集设定为ANSI，那么它会根据当前执行的系统自动匹配系统默认的编码字符集。
如，在简体中文Windows系统中，当前系统使用的编码字符集就是GB2312，
在国际中，通用的编码字符集有三种较常用：ASCII、ANSI和Unicode
jdk和jre的关系：
关键字
//具有特殊含义，被保留的，不能随意使用的字符，这样的字符我们就称为关键字
添加注释
注释就是对代码的解释说明，其目的就是其他开发者能轻松的了解代码。注释是不影响程序的编译和运行。
java中的注释有三种
//单行注释
/*多行注释*/
/**文档注释*/
标识符
标识符：一般是指程序中，我们自定义的内容。比如说类的名字(HelloWord)，方法的名字(main),变量的名字等等，都是表示符。
标识符的命名规则：
标识符可以包含英文字母26个(区分大小写)，0-9数字，_(下划线)，$(美元符)。
标识符不能以数字开头。
标识符不能是关键字。
命名规范：软性建议
建议类名首字母大写，后面的每个首字母建议大写(大驼峰命名法)。
方法名首字母小写，后面的每个单词建议大写(小驼峰命名法)。
变量名一般是全部小写。
标识符见名知意的效果。
常量
常量：在程序运行期间，固定不变的量。
常量中字面常量可以直接应用，而符号常量必须先声明。在程序执行过程中常量保持不变，任何尝试修改常量的操作都会使程序报错。
常量的分类：
1.字符串常量:凡是是用双引号引起来的部分，就叫做字符串常量。 "今天是我学习Java的第一天"
2.整数常量:直接写上的数字，没有小数点。如18 20 -3。
3.浮点数常量(小数):直接写上的数字，有小数点。如 3.14 0.0 。
4.字符常量:凡是单引号引起来的单个字符，就叫做字符常量。 如 '男' '女'。
5.布尔常量:只有 true 和 false。
6.空常量: null(没有任何数据，在内存中不存在)。 空常量不能直接用来直接打印输出口的。
变量
变量：在程序运行期间，内容可以发生变化的量。
变量必须先定义（声明）后引用。变量可以通过赋值来改变值。
数学中，3+5=8 --> x+5=8
在程序中，可以使用字母保存数字的方式，提高计算能力，可以解决更多的实际问题。如 x保存3 也可x 保存5，x保存数字(数据)是可以发生改变的，我们一般称这个x为变量。
备注：Java中，一个变量只能保存一个数据。而且要明确保存的数据类型。
注意：
变量没有赋值是不能使用的
变量的作用域问题
变量的重复定义
变量的定义：
变量定义具备三元素：数据类型，变量名，数据值
格式：
变量的数据类型 变量名 = 变量值
定义变量的注意事项
使用变量的时候，需要注意的事项如下：
1.创建多个变量的时候，变量必须先声明，后使用，变量之间的名称不可以重复。
2.对于float和long类型来说，变量的数据类型后面需要添加字母F和L。
3.如果使用byte或者是short类型的变量，那么右侧的数据值不能超过左侧类型的范围。
4.没有进行赋值的变量，不能直接使用，能够使用的变量一定义经过初始化的(赋值)。
5.变量的使用不能超过它对应的作用域。
6.可以通过一个语句来创建多个变量，但是不建议使用。
7.变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了，同一个作用域内，不可以声明两个同名的变量
作用域 ---》{ (左半部分代表作用域的起始位置) } (右半部分代表作用域的结束位置)
变量的使用不能超过作用域的范围
数据类型
分类：
基本类数据类型 ：如 整数 浮点数 字符 布尔
引用数据类型 ： 如 类 数组 接口 字符串
基本的数据类型
计算机基础知识：
二进制：计算机中的数据全部采用的是二进制数表示，只包含0，1连个数，封二进一，1+1=10，
每一个1或者0，叫做bit(比特) 位。
字节：
字节称为我么计算机中最小的存储单位。计算机中存储的任何的数据，都是以字节的形式存储的1个字节=8个比特(二进制位) 0000-0000表示一个字节，写成1byte 或者1B
8bit=1B
1024B=1KB
1024KB=1MB
1025MB=1GB
1024GB=1TB
1024TB=1PB
1024PB=1EB
1024EB=1ZB
四类八种数据类型：
| 数据类型 | 关键字 | 内存大小 | 取值范围 |
|---|---|---|---|
| 字节型 | byte | 1个字节 1B | -128~127 2^7-1 |
| 短整型 | short | 2个字节 2B | -32768~32767 2^15-1 |
| 整形 | int | 4个字节 4B | 21开头的十位数 -231~231-1 |
| 长整型 | long | 8个字节 8B | -263~263-1 |
| 单精度浮点数 | float | 4个字节 4B | -1.4013E-45~3.4028E+38 |
| 双精度浮点数 | double | 8个字节 8 | 4.9E-324~1.977E+38 |
| 字符型 | char | 2个字节 2B | 0~65535 |
| 布尔类型 | boolean | 1个字节 1B | true false |
转义字符
一些具有特殊含义的字符，通过""来进行转义
----> 一个制表符(占8位)一个tab缩进
----> 一个换行符 newLine()
----> 一个回车符 按一下enter键
----> 退格
数据类型之间的转换
Java程序中要求参与计算的数据，必须保证数据类型一致性，当数据类型不一致的时候，将会发生数据类型转换。
数据类型之间的转换分为两种
1.自动类型转换(隐式)：将取值范围小的类型自动提升为取值范围大的类型。
byte类型在内存中占一个字节，需要和int类型的变量做运算会自动提升为int类型，自动补充3个字节，计算的结果就是int类型。
1.特点：不需要通过代码进行处理，程序内部会自动
2.
2.强制类型转换(显示)：将取值范围大的类型强制转换为取值小的类型的范围。
格式：数据类型 变量名 =(数据类型) 被转换类型值;
1.特点：需要对代码进行特殊处理，程序不会自动完成。
2.格式：范围小的数据类型 范围小的变量名 = (范围小的数据类型) 原来范围大的数据;
强制类型转换的注意事项：
1.一般不推荐使用，因为可能发生精度损失，数据溢出。
2.byte/short/char 这三种数据类型在运算的时候，都会首先提升为int类型，然后再计算。
3.boolean类型不能发生数据类型转换。
4.char类型可以进行数学运算，列入：加法。char类型的数据转换为int类型是按照码表中对应的int值进行计算的。比如在ASCII码表中，'a'对应9
5.如果等号右边是两个常量再相加，程序内部会优化一个常量再进行赋值。
int a = 'a';
System.out.println(a); // 将输出97
//---------------------------------------------------------------------------------
byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
// 第三行代码会报错，b1和b2会自动转换为int类型，计算结果为int，int赋值给byte需要强制类型转换。
// 修改为:
int num = b1 + b2;
// 或者：
byte b3 = (byte) (b1 + b2);
ASCLL(美国信息交换标准代码)
数字和字符的对照关系表(编码表)
American Standard Code for Information
Unicode编码：万国码。也是数字和字符的对照关系表，开头0-127部分和ASCLL完全一样，但是从128开始，包含更多的字符。
需要记忆：
48 ---》'0'
57 ---》'9'
65 ---》'A'
90 ---》'Z'
97 ---》'a'
122 ---》'z'
在计算机内部采用的是二进制的方式，里面的数据都是二进制0,1格式，如何让计算机识别人类文字，就出现了编码表的概念。
编码表：就是将人类的文字和一个十进制数进行对应起来组成的一张表格。
将所有的英文字母，数字，符号，都和十进制数进行对应，产生了世界上第一张编码表(ASCLL)。
备注：
在char和int类型进行计算的过程中，char类型的字符会被转成int类型，需要查询编码表。
运算符
- 算数运算符
| 算数运算符 | 含义 |
|---|---|
| + | 加法运算，字符串拼接，整数 |
| - | 减法，负数 |
| * | 乘法运算，通配符 |
| / | 除法运算 求商数 |
| % | 除法运算 求余数 取模运算 |
| ++ | 自加一运算 |
| -- | 自减一运算 |
1.//(前)++ :先自增1，后运算
//(后)++ :先运算，后自增1
2.//(前)-- :先自减1，后运算
//(后)-- :先运算，后自减1
3.连接符：+：只能使用在String与其他数据类型变量之间使用。
-
比较运算符
比较运算符 含义 == 相等比较 < 小于比较 > 大于比较 >= 大于等于比较 <= 小于等于比较 != 不等于计较 1.比较运算符，运算的结果都是布尔类型值 true false 注意事项： 如果我么进行多次判断，不能连着写。 数学中，a>3 a>-1 -----> -1<a<3 在程序当中不允许这样操作。 2. > < >= <= :只能使用在数值类型的数据之间。 3. == 和 !=: 不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间。 -
赋值运算符
| 赋值运算符 | 含义 |
|---|---|
| = | 赋值 |
| += | 加等于 |
| -= | 减等于 |
| *= | 乘等于 |
| /= | 商等于 |
| %= | 模等于 |
重点掌握 = 基本的算术运算符
剩下的都是复合赋值运算符
只有变量才可以使用赋值运算符，常量不能进行赋值
复合赋值运算符其中隐含了一个强制类型的转换
运算的结果不会改变变量本身的数据类型
-
逻辑运算符
逻辑运算符 含义 && 短路与 同true则true，否则false；如果一边为false，结果就是false || 短路或 任意一边为true，则为true，否则为false ! 取反(取非) 如果为false，结果为true；反之则为false ^ 异或 相同false，异为true //逻辑运算符操作的都是boolean类型的变量。而且结果也是boolean类型 //区分& 与 && //相同点1：& 与 && 的运算结果相同 //相同点2：当符号左边是true时，二者都会执行符号右边的运算 //不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。 //开发中，推荐使用&& // 区分：| 与 || //相同点1：| 与 || 的运算结果相同 //相同点2：当符号左边是false时，二者都会执行符号右边的运算 //不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算 //开发中，推荐使用|| -
位运算符(操作的都是整形变量)
位运算计算机底层采用的是对整数二进制运算 [没有无符号左移运算符] 二进制：源码，补码，反码。操作符 描述 例子 ＆ 与运算。如果相对应位都是1，则结果为1，否则为0 5 & 3 = 1 | 或运算。如果相对应位都是 0，则结果为 0，否则为 1 5 | 3 = 7 ^ 异或运算。如果相对应位值相同，则结果为0，否则为1 5 ^ 3 = 6 ~ 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 ~6--->0110 = -7 << 按位左移运算符。左操作数按位左移右操作数指定的位数。(在一定范围内，每左移一位相当于在原来的基础上乘于2) 5 << 2 = 20 ---> 5 * 2^2 = 5 * 4 = 20 >> 按位右移运算符。右操作数按位右移右操作数指定的位数。(在一定范围内，每向右移1位，相当于/2) 5 >> 1 = 2 ---> 5 / 2^1 = 5 / 2 = 2 >>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 5 >>> 1 = 2---> 5 / 2^1 = 5 / 2 = 2 -
三目运算符
?:
格式：
布尔表达式?真的结果:假的结果;
计算方式：
如果布尔类型的表达式结果为true，三目运算符运算的结果为紧邻?后面的值
如果布尔类型的表达式结果为false，三目运算符运算的结果为紧邻:后面的值
备注：当三目运算符参与其他的运算(赋值运算)，要求三目运算符中的?和:后面的值的[数据类型要保持一致]。
流程控制语句
//顺序结构
/*
程序是从上往下进行加载，按照代码的编写进行执行的。
*/
//选择结构(分支结构)
/*
1.if 单只情况。
if语句的格式：
if(布尔类型表达式){
//代码块
}
if语句(单只)的执行流程：
首先判断布尔类型表达式看他的结果是false还是true
如果是true就执行{}里面的方法体里面的内容
如果是false就不执行{}里面的方法体内容，程序往后加载。
2.if else 多支情形。
格式：
if(布尔表达式){
//语句体内容1
}else{
//语句体内容2
}
if else 多支的执行流程：
首先判断布尔表示式看他的结果式true还是false
如果是true，就执行语句提内容1
如果是false，就执行语句体内容2
3.if ... else if ... else 语句。
格式：
if(布尔表达式){
//方法体内容1
}else if(布尔类型表达式2){
//方法体内容2
}
......
esle if(布尔表达式n){
//方法体内容n
}else{
//方法提内容n+1
}
执行流程：
首先判断布尔表达式1开其结果是true还是false
如果是true，就执行方法体内容1
如果是false，就继续判断布尔表达式2，看起结果是true还是false
如果是true，就执行方法体内容2
如果是false，就继续判断布尔表达式。。。。，看其结果是true还是false
。。。
如果以上所有的布尔表达式都为false，最后执行else{}里面的方法体内容n+1
4.if。。。if。。。else。。。else语句 嵌套情形
格式：
if(布尔类型表达式){
//方法体内容1
....
if(布尔类型表达式){
//方法体内容2
....
}else{
//方法体内容3
....
}
}else{
//方法体内容4
....
}
执行流程：
首先判断布尔类型表达式2.看其结果是true还是false
如果是true，就执行方法提内容1，再继续判断布尔表达式2，看起结果是false还是true，
如果是true，就执行方法体内容2.
如果是false，就执行方法提内容3.。。
如果是false，就执行方法提内容4，之后加载后面的程序
***if语句和三目运算符的互换
*/
int num01=10;
int num02=20;
int c;
if(num01>num02){
c=num01;
}else{
c=num02;
}
//修改为三目运算符
c=num01>num02?num01:num02;
//switch case 语句
switch 语句中的变量类型可以是： byte、short、int 或者 char。
从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。
/*
格式：
switch(表达式/变量){
case 常量值1:
//语句体1
break;
case 常量值2:
//语句体2
break;
。。。
default:
//语句体
break;//可以省略，但是不要省略
}
执行流程：
首先计算出表达式中的值
其次，依此和case后面的常量值作比较，一旦有对应的值，就会执行相应的语句体内容，
在执行过程中，遇到break就会结束switch case语句。
最后，如果所有的case都和表达式的值不匹配，就会执行default中的语句内容，然后switch case语句结束。
case穿透性
在switch语句中，如果case后面的break省略掉，将会出现穿透现象。不会判断后面的case情形值，直接加载case的方法体中大的内容，直到遇到break结束，没有的话执行default的内容。
*/
//循环结构【重点】
/*
三种基本循环 for while do-while
循环结构组成部分：一般可以分成4部分
初始换语句 ：在循环最初开始时，需要定义一个初始化的变量，而且只会定义一次。
条件判断(结束条件) ：如果条件成立满足，进入循环，如果条件不满足，则退出循环。
循环体内容 ：重复要做的事情内容，可能包含很多条语句(事情是有规律的)
迭代语句(步进语句) ：每次循环结束之后需要执行步进语句(迭代语句)，对初始换的变量作步进(迭代)。
for循环语句结构
格式：
for(1初始化; 2布尔表达式; 4迭代语句) {
//3循环体内容
}
初始化语句一定和条件判断表达式紧密结合。
迭代语句和条件判断表达式也是紧密结合。
迭代语句时对初始化语句中定义的变量迭代的。
执行流程：
1 2 3 4 2 3 4 2 3 4 ...2不满足为止。
1负责循环变量的初始化
2负责判断时候满足
*/
/*
while 循环语句
格式：
1.初始化语句
while(2.判断条件){
//3.循环提内容
//4.步进语句
}
执行流程：
1 2 3 4 2 3 4 2 3 4 ...2条件不成立
1负责循环变量初始化
2负责判断是否满足循环条件，不满足则跳出循环
3负责执行具体语句，实现某个功能
4迭代循环变量
*/
//do-while循环
/*
//1初始换语句
do{
//3.循环体内容
//4.迭代条件
}while(2.判断条件);
实行顺序： 1 3 4 2 3 4 2 3 4 2 ...2不满足为止
1负责定义循环变量，并且进行初始化
2负责判断是否满足循环条件，不满足则跳出循环
3负责执行具体的语句，实现某个功能
4迭代循环变量
备注：它会无条件的执行循环体内容，即使判断条件是不满足也依然循环一次，这样的循环是有风险的，不建议使用。
*/
/*
for 和 while 的区别
控制语句中所涉及到的循环变量，当for循环结束后，定义的循环变量不能被访问到，而while循环结束后依然可以被访问到。如果不继续使用循环变量，建议使用for循环，因为for循环结束后，循环变量就会从内存中消失，能够提高内存的使用效率。
在已知循环次数的情况下，建议使用for循环，当循环次数不确定时使用while循环。
*/
Scanner类和Random类的使用
API(Application Programming Interface) 应用程序编程接口，JavaAPI就是程序员的一本字典。
是JDK中提供给我们使用的类的说明文档。只需要查阅API搜索自己需要的类。
Scanner类Int
它是一个可以解析基本数据类型和字符串的文本扫描器。主要作用就是外部的数据录入到系统中。
Scanner sc = new Scanner(System.in);
//让系统能够录入一个整数 nextInt();
int num=sc.nextIne();
//备注：System.in 可以实现通过键盘录入一个数据。
//让系统能够实现从外部录入一个浮点数(小数)。nextDouble();
double num2=sc.nextDouble();
//让系统能够实现一个字符串数据。next(); nextLine();
String str=sc.next();
当你使用外面的其他类的时候，大多数情况是需要在本类做特殊声明需要把外面的其他类的路径导入到本类中。
导入声明的格式；
import 包名.类名;
java.util.Scanner;
import java.util.Scanner;
该导入声明语句类的上面
跳转语句 (break、continue)
break continue 两个语句
break：
break语句用于终止某个语句块的执行。
break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
continue：
continue只能使用在循环结构中
continue语句用于跳过其所在循环语句快的依次执行，继续下一次执行。
continue语句出现在嵌套的循环语句中体中时，可以通过标签指明要跳过的是那一层循环
标签退出:
label: 就是标签 要终止的位置
break label ：终止结束到标签 结束语句
continue label: 终止本次循环 跳到标签位置进行接下来的循环
标签语句必须和循环匹配使用，使用时书写在对应的循环语句的上面，标签语句以冒号结束。如果需要中断标签语句对应的循环，可以采用 break 后面跟标签名的方式。
注意：通常紧跟 break 之后的标签，必须在 break 所在循环的外层循环之前定义才有意义。
两者的区别
break只能用于switch语句和循环语句中。
continue 只能用于循环语句中。
二者功能类似，但continue是终止本次循环，break是终止本层循环。
扩展知识点：
1.死循环 ：循环中的条件永远都是true，死循环是永不结束的循环。死循环一般要和跳出语句结合。
2.循环嵌套 ：是指一个循环的循环体是另一个循环。
循环的次数=外部循环的次数*内部循环的次数。 外循环一次内循环多次。
数组
数组的定义和访问
容器的概念：
就是将多个数据存储到一起，每个数据称为该容器的元素。
生活中的容器：水杯，excel，教室
数组概念：
数组就是存储数据长度固定的容器，保证每个数据类型要一致。
数组的定义：
//格式1动态初始化：
数据类型 变量名;
变量名=new 数组存储大的数据类型[长度>=0的整数];
合成一步为：
//数组存储的数据类型[] 数组名称 =new 数组存储大的数据类型[长度>=0的整数];
解析：
数组的存储类型：决定了该数组容器能够存储什么样的数据。
[]: 表示是数组。
数组名称：给定义的数组起一个变量的名字，满足标识符的命名规范。
new：关键字，创建数组使用的关键字。
数组存储的数据类型：决定了数组容器能够存储什么样的数据。
[长度]：数组的长度，表示数组中能够存储多少个元素。
备注：数字一旦创建，长度不能发生改变，数据具备一个[定长特性]。
//格式2静态初始化：
方式1；
//数组的数据类型[] 数组名称 =new 数组的数据类型[]{元素1,元素2,元素3,...};
方式2：
//数组的数据类型[] 数组名称 ={元素1,元素2,元素3,...};
两种区别：
动态要指定长度，静态要指定内容。
备注：静态初始化虽然没有直接指定长度，但是程序会推算得到该数组的长度。
建议：
如果部确定数组当中存储的内容是，用动态初始化，反之内容已经确定了，使用静态初始化。大多是情况下，建议使用动态初始化。
数组的特点：
1.数组的长度在运行期间不可改变。
2.数组本身就是一种引用数据类型。
3.数组定义时是引用数据类型，但是数组容器里面的存储的元素可以是基本数据类型也可以是引用数据类型。
4.数组当中存储的多个数据，类型要保持一致。
数组初始化：当内存当中船舰了一个数组，并且向数组容器中赋予一些默认值。
默认值：
类型： 默认值：
整数型(int) 0
浮点数 0.0
字符型 'u0000'(空格)
布尔类型 false
引用类型 null
数组的访问
索引：角标，下表
每一个存储数组当中的元素，都会自动的分配一个编号，从【0】开始，这个系统自动分配的编号称为数组的索引(index),我们可以通过索引访问数组当中的元素。
格式：
数组名称[索引]
数组的长度属性
每个数组都有长度，而且是固定的，java会自动赋给数组一个属性，可以获取到数组的长度属性。
格式：
数组名称.length
属性length代表的就是数组的长度，int类型。数组的最大索引值为【数组名.length-1】。
索引访问数组当中的元素操作:
修改索引对应位置上的值：数组名[索引]=数值;
变量=数组名称[索引]; 从数组中当中取出一个数值给一个变量。
如果直接打印数组名称，得到的是一个内存的哈希值。
[I@i5db9742
数组原理内存图理解
内存:
内存是计算机中一个很重要的原件，临时存储区域，作用是当程序运行过中，我们编写的程序文件存放在硬盘当中，硬盘当中的程序文件不会运行，存放到内存当中，当程序运行完毕后程序会清空内存。
Java虚拟机当中的内存划分:
为了提高效率，就对内存空间进行不同区域的划分，每一篇区域都有特定的处理数据方式和内存管理方式
| 区域名称 | 作用 |
|---|---|
| 寄存器 | 给cpu使用，和我们开法没有关系 |
| 本地方法栈 | JVM在使用操作系统功能使用的，和我们的开发没有关系 |
| 方法区 | 存储可以运行的class文件(常量池，静态域) |
| 方法栈(stack) | 方法运行时使用的内存，比如说main方法运行，进行方法栈当中运行，(局部变量) |
| 堆内存(heap) | 存储对象或者数组，new出来的对象，都存储在堆内存当中 |
数组在内存当中的存储
一个数组的内存存储
public static void main(String[]args){
int [] arr=new int [3];
System.out.println(arr);
}
}
程序的执行流程：
main方法进入方法栈中执行
创建数组，JVM会在堆内存当中开辟空间，存储数组
数组在内存当中会有自己的内存地址，以16进制表示
数组当中有三个元素，默认值为0
JVM将数组的内存地址赋值给引用类型变量arr
变量arr保存的数组时在内存当中的地址，而不是一个具体的数值。
两个数组的内存分析图解
public static void main(String[]args){
int [] arr =new int [3];
int [] arr2 =new int [2];
System.out.println(arr);
System.out.println(arr2);
}
两个变量同时指向同一个数组
public static void main(String[]args){
//定义一个数组，动态初始化
int [] arr =new int [3];
//通过索引访问数组当中的元素
arr[0]=10;
arr[1]=10;
arr[2]=10;
//查看元素
System.out.println(arr[1]);//10
//定义一个数组，将上一个数组赋值该数组
int [] arr2=arr;
arr2[1] =50;
//查看元素
System.out.println(arr[1]);//50
}
数组的常见操作
数组的越界操作
public static void main(String[]args){
//定义一个数组，动态初始化
int [] arr =new int [5];
//访问索引值为5的数组元素
System.out.println(arr[5]);
//java.long.ArrayIndexOutOfBounds.java 数组下表越界异常
//数组的索引时从0开始的，最大索引是arr.length-1
//如果访问元素时，索引不在该区间中，程序就会抛出数组越界异常。
}
数组空指针异常
public static void main(String[]args){
//动态初始化一个数组
int arr new int[3];
arr=null;
//查看arr数组元素
System.out.println(arr[2]);ava.
//java.ArrayNu11PointerException 空指针异常
//数组空指针异常，就是程序运行过程中，有一个内存中有一个不存在的一个变量被引用到了
}
数组遍历【重点】
//数组遍历：就是将数组中的每一个元素分别获取取来，就是遍历，
//遍历使我们操作数组的核心和重点内容。
public static void main(String[]args){
//静态初始化一个数组
int[] arr={1,2,3};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
获取数组中的最大值
/*
数组的索引依此递增，递增到arr.length-1为止，引入循环结构
代码优化：
*/
for(int i=0;i<arr.lenght;i++){//遍历容器的时候，初始化语句中的循环变量一般都是索引值
System.out.print(arr[i]);
}
}
获取数组中的最大值
最大值：从数组的所有元素中找到最大值。
思路：
1.定义一个最变量，保存数组当中的第一个元素，
2.遍历数组，获取数组当中的每一个元素。
3.将遍历的元素和保存的最大变量进行比较。
4.如果数组元素的大于最大值变量，就是把元素赋值给最大值变量。
5.数组遍历结束，最大值变量保存的就是数组当中的最大值。
public static void main(String[]args){
//静态初始化一个数组容器
int []arr={45,12,74,45,6,100,45};
int max =arr[o];
for(int i=1;i<arr.lenght;i++){
//将遍历的元素和保存的最大变量进行比较
if(arr[i]>max){
//如果数组元素的大于max就交换为位置
max=arr[i];
}
}
//数组遍历结束，最大变量保存的变量就是数组当中的最大值
System.out.println("数组最大值为"+max);
}
数组的反转：
数组的反转：数组中的元素颠倒顺序。列如：原始数组为：1 2 3 4，反转之后，4 3 2 1
思路，本质就是考察交换两个变量，两种方式。
1.实现反转，就是需要将数组最远端的元素和最近端位置互换
2.定义两个变量，保存数组的最小索引和数组的最大索引
3.让两个索引上的元素交换位置
4.最小的索引变量++，最大的索引变量--，再次交换位置
5.最小的索引超过了最大索引停止交换
public static void main(String[] args){
int [] arr= {1,2,3,4,5,6};//定义一个需要反转的数组
//第一种
/*
int min = 0; //定义一个最小索引
int max = arr.length-1;//定义一个最大索引
for(min , max ; min < max ; min++ , max--){ //遍历数组让两个索引变化
//条件min<max ，就交换最小索引和最大索引，需要定义第三方变量
int temp = a rr[min];//把最小的索引赋值给第三方变量temp
arr [min] = arr[max];//把最大的索引元素赋值给最小的索引元素
arr [max] = temp;//把第三方变量的值赋值给最大索引的元素
}*/
//第二种
for(int i = 0 ; i < arr.length/2 ; i++ ){
//交换变量
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
//查看反转之后的内容
for(int num : arr){
System.out.print(num);
}
}
二维数组
定义方式：和一维数组一样的，也是有三种方式
//方式一 动态初始化
数组的数据类型[][] 数据名称=new 数据类型[长度1][长度2];
//【长度1不可以省略，代表该二维数组里面存储的元素个数】
// 长度2 可以省略，代表该数组里面的元素(数组里面的元素个数)，而且它里面的数组元素个数一样。
如：int[][] arr=new int[3][2];
长度2 该数组里面有3个元素(数组)
长度2 该数组里面的每个数组元素都有两个元素
相当于 int[][]arr={{0,0},{0,0},{0,0}};
//方式二 静态初始化
数组的数据类型[][] 数组名称=new 数组的数据类型[][] {{值1,值2...},{值1,值2...},...;
数组的数据类型[][] 数组名称={{值1,值2,...},{值1,值2,值3...},{}...};
//二维数组元素的访问方式： 借助于索引
格式：
数组名称[一维数组索引][一维数组的值索引];
int [][]arr={{12,32,43},{43,53,21,43},{53,64,765,53};
//arr[0][0] --->12
//arr[1][3] --->43
//arr[2][2] --->765
图解：
数组作为方法参数和返回值
数组可以作为引用类型作为方法的参数进行传递。
数组作为方法参数传递，传递的参数是数组内存地址。
数组作为方法的返回值
数组作为方法的返回值，返回的是数组的内存地址。
方法
概念：在程序中要去实现的某一个功能，需要包含多条语句，这些语句包含循环语句，选择语句结构等共同来处理的一件事情。
//方法的定义格式：
//修饰符：public static。
//返回值类型：void (方法最终产生的数据结果是什么样的)。
//方法的名称：方法的名字，名字自定义--标识符，采用小驼峰。
//参数：参数类型(进入方法中的数据是什么样的类型) 变量名(进入方法当中的数据对应的变量名称)
//return：一般认为有两个作用，第一可以将后面的返回值返回给程序;二停止当前的方法的执行。
//返回值：就是方法执行最终产生的数据结果。
备注:1.return后面的”返回值类型”必须和方法声明上的“返回值类型”保持一致。
2.方法不允许嵌套，不允许定义在类的外面。
3.方法只能并列，并且必须定义在类的里面。
修饰符 返回值类型 方法名 (参数类型1 参数名1...){
//代码块
}
三要素：方法名，返回值类型，参数列表
方法分为：
//无参，无返
//有参，无返
//无参，有返
//有参，有返
方法调用
三种调用格式；
1.单独调用：方法名称(参数具体值);
2.打印调用：System.out.println(方法名称(参数具体值));
3.赋值调用：数据类型 变量名 = 方法名称(参数具体值);
备注：当返回值类型为void的时候，这时候只能单独调用，不能打印或者赋值调用。
返回值类型一般理解为数据类型(基本和引用数据类型)，才外还包含一种类型void类型，当方法执行完毕不需要给程序调用者返回任何的数据结果时，可以指定该方法的返回值类型为void，此时只能单独调用。
注意事项：
//1.方法定义的先后顺序无所谓。
//2.方法定义不能嵌套，不能在一个方法内部定义另外一个方法。
//3.方法定义之后，自己不会执行；如果希望执行，一定要进行方法的调用。
方法重载(overload)
方法重载概念：
//在同一个类中方法名相同，只要它们的参数个数或者参数类型不同即可。
'两同一不同':同一个类，相同方法，参数列表不同(参数个数和类型)。
重载的特点：
//与返回值类型 形参变量名称 方法的修饰符 方法体没有关系
//只看参数列表，且参数列表必须不同(参数个数或参数类型)，参数的多类型顺序不同。调用时，根据方法参数列表的不同来区别。
public class AA{
public static int sum (int a,int b){
return (a+b);
}
public static double sum (double a,double b){
return (a+b);
}
如果在类中定义方法时，方法的参数不一致，虽然方法名称一样，但是程序会认为这是一个新方法。
}
/*一个方法可以有0，1多个参数，但是只能有1个或者0个返回值，不能有多个返回值。
如果我们希望一个方法当中产生了多个结果数据，这些多个结果同时需要返回
解决方案：使用一个容器(数组)作为方法的返回值类型即可。*/
return作用：
//第一个作用：终止当前执行的方法，for循环一般声明在方法内。
//第二个作用，可以返回方法的返回值，return语句声明在for循环结构中可以返回for循环结构之外数据值，方法声明格式为无返回值时，也可以使用return关键字，此时return后面不能跟具体的返回值，当程序加载到return语句时，不管return语句是否在for循环节后中，都会结束当前正在执行的方法，即结束方法内的for循环语句。
//值传递
public static void main (String[] args){
int a = 10;
int b = 20;
change(a,b);
System.out.println(a);//a=10
System.out.println(b);//b=20
}
public static void change(int a,int b){
a = a + b ;//a=30
b = b + a ;//b=50
}
//引用传递2
public static void main (String[] args){
int[] arr={10,20};
changeArray(arr);
System.out.println(arr[0]);//30
System.out.println(arr[1]);//50
}
public static void change(int[] arr){//传递的是地址
arr[0] = 30;
arr[1] = 50;
}
Java数值传递的时候，到底是引用传递还是值传递
java中既有引用传递也有值传递 ----》》方法形式参数上
//值传递，基本数据类型
值传递是：是把实参的值赋值给形参，那么对形参的修改，不会影响实参的值。
//引用传递：引用类型，数组，集合。
传地址：是传值的一种特殊方式，只是他传递的是地址，不是普通的int。那么传地址以后，形参和实参都指向同一个对象。
传引用：真正的以地址的方式传递参数，传递以后，形参和实参都是同一个对象，只是他们的名字不同而已，对形参的修改影响实参的值。
对于基本数据类型来说 “=”赋值操作是直接改变内存地址（存储单元）上的值。
对于引用类型来说 “=” 赋值操作是改变引用变量所指向的内存地址（上文中存储单元）。
总结：
'函数参数传递其实是一个赋值的过程，基本类型传递的是数值，引用类型传递的引用对象的内存地址。'
'另外一点要特别注意，函数的参数其实是函数内部的局部变量。不要跟外部变量混淆。'
错题总结
自增自减前后的顺序，单词的记忆，及时不会的就去复习。
- 大处着眼，小处着手。
- 逆性思维，反证法。
- 通过问题看本质。
两句话：
- 小不忍则乱大谋
- 识时务者为俊杰
预习面向对象，类与对象，封装，成员，局部变量，api，关键字，