1 写在前面

JVM + 核心类库 = JRE + 编译器等开发工具 = JDK

Java环境变量的配置 : 计算机 -> 属性-> 高级系统设置 -> 系统变量 -> 新建系统变量

JAVA_HOME : 选择Java工具包的bin目录的上一级目录

Path : %JAVA_HOME%bin

Java程序开发三步骤 : 编写, 编译, 运行

编译 : javac.exe 编译器 运行 : java.exe 解释器

public class HelloWorld {public static void main(String[] args) {System.out.println("Hello World!");}
}// 先 javac HelloWorld.java, 再 java HelloWorld

2 标识符的概念及规则

• 标识符 : 在程序中,我们自己定义的内容; 比如类, 方法, 变量的 名字 都称为标识符
• 命名规则 : 硬性要求
  • 标识符可以包含英文字母26个(区分大小写),0-9数字,$(美元符号) 和 _(下划线)
  • 标识符不能以数字开头
  • 标识符不能是已有的关键字

• 命名规范 : 软性建议
  • 类名规范 : 首字母大写, 后面每个单词首字母大写 (大驼峰式)
  • 变量名规范 : 首字母小写, 后面每个单词首字母大写 (小驼峰式)
  • 方法名规范 : 同变量名规范

3 常量

定义 : 是指在Java程序运行期间固定不变的数据

| 类型 | 含义 | 数据举例 | | ---------- | ---------------------------------------- | ---------------- | | 整数常量 | 所有的整数 | 0, 1 , 5, -5 | | 浮点数常量 | 所有的小数 | 1.4 , 0.0, -4.9 | | 字符常量 | 单引号引起来的,只能写一个字符,必须有内容 | 'a', ‘好’ | | 字符串常量 | 双引号引起来的,可以写多个, 可以不写 | 'aaaaa', 'Hello’ | | 布尔常量 | 两个值 | true, fasle | | 空常量 | 一个值; 空常量不能直接用来打印输出 | null |

