文章目录
基础知识
二进制发明者：莱布尼茨
字节：
位（bit）：一个数字0或者一个数字1，代表一位。
字节（Byte）：每逢8位是一个字节，这是数据存储的最小单位。
1 Byte = 8 bit
1 KB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
1 PB = 1024 TB
1 EB = 1024 PB
1 ZB = 1024 EB
JAVA虚拟机 —JVM
JVM（Java Virtual Machine ）：Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java程序的运行环境，是Java最具吸引力的特性之一。我们编写的Java代码，都运行在 JVM上
跨平台：任何软件的运行，都必须要运行在操作系统之上，而我们用Java编写的软件可以运行在任何的操作系统上，这个特性称为Java语言的跨平台特性。该特性是由JVM实现的，我们编写的程序运行在JVM上，而JVM 运行在操作系统上。
说明：每个系统都有属于自己的JVM，只有JAVA 程序具有跨平台性，（每个系统的JVM相当于当地的翻译）
JRE ( Java Runtime Environment) ：是Java程序的运行时环境，包含JVM和运行时所需要的核心类库。
JDK ( Java Development Kit)：是Java程序开发工具包，包含JRE和开发人员使用的工具。
我们想要运行一个已有的Java程序，那么只需安装JRE即可。
我们想要开发一个全新的Java程序，那么必须安装JDK。
编译和运行是两回事:
编译：是指将我们编写的Java源文件翻译成JVM认识的class文件，在这个过程中，javac 编译器会检查我们所写的程序是否有错误，有错误就会提示出来，如果没有错误就会编译成功。
运行：是指将class文件交给JVM去运行，此时JVM就会去执行我们编写的程序了。
命令提示符中
javac + 名.java ->编译
java + 名 ->运行
关于main方法
main方法：称为主方法。写法是固定格式不可以更改。main方法是程序的入口点或起始点，无论我们编写多少程序，JVM在运行的时候，都会从main方法这里开始执行。
注释：
单行注释：//开头 换行结束
多行注释：/开头 以/结束
**关键字：**是指在程序中，Java已经定义好的单词，具有特殊含义。
常出现的有public. class . static , void等，这些单词java已经定义好了，全部是小写字母，有特殊颜色标记
标识符：是指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。
标识符可以包含 英文字母26个，区分大小写、0-9数字、美元符号$、和下划线_ 。
标识符不能以数字开头。 标识符不能是关键字。
命名规范：
类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。
方法名规范：首字母小写，后面每个单词首字母大写
**常量：**是指在Java程序中固定不变的数据。
分类：
| 类型 | 含义 | 数据举例 |
|---|---|---|
| 整数常量 | 所有的整数 | 0，1， 567， -9 |
| 小数常量 | 所有的小数 | 0.0， -0.1， 2.55 |
| 字符常量 | 单引号引起来,只能写一个字符,必须有内容 | ‘a’ ， ’ '， ‘好’ |
| 字符串常量 | 双引号引起来,可以写多个字符,也可以不写 | “A” ，“Hello” ，“你好” ，"" |
| 布尔常量 | 只有两个值（流程控制中讲解） | true ， false |
| 空常量 | 只有一个值（引用数据类型中讲解） | null |
变量
变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量。
Java中要求一个变量每次只能保存一个数据，必须要明确保存的数据类型。
Java的数据类型分为两大类：
基本数据类型：包括整数、浮点数、字符、布尔。
引用数据类型：包括 类、数组、接口
Java中jdk封装的类，以及自定义的Java类，都属于引用数据类型
数据类型 关键字 内存占用 取值范围
字节型 byte 1个字节 -128~127
短整型 short 2个字节 -32768~32767
整型 int（默认） 4个字节 -231次方~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
JAVA中整数类型是int，浮点类型是double
变量的定义： 数据类型、变量名、数据值
格式： 数据类型 变量名 = 数据值；
注意：
变量名称：在同一个大括号范围内，变量的名字不可以相同。
变量赋值：定义的变量，不赋值不能使用。
数据类型转换
import java.util.Scanner;
public class Demo318 {
/*
当数据类型不一样时，将会发生数据类型转换。
自动类型转换（隐式）
1. 特点：代码不需要进行特殊处理，自动完成。
2. 规则：数据范围从小到大。
强制类型转换（显式）
*/
public static void main(String[] args) {
System.out.println(1024); // 这就是一个整数，默认就是int类型
System.out.println(3.14); // 这就是一个浮点数，默认就是double类型
// 左边是long类型，右边是默认的int类型，左右不一样
// 一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
// int --> long，符合了数据范围从小到大的要求
// 这一行代码发生了自动类型转换。
long num1 = 100;
System.out.println(num1); // 100
// 左边是double类型，右边是float类型，左右不一样
// float --> double，符合从小到大的规则
// 也发生了自动类型转换
double num2 = 2.5F;
System.out.println(num2); // 2.5
// 左边是float类型，右边是long类型，左右不一样
// long --> float，范围是float更大一些，符合从小到大的规则
// 也发生了自动类型转换
float num3 = 30L;
System.out.println(num3); // 30.0
/*
强制类型转换
1. 特点：代码需要进行特殊的格式处理，不能自动完成。
2. 格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
注意事项：
1. 强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
2. byte/short/char这三种类型都可以发生数学运算，例如加法“+”.
3. byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。
4. boolean类型不能发生数据类型转换
*/
public static void main(String[] args) {
// 左边是int类型，右边是long类型，不一样
// long --> int，不是从小到大
// 不能发生自动类型转换！
// 格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
int num = (int) 100L;
System.out.println(num);
// long强制转换成为int类型
int num2 = (int) 6000000000L;
System.out.println(num2); // 1705032704
// double --> int，强制类型转换
int num3 = (int) 3.99;
System.out.println(num3); // 3，这并不是四舍五入，所有的小数位都会被舍弃掉
char zifu1 = 'A'; // 这是一个字符型变量，里面是大写字母A
System.out.println(zifu1 + 1); // 66，也就是大写字母A被当做65进行处理
// 计算机的底层会用一个数字（二进制）来代表字符A，就是65
// 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字
byte num4 = 40; // 注意！右侧的数值大小不能超过左侧的类型范围
byte num5 = 50;
// byte + byte --> int + int --> int
int result1 = num4 + num5;
System.out.println(result1); // 90
short num6 = 60;
// byte + short --> int + int --> int
// int强制转换为short：注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
short result2 = (short) (num4 + num6);
System.out.println(result2); // 100
}
}
自动转换规则：
强制转换：
运算符
1、算术运算符
++运算
前++和后++区别
前++：变量自己先加1，将加1后的结果赋值给b
后++：变量a先把自己的数值 赋值给b，
2、赋值运算符
= . += . -=. *=. /= . %=
3、比较运算符
== .< .>. <=.>=. !=
4、逻辑运算符
&& || ！
5、三元运算符
格式： 数据类型 变量名= 布尔类型表达式? 结果1：结果2
int a = (2 == 3 ? 4 : 6);
System.out.println(a);//返回值 6
说明：不加括号也是可以的
方法入门
方法：将功能抽取出来，把代码单独定义在一个大括号，形成一个单独功能
当我们需要用这个功能的时候，就要去调用。实现在代码的复用，也解决了代码的冗余
方法定义 ：定义一个方法的格式：
public static void 方法名称() {
方法体
}
方法名称的命名规则和变量一样，使用小驼峰。
方法体：也就是大括号当中可以包含任意条语句。
public static void main(String[] args) {
farmer(); // 调用农民的方法
seller(); // 调用小商贩的方法
cook(); // 调用厨子的方法
me(); // 调用我自己的方法
}
// 厨子
public static void cook() {
System.out.println("洗菜");
System.out.println("切菜");
System.out.println("炒菜");
System.out.println("装盘");
}
// 我
public static void me() {
System.out.println("吃");
}
// 小商贩
public static void seller() {
System.out.println("运输到农贸市场");
System.out.println("抬高价格");
System.out.println("吆喝");
System.out.println("卖给厨子");
}
// 农民伯伯
public static void farmer() {
System.out.println("播种");
System.out.println("浇水");
System.out.println("施肥");
System.out.println("除虫");
System.out.println("收割");
System.out.println("卖给小商贩");
}
方法定义注意事项:
- 方法定义的先后顺序无所谓。
- 方法的定义不能产生嵌套包含关系。
- 方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的【调用】。
如何调用方法，格式：
方法名称();
流程控制
判断语句 if
if（关系表达式）{
语句体；
}
if…else
if（关系表达式）{
语句体1；
}else{
语句体2；
}
if…else if…else
if（关系表达式）{
语句体1；
}else if（关系表达式）{
语句体2；
}else{
语句
}//可以是多个
if语句和三元运算符的互换
选择语句 switch
格式：
switch(表达式){//也就是满足哪一个case就执行那个case的代码
case 常量值1；
语句1
break
case 常量值2；
语句2
break
....
default://就像是刚刚的else
语句体n+1；
break;
}
switch语句使用的注意事项：
- 多个case后面的数值不可以重复。
- switch后面小括号当中只能是下列数据类型：
基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举 - switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略。
“匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。”
**case的穿透性：**在switch语句中，如果case后面不写break，将出现穿透现象，也就是不会判断下一个case的值，往后运行，直到遇到break，或者整体switch结束。
循环语句
/*
循环结构的基本组成部分，一般可以分成四部分：
1. 初始化语句：在循环开始最初执行，而且只做唯一一次。
2. 条件判断：如果成立，则循环继续；如果不成立，则循环退出。
3. 循环体：重复要做的事情内容，若干行语句。
4. 步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。
*/
for循环
for(初始化表达式1;布尔表达式2;步进表达式3){
循环体4；
} //顺序 1-4-2-3
public static void main(String[] args) {
for (int i = 1; i <= 100; i++) {
System.out.println("我错啦！原谅我吧！" + i);
}
System.out.println("程序停止");
}
while循环
初始化表达式1
while(布尔表达式2){
循环体3;
步进表达式4;
}//步骤 1-2-3-4
for (int i = 1; i <= 10; i++) {
System.out.println("我错啦！" + i);
}
System.out.println("=================");
int i = 1; // 1. 初始化语句
while (i <= 10) { // 2. 条件判断
System.out.println("我错啦！" + i); // 3. 循环体
i++; // 4. 步进语句
}
上面的for循环和while循环效果一样
do…while循环
do-while循环的标准格式：
do {
循环体
} while (条件判断);
扩展格式：
初始化语句
do {
循环体
步进语句
} while (条件判断);
for (int i = 1; i <= 10; i++) {
System.out.println("原谅你啦！起来吧！地上怪凉！" + i);
}
System.out.println("===============");
int i = 1; // 1. 初始化语句
do {
System.out.println("原谅你啦！起来吧！地上怪凉！" + i); // 3. 循环体
i++; // 4. 步进语句
} while (i <= 10); // 2. 条件判断
注意：do…while循环无论如何都要把循环体循环一遍
IDEA
注：IDEA所有源代码要写到src中，包也在其中，
层次：项目-模块-src 包（小写，可以加.形成多层文件夹）-类
缩写：
psvm:创建main方法
sout:打印输出 system.out.println();
声明一点：idea是不需要保存的，自动保存。
方法
方法其实就是若干语句的功能集合。
方法好比是一个工厂。
蒙牛工厂 原料：奶牛、饲料、水
产出物：奶制品
钢铁工厂 原料：铁矿石、煤炭
产出物：钢铁建材
参数（原料）：就是进入方法的数据。
返回值（产出物）：就是从方法中出来的数据。
定义方法的完整格式：
修饰符 返回值类型 方法名称(参数类型 参数名称, ...) {
方法体
return 返回值;
}
解释：
修饰符：现阶段的固定写法，public static
返回值类型：也就是方法最终产生的数据结果是什么类型
方法名称：方法的名字，规则和变量一样，小驼峰
参数类型：进入方法的数据是什么类型
参数名称：进入方法的数据对应的变量名称
PS：参数如果有多个，使用逗号进行分隔
方法体：方法需要做的事情，若干行代码
return：两个作用，第一停止当前方法，第二将后面的返回值还给调用处
返回值：也就是方法执行后最终产生的数据结果
注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应。
定义一个两个int数字相加的方法。三要素：
返回值类型：int
方法名称：sum
参数列表：int a, int b
方法的三种调用格式。
- 单独调用：方法名称(参数);
- 打印调用：System.out.println(方法名称(参数));
- 赋值调用：数据类型 变量名称 = 方法名称(参数);
注意：此前学习的方法，返回值类型固定写为void，这种方法只能够单独调用，不能进行打印调用或者赋值调用。
public static void main(String[] args) {
// 单独调用
sum(10, 20);
System.out.println("==========");
// 打印调用
System.out.println(sum(10, 20)); // 30
System.out.println("==========");
// 赋值调用
int number = sum(15, 25);
number += 100;
System.out.println("变量的值：" + number); // 140
}
public static int sum(int a, int b) {
System.out.println("方法执行啦！");
int result = a + b;
return result;
}
idea中会显示灰色a,b提示，
在不同的应用场景下可能会出现要返回参数和没有参数的情况
有参数：例如相加，就要给出参数，方法参数列表要给出定义
无参数：打印字符串，方法参数列表就可以为空
有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数。
例如两个数字相加，必须知道两个数字是各自多少，才能相加。
无参数：小括号当中留空。一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数。例如定义一个方法，打印固定10次HelloWorld。
题目要求：定义一个方法，用来【求出】两个数字之和。（你帮我算，算完之后把结果告诉我。）
题目变形：定义一个方法，用来【打印】两个数字之和。（你来计算，算完之后你自己负责显示结果，不用告诉我。）
注意事项
对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用。
但是对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。
public static void main(String[] args) {
// 我是main方法，我来调用你。
// 我调用你，你来帮我计算一下，算完了之后，把结果告诉我的num变量
int num = getSum(10, 20);
System.out.println("返回值是：" + num);
System.out.println("==============");
printSum(100, 200);
System.out.println("==============");
System.out.println(getSum(2, 3)); // 正确写法
getSum(3, 5); // 正确写法，但是返回值没有用到
System.out.println("==============");
// 对于void没有返回值的方法，只能单独，不能打印或者赋值
// System.out.println(printSum(2, 3)); // 错误写法！
// System.out.println(void);
// int num2 = printSum(10, 20); // 错误写法！
// int num3 = void;
// void num4 = void;
}
// 我是一个方法，我负责两个数字相加。
// 我有返回值int，谁调用我，我就把计算结果告诉谁
public static int getSum(int a, int b) {
int result = a + b;
return result;
}
// 我是一个方法，我负责两个数字相加。
// 我没有返回值，不会把结果告诉任何人，而是我自己进行打印输出。
public static void printSum(int a, int b) {
int result = a + b;
System.out.println("结果是：" + result);
}
使用方法的时候，注意事项：
- 方法应该定义在类当中，但是不能在方法当中再定义方法。不能嵌套。
- 方法定义的前后顺序无所谓。
- 方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
- 如果方法有返回值，那么必须写上“return 返回值;”，不能没有。
- return后面的返回值数据，必须和方法的返回值类型，对应起来。
- 对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。也就是说此时是标志着方法的结束，
return两个作用：- 返回被方法处理过的值
- 作为方法结束的标志
- 对于void方法当中最后一行的return可以省略不写。有返回值就一定要写！
- 一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写。
/*
题目要求：
定义一个方法，用来判断两个数字是否相同。
*/
public static void main(String[] args) {
System.out.println(isSame(10, 20)); // false
System.out.println(isSame(20, 20)); // true
}
/*
三要素：
返回值类型：boolean
方法名称：isSame
参数列表：int a, int b
*/
public static boolean isSame(int a, int b) {
// boolean same;
// if (a == b) {
// same = true;
// } else {
// same = false;
// }
boolean same = a == b ? true : false;
// boolean same = a == b;
return same;//有返回值boolean类型，return一定要写
}
方法的重载 overload
对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。
方法的重载（Overload）：多个方法的名称一样，但是参数列表不一样。
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。
方法重载与下列因素相关：
- 参数个数不同
- 参数类型不同
- 参数的多类型顺序不同
方法重载与下列因素无关：
- 与参数的名称无关
- 与方法的返回值类型无关
public static void main(String[] args) {
System.out.println(sum(10, 20)); // 两个参数的方法
System.out.println(sum(10, 20, 30)); // 三个参数的方法
System.out.println(sum(10, 20, 30, 40)); // 四个参数的方法
// System.out.println(sum(10, 20, 30, 40, 50)); // 找不到任何方法来匹配，所以错误！
sum(10, 20);
}
public static int sum(int a, double b) {
return (int) (a + b);
}
public static int sum(double a, int b) {
return (int) (a + b);
}//上面两个方法的参数类型进行了颠倒，是方法的重载
public static int sum(int a, int b) {
System.out.println("有2个参数的方法执行！");
return a + b;
}
public static int sum(double a, double b) {
return (int) (a + b);
}
// 错误写法！与方法的返回值类型无关
// public static double sum(int a, int b) {
// return a + b + 0.0;
// }
// 错误写法！与参数的名称无关
// public static int sum(int x, int y) {
// return x + y;
// }
public static int sum(int a, int b, int c) {
System.out.println("有3个参数的方法执行！");
return a + b + c;
}
public static int sum(int a, int b, int c, int d) {
System.out.println("有4个参数的方法执行！");
return a + b + c + d;
}
题目要求：
比较两个数据是否相等。
参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，
并在main方法中进行测试。
public static void main(String[] args) {
byte a = 10;
byte b = 20;
System.out.println(isSame(a, b));
System.out.println(isSame((short) 20, (short) 20));//强制类型转换，
System.out.println(isSame(11, 12));//自动转换成int类型，调用含有int参数的方法
System.out.println(isSame(10L, 10L));//两个都是long类型，调用含有long参数的方法
}
public static boolean isSame(byte a, byte b) {
System.out.println("两个byte参数的方法执行！");
boolean same;
if (a == b) {
same = true;
} else {
same = false;
}
return same;
}
public static boolean isSame(short a, short b) {
System.out.println("两个short参数的方法执行！");
boolean same = a == b ? true : false;
return same;
}
public static boolean isSame(int a, int b) {
System.out.println("两个int参数的方法执行！");
return a == b;
}
public static boolean isSame(long a, long b) {
System.out.println("两个long参数的方法执行！");
if (a == b) {
return true;
} else {
return false;
}
}
判断方法的重载：
public static void open(){} // 正确重载
public static void open(int a){} // 正确重载
static void open(int a,int b){} // 代码错误：和第8行冲突。
public static void open(double a,int b){} // 正确重载
public static void open(int a,double b){} // 代码错误：和第6行冲突
public void open(int i,double d){} // 代码错误：和第5行冲突
public static void OPEN(){} // 代码正确不会报错，但是并不是有效重载
public static void open(int i,int j){} // 代码错误：和第3行冲突
说明：第三行，和前面的饰符无关
代码严格区分大小写
练习：模拟println
// byte short int long float double char boolean
// String
// 在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式。
public static void main(String[] args) {
myPrint(100); // int
myPrint("Hello"); // String
}
public static void myPrint(byte num) {
System.out.println(num);
}
public static void myPrint(short num) {
System.out.println(num);
}
public static void myPrint(int num) {
System.out.println(num);
}
public static void myPrint(long num) {
System.out.println(num);
}
public static void myPrint(float num) {
System.out.println(num);
}
public static void myPrint(double num) {
System.out.println(num);
}
public static void myPrint(char zifu) {
System.out.println(zifu);
}
public static void myPrint(boolean is) {
System.out.println(is);
}
public static void myPrint(String str) {
System.out.println(str);
}
快捷键说明：shift + F6 选中一个量，代码中的这个量都会发生改变
数组
数组定义
存储数据长度固定的容器，保证多个数据的数据类型要一致。
数组的概念：是一种容器，可以同时存放多个数据值。
数组的特点：
- 数组是一种引用数据类型
- 数组当中的多个数据，类型必须统一
- 数组的长度在程序运行期间不可改变
数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。
两种常见的初始化方式：
- 动态初始化（指定长度）
- 静态初始化（指定内容）
动态初始化数组的格式：
数据类型[] 数组名称 = new 数据类型[数组长度];
解析含义：
左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型
左侧的中括号：代表我是一个数组
左侧数组名称：给数组取一个名字
右侧的new：代表创建数组的动作
右侧数据类型：必须和左边的数据类型保持一致
右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字
定义：
格式一：动态初始化：
数组存储数据类型[] 数组名 = new 数组存储数据类型[长度]；
如 int[] arr = new int[5];存储五个整数的数组容器。
格式二: 注意是大括号
动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数。
静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。
静态初始化基本格式：
数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, … };
注意事项：
虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。
数组存储数据类型[] 数组名 = new 数组存储数据类型[]{元素1,元素2…}；
如 int[] arr = new int[]{1,5,6,4,8};存储五个整数的数组容器。
格式三：
使用静态初始化数组的时候，格式还可以省略一下。
标准格式：
数据类型[] 数组名称 = new 数据类型[] { 元素1, 元素2, … };
省略格式：
数据类型[] 数组名称 = { 元素1, 元素2, … };
注意事项：
- 静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
- 静态初始化标准格式可以拆分成为两个步骤。
- 动态初始化也可以拆分成为两个步骤。
- 静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。
使用建议
如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。
数组存储数据类型[] 数组名 = {元素1,元素2…}；
如 int[] arr = {1,2.3,5,6};存储五个整数的数组容器。
数组的访问
int[] arrayE = {1,2,3};
System.out.println(arrayE);//[I@75412c2f
返回一串字符，是数组在内存中的地址，new出来的东西都是在堆内存中存储的，方法中的array保存的是数组的地址。
直接打印数组名称，得到的是数组对应的：内存地址哈希值。
二进制：01
十进制：0123456789
16进制：0123456789abcdef
访问数组元素的格式：数组名称[索引值]
索引值：就是一个int数字，代表数组当中元素的编号。
注意:
-
索引值从0开始，一直到“数组的长度-1”为止。
-
刚刚定义的数组，int类型，系统会自动初始化为0
int[] arrayH = new int[3];
System.out.println(arrayH[0]);//0
System.out.println(arrayH[2]);//0
使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下：
如果是整数类型，那么默认为0；
如果是浮点类型，那么默认为0.0；
如果是字符类型，那么默认为’\u0000’；
如果是布尔类型，那么默认为false；
如果是引用类型，那么默认为null。
注意事项：
静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。
JVM内存划分
按照左侧代码进行分析：
运行后，main方法进入到方法区存储，明确main方法需要的信息加载到stack中，并且为main开辟内存空间（进栈）。
下一行把是数组名称，也就是局部变量拿过来。
int[3]是我们new出来的对象，进到堆Heap，划分为三个格子，每一个格子都有索引编号，同时创建完会初始化为0，地址值都是16进制，0x代表16进制。
例如0x666会被发到array
注意:我们定义的数组在Heap中，而名称相当于局部变量，放在Stack中，存储一个地址值，genuine地址就能找到数组
下一行
根据索引array[0]就能找到0x666地址
两个数组情况：arrayB = arrayA
自己理解：
最后两个数组输出结果是一样的，表示数组A,B两者都是内存上的管理者，并非真正拥有者
数组常见问题
数组越界异常
数组的索引编号从0开始，一直到“数组的长度-1”为止。
如果访问数组元素的时候，索引编号并不存在，那么将会发生
数组索引越界异常
ArrayIndexOutOfBoundsException
原因：索引编号写错了。
解决：修改成为存在的正确索引编号。
数组空指针异常
所有的引用类型变量，都可以赋值为一个null值。但是代表其中什么都没有。
数组必须进行new初始化才能使用其中的元素。
如果只是赋值了一个null，没有进行new创建，
那么将会发生：
空指针异常 NullPointerException
原因：忘了new
解决：补上new
public static void main(String[] args) {
int[] array = null;
// array = new int[3];//成心指向null
System.out.println(array[0]);
}
如何获取数组的长度，格式：
数组名称.length
这将会得到一个int数字，代表数组的长度。
数组一旦创建，程序运行期间，长度不可改变
int[] arrayH = new int[3];
int a = arrayH.length;
System.out.println(a);//3
arrayH = new int[]{1,2,1,2,1,2,1};
System.out.println(arrayH.length);//7
数组遍历：重点
数组遍历：数组中的每个元素分别获取出来，就是遍历。遍历是数组操作中的基石
public static void main(String[] args) {
int[] array = new int[]{1, 2, 3, 5, 2, 6, 8, 5, 1, 55, 4};
//遍历数组
for (int i = 0; i <= array.length - 1; i++) {
System.out.println(array[i]);
}
}
数组中获取最大值元素
public static void main(String[] args) {
int[] array = new int[]{1, 2, 3, 5, 2, 6, 8, 5, 1, 55, 4};
// 数组获取最大数值
int max = array[0];
for (int i = 0; i <= array.length - 1; i++) {
if(max <=array[i]){
max = array[i];
}
}
System.out.println("最大值是"+max);
}
注： 数据名称.fori可以生成遍历for循环
数组反转：
数组元素的反转：
本来的样子：[1, 2, 3, 4]
之后的样子：[4, 3, 2, 1]
要求不能使用新数组，就用原来的唯一一个数组。
public static void main(String[] args) {
int[] array = new int[]{1, 2, 3, 5, 2, 6, 8, 5, 1, 55, 4};
//要实现数组的反转，也就是其中的数值进行交换。
//要找一个中间体
// 初始化语句：int min = 0, max = array.length - 1
// 条件判断：min < max
// 步进表达式：min++, max--
// 循环体：用第三个变量倒手
for(int min = 0,max = array.length-1;min<max;min++,max--){
int temp = array[min];
array[min] = array[max];
array[max] = temp;
}
for (int i = 0; i <=array.length-1 ; i++) {
System.out.println(array[i]);
}
}
数组作为方法参数：
数组可以作为方法的参数。
当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。
public static void main(String[] args) {
int[] array = { 10, 20, 30, 40, 50 };
System.out.println(array); // 地址值[I@75412c2f
printArray(array); // 传递进去的就是array当中保存的地址值
}
/*
三要素
返回值类型：只是进行打印而已，不需要进行计算，也没有结果，用void
方法名称：printArray
参数列表：必须给我数组，我才能打印其中的元素。int[] array
*/
public static void printArray(int[] array) {
System.out.println("printArray方法收到的参数是：");
System.out.println(array); // 地址值
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
我们要明确一点就是，方法的参数值可以是0，1，2等个参数，但是返回值只能是0，1个
一个方法可以有0、1、多个参数；但是只能有0或者1个返回值，不能有多个返回值。
如果希望一个方法当中产生了多个结果数据进行返回，怎么办？
解决方案：使用一个数组作为返回值类型即可。
任何数据类型都能作为方法的参数类型，或者返回值类型。
数组作为方法的参数，传递进去的其实是数组的地址值。
数组作为方法的返回值，返回的其实也是数组的地址值。
public static void main(String[] args) {
int[] result = calculate(10, 20, 30);
System.out.println("main方法接收到的返回值数组是：");
System.out.println(result); // 地址值
System.out.println("总和：" + result[0]);
System.out.println("平均数：" + result[1]);
}
public static int[] calculate(int a, int b, int c) {
int sum = a + b + c; // 总和
int avg = sum / 3; // 平均数
// 两个结果都希望进行返回
// 需要一个数组，也就是一个塑料兜，数组可以保存多个结果
/*
int[] array = new int[2];
array[0] = sum; // 总和
array[1] = avg; // 平均数
*/
int[] array = { sum, avg };
System.out.println("calculate方法内部数组是：");
System.out.println(array); // 地址值
return array;//方法结束的标志
}
扫一扫
519
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
