Java基础语法
01_Java基础语法
day_01day01_前言、入门程序、常量、变量
1.编程语言
编程语言可分为3类：机器语言、汇编语言和高级语言。
- 机器语言:是用二进制代码表示的计算机能直接识别和执行的一种机器指令的集合。编出的程序全是些0和1的指令代码也成称为二进制代码。
- 汇编语言:汇编语言是使用一些特殊的符号来代替机器语言的二进制码，计算机不能直接识别，需要用一种软件将汇编语言翻译成机器语言。
- 高级语言：使用普通英语进行编写源代码，通过编译器将源代码翻译成计算机直接识别的机器语言，之后再由计算机执行。例如： C、C++、C#、JAVA
2.常用的DOS命令
命令 操作符号
盘符切换命令 盘符名:
查看当前文件夹 dir
进入文件夹命令 cd 文件夹名
退出文件夹命令 cd..
退出到磁盘根目录 cd\
清屏 cls
3.Java语言开发环境
-
JVM（Java Virtual Machine ）：Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java程序的 运行环境，是Java 最具吸引力的特性之一。我们编写的Java代码，都运行在 JVM 之上。
-
针对不同系统，Java有不同的虚拟机，
只需将编译过后的Class文件交给虚拟机即可
统上，这个特性称为Java语言的跨平台特性。该特性是由JVM实现的，我们编写的程序运行在JVM上，而JVM 运行在操作系统上。
-
JRE (Java Runtime Environment) ：是Java程序的运行时环境，包含 JVM 和运行时所需要的 核心类库 。
-
JDK (Java Development Kit)：是Java程序开发工具包，包含 JRE 和开发人员使用的工具。
我们想要运行一个已有的Java程序，那么只需安装 JRE 即可。
我们想要开发一个全新的Java程序，那么必须安装 JDK
4.Java程序开发
- 三步骤：编写、编译、运行。
-
Java程序运行流程（Java和Javac）
有一份.java源文件
通过Javac命令进行编译成为.class文件
通过java命令让虚拟机解释执行.class文件
5.添加注释comment
//单行注释
/*
*多行注释
*/
/**
*文档注释
*/
文档注释是java特有的注释，其中注释内容可以被JDK提供的工具Javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。可以使用Javadoc.exe命令生成API文档。
6.关键字Keywords
关键字：是指在程序中，Java已经定义好的单词，具有特殊意义。
特点：全部都是小写字母。
7.标识符
-
定义：是指在程序中我们自己定义的内容。比如类的名字、方法的名字和变量的名字等，都是标识符。
-
命名规则：硬性要求
- 标识符可以包含英文26个字母（区分大小写）、0-9数字、$(美元符号)和_（下划线）。
- 标识符不能以数字开头。
- 标识符不能是关键字。
- 严格区分大小写，应做到见名知意
-
命名规范：软性建议
-
类名规范：首字母大写，后面每个单词首字母大写（大驼峰）。如创建一个类
-
public class HelloWorld（）{} -
方法名规范：首字母小写，后边每个单词首字母大写（小驼峰）。如创建一个main方法和
-
public static void mina(String[] args){} -
变量名规范：全部小写。
-
常见命名规则：
- 包：
- 单级包：全部小写
- 多级包：全部小写，中间以 . 隔开
- 类与接口：大驼峰
- 一个单词：首字母大写
- 多个单词：每个单词的首字母大写
- 变量与方法：小驼峰
- 一个单词：首字母小写，其他单词首字母大写
- 常量：全部小写。
8.常量
定义：是指在java程序中固定不变的数据。
| 类型 | 含义 | 数据举例 |
|---|---|---|
| 整数常量 | 所有的整数 | 0,1,6,5,8,-6 |
| 小数常量 | 所有小数 | 0.0,0.3,-3.6,0.36 |
| 字符常量 | 单引号引起来,只能写一个字符,必须有内容 | '啊','d','.' |
| 字符串常量 | 双引号引起来，可以写多个字符，也可以不写 | “A” , "Hello","世界" ， " " |
| 布尔常量 | 只有两个值 | true，false |
| 空常量 | 只有一个值 | null |
9.变量和数据类型
- 变量：可以变化的量。
- 要求：每一个变量每次只能保存一个数据，必须要明确数据类型。
10.数据类型
基本数据类型加上[] 就变成引用数据类型
数据类型分类
java的数据类型分为两大类：
- 基本数据类型：包括整数、浮点数、布尔型、字符型
- 引用数据类型：类、接口、数组、字符串、Lambda
基本数据类型加个[] 就变成引用数据类型
四类八种
- 整数型 （取值范围）
- 字节型byte（1个字节)（-128~127） 短整型short（2个字节)（-32768~32767） 整形int（4个字节)（一般默认）（-21亿~21亿） 长整型long（8个字节)（ ）
- 浮点型
- float(单精度浮点数) （4个字节) double（双精度浮点数）（8个字节)（一般默认）
- 字符型
- char（字符型）（2个字节)
- 布尔型
- boolean（1个字节)（只有两个结果true或者false）
四类：整数类型、浮点类型、布尔型、字符型
八种：byte、short、int、lang
float、double
11.变量的定义
格式：数据类型 变量名称 = 数据值；
public class Variable{
public static void main(String[] args){
//定义字节型变量
byte b = 127;
System.out.println(b);
//定义短整型变量
short s = 32767;
System.out.println(s);
//定义整形变量
int i = 66666666;
System.out.println(i);
//定义单精度浮点数变量
float f = 6.6F;
System.out.println(f);
//定义双精度浮点型变量
double d = 6.56;
//定义布尔型变量
boolean bool = true；
System.out.println(bool);
//定义字符型变量
char c = 'A';
System.out.println(c);
}
}
注意事项：
- long类型：建议数据后加L表示。
- float类型：建议数据后加F表示。
- 变量名称：在同一大括号范围内，变量的名字不可以相同。
- 变量赋值：定义的变量，不赋值不能使用。
day02_数据类型转换、运算符、方法入门
第一节 数据类型转换
java程序中要求参与的计算数据，必须要保证数据类型的一致性，如果数据类型不一样将发生类型的转换。
1.1自动转换（是Java自动执行）
- 将取值范围小的自动提升为取值范围大的。
public static void main(String[] args){
byte b = 2;
int i = 1;
//byte x = b + i;
//int类型和byte类型运算，结果是int类型
int j = b+i;
System.out.println(j)
}
-
转换原理图解
- byte类型内存占有1个字节，int类型内存占4个字节，byte类型在和int类型运算时，自动补充3个字节，因此计算结果还是int类型的。
- 同样道理，当一个int类型变量和一个double变量运算时，int类型会自动提升为double类型进行运算。
public static void main(String[] args){
int i = 1;
double d = 3.6;
double e = i +d;
System.out.println(e);
}
-
转换规则
范围小的类型向范围大的类型提升，byte、short、char运算时会自动提升为int类型
byte、short、char-->int-->float-->double
1.2强制转换（是需要我们手动的）
-
强制类型转换：就是将范围大的类型自动转换为取值范围小的类型。
-
转换格式
数据类型 变量名 = （数据类型）被转数据值；
将1.5赋值给int类型，代码修改为：
//double类型转换为int类型,直接去掉小数点 int i = (int)1.5;
同样，当short类型与1相加的时候
public static void main(String[] args){
//short类型变量，内存中2个字节
short s = 1;
/*
出现编译失败
s和1做运算，1是int类型，s会被提升为int类型
s + 1后结果是int类型，将结果再赋值给s时会发生错误，因为s是short类型
short内存2个字节，int类型4个字节，必须将int强制转成short才能完成。
*/
s = s +1;//编译失败
s = (short)(s+1);//编译成功
}
强烈注意
-
浮点数转成整数，直接取消小数点，可能造成数据损失精度。
-
int强制转成short砍掉两个字节，可能造成数据丢失。
//定义s为short范围内最大值 short s=32767； s = (short)(s+10);
1.3ASCLL编码表
public static void main(String[] args){
//字符类型变
char c = 'a';
int i = 1;
//字符型类型和int类型计算
System.out.println(c+i);//输出结果98
}
编码变：就是讲人类的文字和一个十进制数进行对应起来组成一张表格。
人们规定：
| 字符 | 数值 |
|---|---|
| 0 | 48 |
| 9 | 57 |
| A | 65 |
| Z | 90 |
| a | 97 |
| z | 122 |
第二节 运算符
2.1算术运算符
| 算数运算符包括： | |
|---|---|
| + | 加法运算，字符串连接运算 |
| - | 减法运算 |
| * | 乘法运算 |
| / | 除法运算 |
| % | 取模运算，两个数字相除取余数 |
| ++、-- | 自增自减运算 |
-
++运算，变量自己增长1.--运算，变量自己减少1，用法一致。（以加法为例）
-
独立运算：
- 变量在运算时，前++和后++没有区别。
-
混合运算：
-
和其他变量放在一起。前++和后++就不同了。
-
变量前++：变量a自己加1，将加1后的结果赋值给b。
public static void mian(String[] args){ int a = 1; int b = ++a; System.out.println(a);//结果是2 System.out.println(b);//结果为2 } -
变量后++:变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a的值再自增加1，a的值就是2.
public static void mian(String[] args){ int a = 1; int b = a++; System.out.println(a)；//结果是2 System.out.println(b)；//结果是1 }
-
-
-
+符号在字符串中的操作：
-
+符号在遇到字符串的时候，表示连接、拼接的含义。
-
"a"+"b"的结果就是ab，连接的含义
public static void mian(String[] args){ System.out.prinntln("6+9="+6+9);//输出的6+9=69 }
-
2.2赋值运算符
| 赋值运算符包括： | |
|---|---|
| = | 等于号 |
| += | 加等于 |
| -= | 减等于 |
| *= | 成等于 |
| /= | 除等于 |
| %= | 取模等 |
-
赋值运算符，就是讲符号右边的值，赋值给左边的变量。
public static void main(String[] args){ int i = 6; i+=6;//计算方式i = i+6; System.out.println(i);结果是12 }
2.3比较运算符
| 比较运算符包括： | |
|---|---|
| == | 比较符号两边数据是否相等，相等结果为true。 |
| < | 比较符号左边数据是否小于右边数据，如果小于为true。 |
| > | 比较符号左边数据是否大于右边数据，如果大于为true。 |
| <= | 比较符号左边数据是否小于等于右边数据，如果小于等于为true。 |
| >= | 比较符号左边数据是否大于等于右边数据，如果大于等于为true。 |
| != | 比较符号左边数据是否不等于于右边数据，如果不等于于为true。 |
-
比较运算符是两个数据之间进行比较运算，运算结果都是布尔值true或者false。
public static void main(String[] args){ System.out.println(1==1);//结果为true System.out.println(1<2);//结果为true System.out.println(6>9);//结果为false System.out.println(2>=1);//结果为true System.out.println(3<=1);//结果为false System.out.println(3!=1);//结果为true }
2.4逻辑运算符
- 逻辑运算符使用来连接两个布尔型的结果的运算符，运算结果是布尔值true或者false
| 逻辑运算符包括： | |
|---|---|
| & 与 | 无论左边是否为true或者false都判断右边。 false&true 结果为false |
| | 或 | 无论左边是否为true或者false都判断右边。 false&true 结果为true |
| ^ 非 | 相同为真，不同为假。 |
| && 短路与 | 1.两边都是true，结果为true 2.一边为false，结果为false 短路特点：符号左边为false，右边不再算 |
| || 短路或 | 1.两个边都为false，结果为false。 2.一边为true，结果为true 短路特点：左边为true，右边不在算 |
| ！ 取反 | 1.！true的结果为false。 2.！false的结果为true |
- 位运算符：&、|、^、~、<<、>>、>>>（0，1）
- &：有0则0
- |：有1则1
- ^：相同为0，不同为1（涉及二进制）
- ~：按位取反（取反码）
- <<：左移位相当于乘以2^移位数(除去最高位，右边补0)
- >>：右移位相当于除以2^移位数(除去后两位,最高位是0补0,是1补1)
- >>>：无符号右移位(除去后两位,左边补0)
public static void main(String[] args){
System.out.println(true && true);//true
System.out.println(true && false);//false
System.out.println(false && true);//false ,右边不计算
System.out.println(false || false);//false
System.out.println(false || true);//true
System.out.println(true || false);//true,右边不计算
System.out.println(！true);//false
}
}
2.5三元运算符
-
格式：数据类型 变量名 = 布尔类型表达式？结果1：结果2
-
计算方式：
- 布尔类型表达式的结果为true，三元运算符整体结果为结果1，赋值给变量。
- 布尔类型表达式结果为false，三元运算符整体的结果为结果2，赋值给变量。
public static void main(String[] args){ int i = (6==9?66:99); System.out,println(i);//结果为99 int j = (2<=9?100:200); System.out.println(j);//结果为100 }
第三章 方法的入门
3.1概述
- 方法：就是将一个功能抽取出来，把代码单独定定义到一个大括号内，形成一个单独的功能。当我们需要这个功能的时候，就可以去调用，这样既实现了代码的复用性，也解决了代码冗余的现象。
3.2方法的定义
方法写之前首先考虑三要素：
- 返回值类型
- 方法名称
- 参数列表
-
定义格式：
修饰符 返回值类型 方法名（参数列表）{ 方法体 return ； } -
定义格式解释：
- 修饰符：目前固定的写法 public static
- 返回值类型:也就是方法最终产生的数据结果是什么类型。
- 方法名称：方法的名字，规则和变量一样，小驼峰。
- 参数类型：进入方法的数据是什么类型。
- 参数名称：进入方法的数据对应的变量名称
- PS：如果参数有多个，使用逗号进行分隔。
- 方法体：方法需要做的事，若干行代码
- return：两个作用。第一停止当前方法，第二将后面的返回值还给调用处
- 返回值：也就是方法执行后最终产生的数据结果
-
注意：return后面的"返回值”，必须和方法名称前面的“返回值类型”，保持对应。
-
举例：
public static void methodName(){ System.out.println("这是一个方法"); }
3.3方法的三种调用格式
方法在定义完毕后，方法不会自己运行，必须被调用才能执行，我们可以在主方法main中来调用我们自己定义好的方法。在主方法中直接写要调用的方法名称就可以调用了。
- 单独调用：方法名称（参数）；
- 打印调用：System.out.println(方法名称（参数)）；
- 赋值调用：数据类型 变量名称 = 方法名称（参数）；
public static void mian(String[] args){
//单独调用
sum(1,2);
//打印调用
System.out.println(sum(3,6));
//赋值调用
int number = sum(19,3);
System.out.println(number);
}
//方法
public void int sum(int a,int b){
int result = a+b;
return result;
}
3.4注意事项
- 方法定义的 注意事项：
- 方法必须定义在一个类中，方法外
- 方法不能定义在另一个方法的里面。
3.5扩展知识点
-
+=符号扩展
下面程序有问题吗？
public static void main(String[] args){ short s = 1; s +=1; System.out.println(s); }分析：s +=1;逻辑上看作是s = s+1；计算的结果被提升为int类型，在向short类型赋值时发生错误，因为不能将取值范围大的类型赋值到取值范围小的类型。但是，s=s+1进行两次运算，+=是一个运算符，只运算一次，并带有强制转换的特点，也就是说s+=1;就是s=(short)(s+1);因此程序没有问题编译通过，运行结果为2.
-
常量和变量的运算
public static void main(String[] args){ byte b1 = 1; byte b2 = 2; byte b3 = 1+2; byte b4 = b3+b2; System.out.println(b3); System.out.println(b4); }
-
分析：b3 = 1+2,1和2是常量，为固定不变的数据，在编译时（编译器javac），已经确定了1+2结果并没有超过byte类型的取值范围，可以赋值给变量b3，因此b3=1+2是正确的。
反之，b4 = b2+b3，b2和b3是变量，变量的值是可能发生变化的，在编译的时候，javac不确定b2+b3的结果是什么，因此会将结果以int类型处理，所以int类型不能赋值给byte类型，因此编译失败。（发生了自动转换，在计算的时候byte和short会自动转换为int类型）
day03【流程控制语句】
第二章 判断语句
2.1判断语句1--if
-
if语句第一种格式：if
if(关系表达式){ 语句体； }例子：
public static void main(String[] args){ int a = 1; int b = 2; if(a=b){ System.out.println("相等") } System.out.println("不相等。") } -
if语句第二种格式：if...else
if(关系表达式){ 语句体1； }else{ 语句体2； }例子：
public static void main(Stringp[] args){ //判断给定的数据类型是奇数还是偶数 //定义变量 int a = 6; if(a %2 ==0){ System.out.println("a为偶数") }else{ System.out.println("a为奇数") } System.out.println("结束。") } -
if语句的第三种各式--if..else if..else
if(判断条件1){ 语句体1； }else if（判断条件2）{ 语句体2； } ... }else if(判断语句n){ 语句体n； }else{ 执行语句n+1； }例子：
public static void mian(String[] args){ int x = 5; int y; if(x>=6){ y = 3x+2; }else if(-3<=x & x<6){ y = 2x+9; }else{ y = x+3; } System.out.println("y的值为："+y) }
2.2 if语句与三元运算符的转换
public static void main(String[] args){
int a = 1;
int b = 2;
int c;
if(a>b){
c = a;
}else{
c = b;
}
//改写成三元运算符
c = a>b?a:b;
}
第三章 选择语句
3.1 选择语句--switch
-
switch格式
switch(表达式){ case 常量值1： 语句体1； break； case 常量值2： 语句体2； break ... default: 语句体n+1； break； } -
执行流程
- 首先计算表达式的值。
- 其次，和case一次相比较，一旦有对应的值，就会执行相应的语句，在执行过程中，遇到break就会结束。
- 最后，如果所有的case值都和表达式结果不匹配， ，就会执行default语句部分，饭后程序结束。
-
举例：
switch 语句中，表达式的数据类型可以是byte、short、int、char、enum（枚举），jdk7后可以接收字符串。
public static void main(String[] args){
int j = 9;
switch(j){
case 1:
System.out.println("王者荣耀")
break；
case 2：
System.out.println("天天酷跑")
break；
default：
System.out.println("穿越火线")
}
}
3.2 case的穿透性
定义：在switch语句中，如果case后不写break，将出现穿透现象，也就是不会再判断下一个case值，直接向后运行，直到遇见break，或者整体switch结束。
例子：
public static void main(String[] args){
int i = 3;
switch(i){//switch 表达式
case 1：
System.out.prinkln(1);
break;
case 3:
System.out.priuntln(3);
case 6:
System.out.prinkln(6);
break;
}
}
上述程序中，在执行case3后，由于没有break语句，程序会继续向后走，不会判断case，直到遇到下一个break。
第四章 循环语句
4.1 循环概述
循环语句在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句。当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而循环结束，否则将一直运行下去，形成死循环。
4.2 循环语句1--for
-
for循环语句格式：
for(初始表达式①；布尔表达式②；步进表达式④){ 循环体③； }public static void main(String[] args){ //计算1-100奇数和 int num = 0; for(int i=1;i<=100;i++ ){ if(i % 2!=0){ num +=i; } } System.out.println("奇数和为"+num ) }
4.3 循环语句2 --while
while循环语句格式
初始化表达式1
while（布尔表达式2）{
循环体3
步进表达式4
}
public static void main(String[] args){
int x = 1;
while(x<=10){
System.out.println("萝莉！")；
x++;
}
}
4.4 循环语句3--do...while
do...while循环语句格式
初始化表达式1
do{
循环体3
步进表达式4
}while（布尔表达式2）；
public static void mian(String[] args){
int i = 1;
do{
System.out.println("御姐")
}while(i<=10)
}
特点：无条件执行一次循环体，即使我们将循环条件（布尔表达式的结果）直接写为false，也依然会循环一次。
public static void main(String[] args){
do{
System.out.println("无条件执行一次。")
}while(false)
}
4.5 循环语句的区别
- for和的while小区别
- 控制条件语句所控制的那个变量，在for循环结束后，就不能在被访问到了。而while循环结束后还可以继续使用。原因是for循环结束后，该变量就从内存中消失，能够提高内存的使用效率。
- 在已知循环次数的时候推荐用for，未知的时候推荐用while。
4.6 跳出语句
break
-
使用场景:终止switch或者循环
-
在选择结构switch语句中
-
在循环语句中
-
离开使用场景的存在是没有意义的
public static void main(String[] args){ for(int a = 1;a<=9;a++){ if(a==3){ System.out.println("结束。") break; } System.out.println("运行"+a) } }
continue
-
使用场景：结束本次循环，继续下一次的循环
public static void main(Strig[] args){ for(int i = 1;i<9;i++){ if(i==6){ continue； } System.out.println("运行结果"+i) } }
-
第五章 扩展知识点
5.1 死循环
- 死循环就是循环条件永远为true，死循环就是永不结束的循环。例如while(true){}
5.2 循环嵌套
-
所谓的嵌套循环，就是指一个循环的循环体是另一个循环。
for(初始化表达式1；循环条件2；步进表达式7){ for(初始化表达式3；循环条件4，步进表达式6){ 执行语句7； } }
day04【Idea、方法】
1.定义方法的注意事项
-
定义位置，类中 方法外边。
-
返回值类型，必须要和return语句返回值类型相同，否则编译失败。
public static int getSum{ return 5；//正确int 型 return 1.63；//错误，类型不匹配 } -
不能在return后面写代码，return意味着方法结束，所有后边代码永远不会执行，属于无效代码。
2.调用方法的三种格式
-
直接调用：直接写方法名调用
public static void main(Strng[] args){ print(); } public static void print(){ System.out.println("被调用的方法。") } -
赋值调用:调用方法，在方法前面定义变量，接收方法返回值
public static void main(String[] args){ int sum = getSum(6,9); System.out.println(sum); } public static int getSum(int a,int b){ return a+b; } -
输出语句调用：
-
在输出语句中调用方法，System.out.println((方法名（))；
public static void main(String[] args){ System.out.println(getSum(6,9)); } public static int getSum(int a,int b){ return(a+b); } -
不能用输出语句调用void类型的方法。因为方法执行后没有结果，也就打印不出来任何内容。
public static void mian(String[] args){ System.out.println(println());//错误，不能输出语句调用void类型方法 } public static void printlnHello(){ System.our.println("Hello) }
-
3.方法重载
- 方法重载：是指在同一个类中，允许存在一个以上的同命方法，只要他参数列表不同即可，与修饰符和返回值类型无关。
- 参数列表：个数不同数据类型不同，顺序不同。
- 方法重载的调用：jvm通过方法的参数列表，调用不同的方法。
public static void main(String[] args){
byte a = 1;
byte b = 2;
short c = 3;
short d = 6;
System.out.println(compare(a,b));
System.out.println(compare(c,d));
}
public static boolean compare(byte a,byte b){
System.out.println("byte型")
return a == b;
}
public static boolean compare(short c,short d){
System.out.println("short型")
return c == d;
}
day05【数组】
第一章 数组的定义和访问
1.1 容器概述
- 容器：是将多个数据存储到一起，每个数据称为该容器的元素。
- 生活中的容器：水杯、衣柜、教室
1.2 数组的概念
- 数组概念：是一种容器，可以同时存放多个数据。
- 特点：
- 数组是一种引用数据类型
- 数组当中的多个数据，类型必须统一
- 数组的长度在程序的运行期间不可改变
- 初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。
- 两种常见的初始化方式：
- 动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的多个元素。
- 静态初始化（指定内容）：在初始话的时候，不直接指定数据多少个，而是直接将数据的内容进行指定。
1.3 数组的定义
1. 动态初始化
-
动态初始化数组的格式：
数据类型【】 数组名称 = new 数据类型【数组长度】；
-
解析含义：
左侧数据类型：也就是数组当中保存的数据，全都是统一的数据类型。
左侧的中括号：代表我是一个数组。
左侧数组名称：给数组取一个名字
右侧的new：代表创建数组的动作
右侧的数据类型：必须和左侧的数据类型保持一致。
右侧中括号的长度：也就是数组当中可以存多好个数据，是一个int数字。
int[] arr = new int[3];
2.静态初始化
-
基本格式：
数据类型 数组名称 = new 数据类型[]{元素1，元素2，.....};
-
注意事项：
虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出长度。
int[] arr = new int[]{元素1、元素2、元素3、、、}；
3.静态初始化省略格式
-
使用静态初始化数组的时候，格式可以省略
静态初始化标准格式：
数据类型【】 数组名称 = new 数据类型【】{元素1，元素2，。。。。}
省略格式：
数据类型【】 数组名称 = {元素1，元素2、、}
int[] arr = {元素1、元素2、、、}; -
注意事项：
- 静态初始化没有直接指定长度，但是仍然会自动推算长度。
- 静态初始化的标准格式可以拆分为两个步骤。
- 动态初始化也可以拆分为两个步骤。
- 静态初始化一旦使用省略格式，就不能拆分为两个步骤。
-
使用建议:
如果不确定数组当中的具体内容,用动态初始化;否则,已经确定了具体内容,用静态初始化.
1.4 数组的访问
-
索引：每一个存储到数组的元素，都会自动拥有一个编号，从0开始，自动编号称为索引值。
-
格式：
数组名【索引】； -
数组长度属性：每个数组都有长度，而且固定的，可以通过语句 数组名.length获取数组的长度。数组最大的索引值为length-1；
public static void main(String[] args){ int[] arr = new int[]{3,6,9,12,23}; //打印数组长度 System.out.println(arr.length) } -
访问数组中的元素：
- 数组名[索引] = 数值，为数组中的元素赋值。将会替换掉原来的数值。
- 变量 = 数组名称 [索引]，获取数组中的元素。
第二章 数组内存图
2.1 内存的概述
内存是计算机中的重要原件，临时存储区域，作用是运行程序。 我们平时编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须存放进内存中才能运行，运行完毕后就会清空内存。
2.2 java虚拟机的内存划分
-
栈（Steck）：存放的都是方法中的局部变量。方法的运行一定要在栈当中运行。
局部变量：方法的参数，或者是方法{}内部的变量。
作用域：一旦超出作用域，立刻从栈内存中消失。
-
堆（Heep）：凡是new出来的东西，都在堆当中。
堆内存当中的东西都有一个地址值：16进制，
堆内存中的数据，都有默认值。规则：
如果是整数 默认值为0
如果是浮点数 默认值为0.0
如果是字符 默认值为'\u0000'
如果是布尔 默认值为false
如果是引用类型 默认值为null
-
方法区（Method Area）：存储.class文件相关信息，包含方法的信息。
-
本地方法栈(Native Method Stack):与操作系统相关。
-
寄存器(Pc Register):与CPU相关。
2.3 数组在内存中的存储
1.一个数组的内存图
涉及知识点：
- 方法区：中存放.class相关文件，包含方法信息（主要就是方法信息），如Demo02ArrayOne的main方法
- 栈：运行main方法，加载到栈内存当中，并为main方法在栈当中开辟内存空间，这个动作叫做进入栈内存。（进栈）
- new出来的东西都在堆当中， 在堆里边开辟一段内存空间。十六进制开头0X表示
- 数组在内存空间有自己的内存地址，以十六进制表示。0X开头
其他：
十六进制开头0X表示
数组的名称其实就是一个局部变量
2.两个数组的内存图
3.两个变量执行同一个数组
第三章 数组的常见操作
3.1常见问题_数组索引越界
数组的索引编号从0开始，一直到”数组长度-1“为止。
如果访问数组的编号并不存在，就会发生数组索引越界异常
报错代码：ArrayIndexOutOfBoundsException
原因：索引编号写错了
解决：修改称为正确的索引即可。
3.2 空指针异常
所有引用类型变量都可以赋值为一个null值，但其代表为空。
数组值赋了一个null，没有进行new的创建，就会发生空指针异常。 NullPointerException
3.3 获取数组的长度
格式：数组名称.length
将会得到一个int类型的数字，代表数组的长度。
数组一旦创建，程序运行期间不可更改，长度不可改变。
3.4 数组的遍历
数组遍历：就是将数组中的每个元素分别获取出来。
public static void main(String[] args){
int[] arr = new int[]{3,6,9};
for(int i=0;i<=arr.length-1;i++){
System.out.println(arr[i]);
}
}
3.5 获取数组的最大值
从数组的所有元素中找出最大值
public static void main(String[] args){
int max = 0;
int[] arr = new int[]{3,69,9,66,33};
for(int i = 0;i<=arr.length-1;i++){
if(max<arr[i]){
max = arr[i];
}
}
System.out.println("最大值是:"+max);
}
3.6 数组反转
数组反转：数组中的元素颠倒顺序。
public static void main(String[] args){
int[] arr = {1,2,3,5,6};
/*循环中定义变量min = 0最小索引
max = arr.length-1最大索引
*/
for(int min = 0,max = arr.length-1;max>min;max--,min++){
//利用第三方变量完成数组中的元素交换
int temp = arr[min];
arr[min] = arr[max];
arr[max] = temp;
}
//反转后，遍历数组
for(int i= 1;i<arr.length-1;i++){
System.out.println(arr[i])
}
}
第四章 数组作为方法参数和返回值类型
4.1 数组作为方法参数
-
任何数据类型都可以作为方法参数。
-
数组作为方法参数传递，传递的参数是数组内存的地址值。
public static void mian(String[] args){ int[] array = {3,6,9}; printArray(array); } /* 三要素： 返回值类型：只是进行打印而已，不需要进行其他操作，也没有结果，所以用void； 方法名称：printArray 参数列表：必须给数组，才能打印其中的元素，int[] array*/ public static void printArray(int[] array){ for(int i = 0;i<array.length;i++){ System.out.print(array[i]); } }
4.2 数组作为方法返回值
数组作为方法的参数，传递进去的其实就是数组的地址值。
数组作为方法的返回值，返回的其实也是数组的地址值。
public static void mian(String[] args){
//调用方法，接收数组的返回值
//接收到的是数组的内存地址
int[] arr = gerArray();
for(int a=0;a<arr.length;a++){
System.out.print(arr[i])
}
}
public static int[] gerArray(){
int[] arr = {3,6,9};
//返回数组的地址，返回到调用者
return arr;
}
方法的参数为基本数据类型时，传递的是数据值。方法的参数为引用数据类型时传递的是地址值。