System.out.println(5);
System.out.println(5.0);
System.out.println('5');
System.out.println("admin);

4 数据基本类型

Java数据类型分为两大类 : 基本数据类型 和 引用数据类型

基本数据类型 : 整数, 浮点数, 字符, 布尔这四大类 又可分为八种

引用数据类型 : 字符串, 类, 数组, 接口, Lambda

| 数据类型 | 关键字 | 内存占用 | 取值范围 | | ------------ | ------- | ------------- | ------------------------ | | 字节型 | byte | 1个字节 | -128 ~127 | | 短整型 | short | 2 个字节 | -32768 ~ 32767 | | 整型 | int | 4个字节(默认) | -2的31次方 ~ 2的31次方-1 | | 长整型 | long | 8个字节 | -2的63次方 ~ 2的63次方-1 | | 单精度浮点数 | float | 4个字节 | 1.4013E-45 ~ 3.4028E+38 | | 双精度浮点数 | double | 8个字节 | 4.9E-324~1.7977E+308 | | 字符 | char | 2个字节 | 0-65535 | | 布尔 | boolean | 1个字节 | true, false |

注意事项 :

1. 字符串不是基本类型, 而是引用类型
2. 浮点型可能是一个近似值, 并非精确的值
3. 数据范围与字节数不一定相关, 例如float数据范围比long更加广泛,但是float是4个字节,long是8个字节
4. 浮点数当中默认类型是double,如果一定要使用float类型, 需要加上一个后缀F, 推荐使用大写字母后缀
5. 如果是整数, 默认是int类型, 如果一定要使用long类型, 需要加上一个后缀F, 推荐使用大写字母后缀

5 变量

定义 : 在程序运行期间可以变化的量称为变量

Java中要求一个变量每次只能保存一个数据, 且必须要明确保存变量的数据类型

变量定义的格式包括三个要素： 数据类型 、 变量名 、 数据值 。

数据类型 变量名称 = 数据值; // 创建了一个变量,并将数据值赋值给变量

注意事项 :

1. 如果创建多个变量, 变量之间的名称不可以重复
2. 对于float和long类型来说, 字母后缀F和L不要丢掉
3. 如果使用byte或者short类型的变量, 那么右侧的数据值不能超过左侧类型的范围
4. 没有进行赋值的变量, 不能直接使用; 一定要赋值之后, 才能使用
5. 变量的使用不能超过作用域的范围[作用域: 从定义变量的一行开始, 一直到直接所属的大括号为止]

6 数据类型转换

自动类型转化 -- 隐式转换

将取值小的范围自动提升为取值范围大的类型, 比如:一个int类型与byte字节类型相加运算是int类型

public static void main(String[] args){int i = 1;byte b = 2;// byte x = b + i; // 报错 // int类型和byte类型运算，结果是int类型 int j = b + i; System.out.println(j);
}

同样道理当一个 int 类型变量和一个double 变量运算时，int 类型将会自动提升为 double 类型进行运算。

public static void main(String[] args) {int i = 1; double d = 2.5; //int类型和double类型运算，结果是double类型 // int类型会提升为double类型double e = d+i;System.out.println(e);}

转换规则 :范围小的类型向 范围大的类型提升; byte, short ,char 运算时直接提升为 int

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

强制类型转换 -- 显式转换

将 1.5 赋值到 int 类型变量会发生什么? 产生编译失败, 肯定无法赋值

int i = 1.5
// // 错误 double 类型内存8个字节， int 类型内存4个字节。 1.5 是 double 类型，取值范围大于 int 。可以理解为 double 是8 升的水壶， int 是4升的水壶，不能把大水壶中的水直接放进小水壶去。 想要赋值成功，只有通过强制类型转换，将 double 类型强制转换成 int 类型才能赋值。

强制类型转换：将取值范围大的类型 强制转换成 取值范围小的类型 。 比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。

转换格式 : 数据类型 (范围小) 变量名 (范围小) = (数据类型 -- 范围小) 被转数据值(范围大);

int i = (int) 1.5;public static void main(String[] args) { //short类型变量，内存中2个字节 short s = 1;/*出现编译失败 s和1做运算的时候，1是int类型，s会被提升为int类型 s+1后的结果是int类型，将结果在赋值会short类型时发生错误 short内存2个字节，int类型4个字节 必须将int强制转成short才能完成赋值 */s = s + 1;//编译失败 s = (short) (s+1);//编译成功
}

注意事项 :

1. 强制类型转换一般不推荐使用, 有可能发生精度损失, 数据溢出

7 ASCII编码表

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 |

在char类型和int类型计算的过程中，char类型的字符先查询编码表，得到97，再和1求和，结果为98。 char类型提升 为了int类型。char类型内存2个字节，int类型内存4个字节。

8 运算符

算数运算符

| 算数运算符包括： | | | :--------------- | :--------------------------- | | + | 加法运算，字符串连接运算 | | - | 减法运算 | | * | 乘法运算 | | / | 除法运算 | | % | 取模运算，两个数字相除取余数 | | ++、— | 自增自减运算 |

Java中, 整数使用以上运算符 ,无论怎么计算, 也不会得到小数

public static void main(String[] args) { int i = 1234;System.out.println(i/1000*1000);//计算结果是1000
}

一切基本数据类型与 String字符串用 + 都是拼接形成新的 字符串

自增运算符 : ++

自减运算符 : --

使用格式 : 写在变量名称之前, 后缀写在变量名称之后, 例如: ++num, 也可以num++

使用方式 :

​ 单独使用 : ++num, num++ 没有任何区别

​ 混合使用 :

​ A - 如果是前++ ,那么变量立刻马上+1,然后拿着结果使用 [先加后用]

​ B - 如果是后++,那么使用变量本来的数值,然后再让变量+1 [先用后加]

注意事项 : 只有变量才能使用自增, 自减运算符; 常量不可改变, 所以不能用

赋值运算符

| 赋值运算符包括： | | | :--------------- | :----- | | = | 等于号 | | += | 加等于 | | -= | 减等于 | | *= | 乘等于 | | %= | 取模等 | | /= | 除等于 |

赋值运算符 : 就是将符号左边的值, 赋给左边的变量

public static void main(String[] args){ int i = 5; i+=5;//计算方式 i=i+5 变量i先加5，再赋值变量i System.out.println(i); //输出结果是10
}

比较运算符

| 比较运算符包括： | | | :--------------- | :----------------------------------------------------------- | | == | 比较符号两边数据是否相等，相等结果是true。 | | > | 比较符号左边的数据是否大于右边的数据，如果大于结果是true。 | | < | 比较符号左边的数据是否小于右边的数据，如果小于结果是true。 | | >= | 比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是true。 | | <= | 比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true。 | | != | 不等于符号 ，如果符号两边的数据不相等，结果是true。 |

比较运算符 : 两个数据之间比较的运算, 运算结果都是布尔值 true 或者 false

逻辑运算符

| 逻辑运算符包括： | | | :--------------- | :----------------------------------------------------------- | | && 短路与 | 1. 两边都是true，结果是true 2. 一边是false，结果是false 短路特点：符号左边是false，右边不再运算 [全真为真] | | ！ 取反 | 1. ! true 结果是false 2. ! false结果是true | | || 短路或 | 1. 两边都是false，结果是false 2. 一边是true，结果是true 短路特点： 符号左边是true，右边不再运算。 [一真为真] |

三元运算符

运算法则 : 数据类型 变量名 = 布尔类型表达式 ? 结果1 : 结果2

当布尔类型表达式值为true, 取结果1赋值给变量 ; 否则即当布尔类型表达式值为false, 取结果2赋值给变量;

9 JDK的JShell的简单使用

当我们编写的代码非常少的时候, 而又不愿意编写类, main方法, 也不愿意去编译和运行,就要使用JShell命令

在cmd当中 输入 jshell进入,,,,,,,输入 /exit 退出命令

编译器的的优化 :

• 对于 byte/short/char 三种类型来说, 如果右侧赋值的数值没有超过范围, 那么javac编译器将会自动隐含地(强转)为我们补上一个(byte)(short)(char); 如果右侧超过了左侧的范围, 那么直接编译报错
• 在给变量赋值的时候, 如果右侧的表达式当中全都是常量, 没有任何变量, 那么编译器javac 将会直接将若干个常量表达式计算得到结果; short = 5 + 8; // 等号右边全都是常量, 没有任何变量参与运算编译之后, 得到的.class 字节码文件当中相当于[直接就是] : short result = 13;右侧的常量结果数值, 没有超过左侧范围, 所以正确; 这称之为"编译器的常量优化"

10 流程控制

顺序结构

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。也就是说，程序的流程对运行结果 有直接的影响。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现 我们要完成的功能。

public static void main(String[] args){//顺序执行，根据编写的顺序，从上到下运行
System.out.println(1);
System.out.println(2);
System.out.println(3);
}

判断语句

if

if(关系表达式)｛
语句体;
｝public static void main(String[] args){System.out.println("开始");// 定义两个变量int a = 10;int b = 20;//变量使用if判断if (a == b){System.out.println("a等于b");}int c = 10;if(a == c){System.out.println("a等于c");}System.out.println("结束");
｝

执行流程 :

1. 首先判断关系表达式看其结果是true还是false
2. 如果是true就执行语句体
3. 如果是false就不执行语句体

if.....else

if(关系表达式) {语句体1;
}else {语句体2;
}

执行流程 :

1. 首先判断关系表达式看其结果是true还是false
2. 如果是true就执行语句体1
3. 如果是false就执行语句体2

if ....else if ...else

if (判断条件1) {执行语句1;
} else if (判断条件2) {执行语句2;
}
...
}else if (判断条件n) {执行语句n;
} else {执行语句n+1;
}

执行流程 :

1. 首先判断关系表达式1看其结果是true还是false
2. 如果是true就执行语句体1
3. 如果是false就继续判断关系表达式2看其结果是true还是false
4. 如果是true就执行语句体2
5. 如果是false就继续判断关系表达式…看其结果是true还是false
6. …
7. 如果没有任何关系表达式为true，就执行语句体n+1。

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 {y = 2 * x ‐ 1;}System.out.println("y的值是："+y);
}

选择语句

switch(表达式) {case 常量值1:语句体1;break;case 常量值2:语句体2;break;...default:语句体n+1;break;
}

执行流程 :

1. 首先计算出表达式的值
2. 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
3. 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

public static void main(String[] args) {//定义变量，判断是星期几int weekday = 6;//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;}
}

switch语句中, 表达式的数据类型 ,可以是byte, short, int ,char ,enum(枚举), 还可以是字符串

循环语句

循环语句可以在满足循环条件的情况下, 反复执行某一段代码, 这段被重复执行的代码被称为循环体语句, 当反复执行这个循环体时, 需要在合适的时候把循环判断条件修改为false, 从而结束循环, 否则循环将一直执行下去, 形成死循环

for循环语句表达式

for(初始化表达式①; 布尔表达式②; 步进表达式④){循环体③
}

执行流程 :

执行顺序：①②③④>②③④>②③④…②不满足为止。

①负责完成循环变量初始化

②负责判断是否满足循环条件，不满足则跳出循环

③具体执行的语句

④循环后，循环条件所涉及变量的变化情况

public static void main(String[] args) {//定义变量从0开始，循环条件为<10for(int x = 0; x < 10; x++) {System.out.println("HelloWorld"+x);}
}
循环练习：使用循环，计算1-100之间的偶数和
public static void main(String[] args) {//1.定义一个初始化变量,记录累加求和,初始值为0int sum = 0;//2.利用for循环获取1‐100之间的数字for (int i = 1; i <= 100; i++) {//3.判断获取的数组是奇数还是偶数if(i % 2==0){//4.如果是偶数就累加求和sum += i;}}//5.循环结束之后,打印累加结果System.out.println("sum:"+sum);
}

do.......while循环表达式

初始化表达式①
do{循环体③
步进表达式④
}while(布尔表达式②);输出10次HelloWorld
public static void main(String[] args) {int x=1;do {System.out.println("HelloWorld");x++;}while(x<=10);
}

do...while循环的特点：无条件执行一次循环体，即使我们将循环条件直接写成false，也依然会循环一次。这样的 循环具有一定的风险性，因此初学者不建议使用do...while循环。

跳出语句

break : 终止swtich或者循环

public static void main(String[] args) {for (int i = 1; i<=10; i++) {//需求:打印完两次HelloWorld之后结束循环if(i == 3){break;}System.out.println("HelloWorld"+i);}}

continue : 结束本次循环, 继续下一次的循环

public static void main(String[] args) {for (int i = 1; i <= 10; i++) {//需求:不打印第三次HelloWorldif(i == 3){continue;}System.out.println("HelloWorld"+i);}
}

死循环 : 也就是循环中的条件永远为true，死循环的是永不结束的循环。例如：while(true){}

嵌套循环 所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数

外循环一次, 内循环多次

for(初始化表达式①; 循环条件②; 步进表达式⑦) {for(初始化表达式③; 循环条件④; 步进表达式⑥) {执行语句⑤;}
}

11 开发工具 Intellij IDEA

IDEA是一个专门针对java的集成开发工具(IDE), 由java语言编写, 所以, 需要有JRE运行环境并配置好环境变量; 他可以极大的提升我们的开发效率, 可以自动编译, 检查错误

项目Project --> 模块Module --> 包 Packpage

IDE的 HelloWorld 在模块的src目录下 新建 java class,写上 psvm 快捷生成 main()

IDE的基本设置 : 更改自动补全为 Alt+/

IDEA常用快捷键

| 快捷键 | 功能 | | -------------------- | -------------------------------------- | | Alt+Enter | 导入包, 自动修正代码 | | Ctrl+Y | 删除光标所在行 | | Ctrl+D | 复制光标所在行的内容, 插入光标位置下面 | | Ctrl+Alt+L | 格式化代码 | | Ctrl+/ | 单行注释, 再按取消注释 | | cTRL+Shift+/ | 选中代码注释, 多行注释, 再按取消注释 | | Alt+Ins | 自动生成代码, toString, get, set等方法 | | Alt+Shift+上下箭头 | 移动当前代码行 |

删除模块: 选中模块delete, 或者右键Remove Module

导入模块 : File --> Project Structure --> + -->import Module --> 选择对应的目录-->一直next,next

12 方法

定义 : 就是将一个功能抽取出来, 把代码单独定义在一个大括号内, 形成一个单独的功能;当我们需要这个功能的时候,就可以去调用, 这样既实现了代码的复用性, 也解决了代码冗余的现象

定义格式 :

修饰符 返回值类型 方法名 (参数列表) {代码 ...return ;
}public static void main (String[] args) {方法体 ...return 返回值;
}

解释 :

• 修饰符 : 目前固定写法 public static
• 返回值类型 : 目前固定写法 void, 其他返回值会在后面接触
• 方法名: 我们定义的方法名 : 满足标识符的规范, 用来调用方法
• 参数列表 :方法在运算过程中的未知数据, 调用者调用方法时传递
• return : 将方法执行后的结果数据带给调用者，方法执行到 return ，整体方法运行结束
• 结果 : 方法的返回值

注意事项 :

• 方法的定义位置在类中,在main()外面, 在 main中调用,先后顺序无所谓,和调用顺序有关
• 返回值类型, 必须要和 return语句返回的类型相同, 否则编译失败
• 不能用输出语句调用 void 类型的方法; 因为方法执行后没得结果,也不打印出任何内容
• 一个方法中可以有多个return语句,但是只能保证同时只能有一个被执行, return不能连写

方法的调用方式:

• 单独调用, 方法名称(参数);
• 打印调用, System.out.println(Sum(3,5));
• 赋值调用, 数据类型 变量名称 = Sum(3,5);

方法的有无参数:

有参数: 小括号当中有内容, 当一个方法需要一些数据条件,才能完成任务的时候,就是有参数
例如两数相加, 必须知道两个数字各自是多少, 才能相加无参数: 小括号当中留空, 一个方法不需要任何数据条件, 自己就能独立完成任务,就是无参数
例如定义一个方法, 打印10次Helloworld

有无返回值

package cn.itcast.day04.demo02;public class Demo04Return {public static void main(String[] args) {int num = getSum(10,20);System.out.println("返回值"+ num);System.out.println("=============");printSum(2,3);}public static int getSum(int a, int b){int res = a + b;return res;}public static void printSum(int a,int b){int res = a + b;System.out.println(res);}}

getSum就是有返回值的方法; printSum就是无返回值的方法

练习 1 : 定义一个方法, 用来判断两个数字是否相同

public class Demo01MethodSame(){public static void main(String[] args) {System.out.println(isSame(10,20))  // false}public static boolean isSame(int a,int b){boolean same;if (a == b){same = true;}else{same = fasle;}boolean same = a = b?true:fasle;boolean same = a==breturn same;return a == b;
}}

练习2 : 定义一个方法, 永安里打印指定次数的HelloWorld

public class Demo03MethodPrint {public static void main(String[] args) {printCount(8);}/*三要素返回值类型 : void方法名 : printCount参数列表 : 到底打印多少次, 告诉我几次,就打印几次 次数 int :num*/public static void printCount(int num){for (int i = 0; i < num; i++) {System.out.println("HelloWorld" + (i+方法1));}}
}

方法定义的三要素 : 返回值类型, 方法名, 参数列表 [返回值类型必须与return返回的类型相同]

方法重载

定义 : 同一个类中, 允许重载一个以上的同名方法, 只要他们的参数列表不同即可, 与修饰符和返回值类型无关

参数列表 : 个数不同, 数据类型不同, 顺序不同

重载方法调用 : JVM通过方法的参数列表, 调用不同的方法

13 数组

定义 : 是一种容器, 可以同时存放多个数据值

特点 :

1. 数组是一种引用数据类型
2. 数组当中的多个数据, 类型必须统一
3. 数组的长度在程序运行期间不可改变

数组的创建 , 也叫做数组的初始化

1. 动态初始化(指定长度) : 在创建数组的时候, 直接指定数组当中的数据元素的个数
2. 静态初始化(指定内容) : 在创建数组的时候, 不直接指定数据个数多少, 而是直接将具体的数据内容指定

动态初始化数组的格式 : 数据类型[] 数组名称 = new 数据类型[数组长度];

动态初始化时数组的元素会自动拥有一个默认值, 为 0; 根据数组的类型自动拥有

静态初始化时数组的元素会其实也会自动拥有一个默认值, 为 0; 只不过系统马上将默认值替换为了大括号当中的具体数值

解析含义 :

左侧数据类型 : 也就是数组当中保存的数据, 全都是统一的什么类型

左侧中的括号 : 代表我是一个数组

左侧的数组名称 : 给数组取一个名字

右侧中的new : 代表创建数组的动作

右侧数据类型 : 必须和左边的数据类型保持一致

右侧括号中的长度 : 也就是数组当中, 到底可以保存多少个数据, 是一个int数字

静态初始化数组的格式 : 数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3};

省略初始化数组的格式 : 数据类型[] 数组名称 = {元素1,元素2,元素3};

// 直接打印数组名称, 得到的是数组对应的, 内存地址的哈希值int[] array = {10,20,30}
System.out.println(array);   // [I@75412c2f 十六进制

数组的访问

索引 : 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，到length-1结束, 这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

格式 : 数组名[索引]

数组的赋值 : array[索引] = 具体的数值

Java的内存划分

Java的内存需要划分为五个部分:

1 栈(Stack) : 存放的都是方法中的局部变量, 方法的运行一定要在栈当中; 局部变量: 方法的参数,或者是方法{}内部的变量, 作用域: 一旦超过作用域, 立刻从栈内存才能当中消失

2 堆(Heap) : 凡是 new 出来的东西,都在堆当中; 堆内存里面的东西都有一个地址值 : 16 进制, 堆内存里面的数据, 都有默认值; 整数 --> 默认为0; 浮点数 --> 默认为0.0; 字符 --> 默认为'u0000'; 布尔值 --> 默认为false; 引用类型 --> 默认为null

3 方法区(Method Area) : 存储.class 相关信息, 包含方法的信息

4 本地方法栈(Native Method Stack) : 与操作系统相关

5 寄存器(pc Register) : 与CPU相关

一个数组的从无到有

两个数组的内存图

两个引用指向同一个数组的问题

把 arrayB = arrayA 把arrayA的内存地址赋值给arrayB

public class Demo05ArraySame {public static void main(String[] args) {int[] arrayA = new int[3]; // 初始化一个数组System.out.println(arrayA); // 地址值System.out.println(arrayA[0]);  // 0System.out.println(arrayA[1]);  // 0System.out.println(arrayA[2]);  // 0arrayA[1] = 20;arrayA[2] = 30;System.out.println(arrayA);  // 地址值System.out.println(arrayA[0]); // 0System.out.println(arrayA[1]);  // 20System.out.println(arrayA[2]);  // 30int[] arrayB = arrayA;System.out.println(arrayB); // 地址值System.out.println(arrayB[0]);  // 0System.out.println(arrayB[1]);  // 0System.out.println(arrayB[2]);  // 0arrayB[1] = 200;arrayB[2] = 300;System.out.println(arrayB);  // 地址值System.out.println(arrayB[0]); // 0System.out.println(arrayB[1]);  // 200System.out.println(arrayB[2]);  // 300System.out.println("=================");System.out.println(arrayA[1]);  // 200System.out.println(arrayA[2]);  // 300}
}

操作 arrayA和arrayB, 他们俩其实就是一个数组

空指针异常

所有的引用类型变量, 都可以赋值为一个 null 值,但是代表其中什么都没有

数组必须进行new初始化才能使用其中的元素

如果只是赋值了一个null,没有进行new创建,那么将会发生空指针异常 NullPointerException

数组的长度属性

每个数组都具有长度，而且是固定的，在程序运行期间不可变,Java中赋予了数组的一个属性，可以获取到数组的长度，语句为： 数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为 数组名.length-1 。

int[] arrayC = new int[3];
arrayC = new int[5];
System.out.println(arrayC) // 此时并没有改变数组的长度,而是新创建了一个数组, 改变了arrayC的引用 --> 指向新的数组

数组的遍历输出

public static void main(String[] args) {int[] arr = { 1, 2, 3, 4, 5 };for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}
}

数组获取最大值元素

public static void main(String[] args) {int[] arr = { 5, 15, 2000, 10000, 100, 4000 };//定义变量，保存数组中0索引的元素int max = arr[0];//遍历数组，取出每个元素for (int i = 1; i < arr.length; i++) {//遍历到的元素和变量max比较//如果数组元素大于maxif (arr[i] > max) {//max记录住大值max = arr[i];}}System.out.println("数组最大值是： " + max);
}

数组反转

blic static void main(String[] args) {int[] arr = { 1, 2, 3, 4, 5 };/*循环中定义变量min=0最小索引初始化语句 min=0最小索引,max=arr.length‐1最大索引条件判断  min <= max步进表达式  min++,max‐‐*/for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) {//利用第三方变量完成数组中的元素交换int temp = arr[min];arr[min] = arr[max];arr[max] = temp;}// 反转后，遍历数组for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}
}

数组作为方法的参数传递

数组作为方法的参数传递, 传递的参数是数组的内存地址

public static void main(String[] args) {int[] arr = { 1, 3, 5, 7, 9 };//调用方法，传递数组printArray(arr);
}
/*
创建方法，方法接收数组类型的参数
进行数组的遍历
*/
public static void printArray(int[] arr) {for (int i = 0; i < arr.length; i++) {System.out.println(arr[i]);}
}

数组作为方法的返回值返回

数组作为方法的返回值返回, 返回的是数组的内存地址

一个方法可有0, 1, 多个参数,但是只能有0或者1个返回值, 不能有多个返回值

如果希望一个方法当中产生多个结果数据返回, 使用一个数组作为返回值类型即可

public static void main(String[] args) {//调用方法，接收数组的返回值//接收到的是数组的内存地址int[] res = cal(10,20,30);for (int i = 0; i < res.length; i++) {System.out.println("总和:"+ res[0]);System.out.println("平均数:"+ res[0]);}
}
/*
创建方法，返回值是数组类型
return返回数组的地址
*/
public static int[] cal(int a,int b,int c) {int sum = a+b+c; // 总和int avg = sum /3;  // 平均数int[] arr = {sum,avg};return arr;
}

方法的参数为基本数据类型时,传递的是数据值; 方法的参数为引用类型时, 传递的是地址值

同理, 引用类型作为方法的返回值时, 返回的也是地址值