Java基础语法(HelloWorld、常识、常量、变量和数据类型、数据类型转换、运算符、方法、流程控制语句、数组、开发工具)
Java基础语法
- 1. HelloWorld入门程序
-
- 1.1 程序开发步骤说明
- 1.2 编写Java源程序
- 1.3 编译Java源文件
- 1.4 运行Java程序
- 2. 一些常识
-
- 2.1 编译和运行是两回事
- 2.2 关于main方法
- 2.3 关键字keywords
- 2.4 标识符
- 3. 常量
- 4. 变量和数据类型
-
- 4.1 变量概述
- 4.2 数据类型
-
- 4.2.1 数据类型分类
- 4.2.2 基本数据类型
- 4.3 变量的定义
- 5. 数据类型转换
-
- 5.1 自动转换
- 5.2 强制转换
- 5.3 ASCII 编码表
- 6. 运算符
-
- 6.1 算数运算符
- 6.2 赋值运算符
- 6.3 比较运算符
- 6.4 逻辑运算符
- 6.5 三元运算符
- 7. 方法
-
- 7.1 方法的定义
- 7.2 调用方法的三种形式
- 7.3 方法重载
- 8.流程控制语句
-
- 8.1判断语句
-
- 8.1.1 判断语句1--if
- 8.1.2 判断语句2--if...else
- 8.1.3 判断语句3--if..else if...else
- 8.1.4 语句练习
- 8.1.5 if 语句和三元运算符的互换
- 8.2 选择语句
-
- 8.2.1 选择语句--switch
- 8.2.2 case 的穿透性
- 8.3 循环语句
-
- 8.3.1 循环语句1--for
- 8.3.2 循环语句2--while
- 8.3.3 循环语句3--do...while
- 8.3.4 循环语句的区别
- 8.3.5 跳出语句
- 8.3.6 死循环
- 8.3.7 嵌套循环
- 9. 数组
-
- 9.1 数组定义和访问
-
- 9.1.1 数组的定义
- 9.1.2 数组的访问
- 9.2 数组原理内存图
-
- 9.2.1 Java 虚拟机的内存划分
- 9.3 数组在内存中的存储
- 9.4 数组的常见操作
-
- 9.4.1 数组越界异常
- 9.4.2 数组空指针异常
- 9.4.3 数组遍历【重点】
- 9.4.4 数组获取最大值元素
- 9.4.5 数组反转
- 9.5 数组作为方法参数和返回值
-
- 9.5.1 数组作为方法参数
- 9.5.2 数组作为方法返回值
- 9.5.3 方法的参数类型区别
- 10. 开发工具IntelliJ IDEA
-
- 10.1 IDEA 软件安装
- 10.2 IDEA 常用快捷键
- 10.3 IDEA 修改快捷键
一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。
对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
类：类是一个模板，它描述一类对象的行为和状态。
方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。
1. HelloWorld入门程序
1.1 程序开发步骤说明
Java程序开发三步骤：编写、编译、运行。
1.2 编写Java源程序
- 在 d:\day01 目录下新建文本文件，完整的文件名修改为 HelloWorld.java ，其中文件名为 HelloWorld ，后
缀名必须为 .java 。 - 用记事本打开(可使用notepad++)
- 在文件中键入文本并保存，代码如下：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
注:文件名必须是 HelloWorld ，保证文件名和类的名字是一致的，注意大小写。
HelloWord 源程序就编写完成了，但是这个文件是程序员编写的，JVM是看不懂的，也就不能运行，因此我们必须将编写好的 Java 源文件 编译成JVM可以看懂的字节码文件 。
1.3 编译Java源文件
在DOS命令行中，进入Java源文件的目录，使用 javac 命令进行编译。
命令：
javac 源文件名.后缀名
编译成功后，命令行没有任何提示。打开 d:\day01 目录，发现产生了一个新的文件 HelloWorld.class ，该文件就是编译后的文件，是Java的可运行文件，称为字节码文件，有了字节码文件，就可以运行程序了。
1.4 运行Java程序
在DOS命令行中，进入Java源文件的目录，使用 java 命令进行运行。
命令：
java 类名字
注:java HelloWord 不要写 .class
2. 一些常识
2.1 编译和运行是两回事
编译 ：是指将我们编写的Java源文件翻译成JVM认识的class文件，在这个过程中， javac 编译器会检查我们所写的程序是否有错误，有错误就会提示出来，如果没有错误就会编译成功。
运行 ：是指将 class 文件 交给JVM去运行，此时JVM就会去执行我们编写的程序了。
2.2 关于main方法
main 方法：称为主方法。写法是固定格式不可以更改。main方法是程序的入口点或起始点，无论我们编写多少程序，JVM在运行的时候，都会从main方法这里开始执行。
2.3 关键字keywords
关键字 ：是指在程序中，Java已经定义好的单词，具有特殊含义。
HelloWorld 案例中，出现的关键字有 public 、 class 、 static 、 void等，这些单词已经被Java定义好，全部都是小写字母，notepad++中颜色特殊。
2.4 标识符
标识符 ：是指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。
HelloWorld 案例中，出现的标识符有类名字 HelloWorld 。
命名规则： 硬性要求
- 标识符可以包含 英文字母 26个(区分大小写) 、 0 -9数字 、 $ （美元符号） 和 _ （下划线）。
- 标识符不能以数字开头。
- 标识符不能是关键字。
命名规范： 软性建议
- 类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）。
- 方法名规范： 首字母小写，后面每个单词首字母大写（小驼峰式）。
- 变量名规范：全部小写。
3. 常量
| 类型 | 含义 | 数据举例 |
|---|---|---|
| 整数常量 | 所有的整数 | 0，1， 243， -7 |
| 小数常量 | 所有的小数 | 0.0， -0.2， 3.95 |
| 字符常量 | 单引号引起来,只能写一个字符,必须有内容 | ‘a’， ‘好’ |
| 字符串常量 | 双引号引起来,可以写多个字符,也可以不写 | “A” ，“Hello” ，“你好” ，"" |
| 布尔常量 | 只有两个值 | true ， false |
| 空常量空常量 | 只有一个值 | null |
使用示例
public class ConstantDemo {
public static void main(String[] args){
//输出整数常量
System.out.println(249);
//输出小数常量
System.out.println(0.13);
//输出字符常量
System.out.println('A');
//输出布尔常量
System.out.println(true);
//输出字符串常量
System.out.println("你好呀Java");
}
}
4. 变量和数据类型
4.1 变量概述
变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量。
Java中要求一个变量每次只能保存一个数据，必须要明确保存的数据类型。
4.2 数据类型
4.2.1 数据类型分类
基本数据类型 ：包括 整数 、 浮点数 、 字符 、 布尔
引用数据类型 ：包括 类 、 数组 、 接口
4.2.2 基本数据类型
四类八种基本数据类型：
| 数据类型 | 关键字 | 内存占用 | 取值范围 |
|---|---|---|---|
| 字节型 | 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 |
4.3 变量的定义
数据类型 变量名 = 数据值;
练习
public class Variable {
public static void main(String[] args){
//定义字节型变量
byte b = 100;
System.out.println(b);
//定义短整型变量
short s = 1000;
System.out.println(s);
//定义整型变量
int i = 123456;
System.out.println(i);
//定义长整型变量
long l = 12345678900L;
System.out.println(l);
//定义单精度浮点型变量
float f = 5.5F;
System.out.println(f);
//定义双精度浮点型变量
double d = 8.5;
System.out.println(d);
//定义布尔型变量
boolean bool = false;
System.out.println(bool);
//定义字符型变量
char c = 'A';
System.out.println(c);
}
}
long类型：建议数据后加L表示。
float类型：建议数据后加F表示。
变量名称：在同一个大括号范围内，变量的名字不可以相同。
变量赋值：定义的变量，不赋值不能使用。
5. 数据类型转换
Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。
5.1 自动转换
自动转换 ：将 取值范围小的类型 自动提升为 取值范围大的类型 。
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
自动提升带来的问题
public static void main(String[] args){
byte b1=1;
byte b2=2;
//1和2是常量，为固定不变的数据，在编译的时候，已经确定了1+2的结果并没有超过byte类型的取值范围
//所以1+2可以赋值给变量b3
byte b3=1 + 2; //因此 b3=1 + 2是正确的。
//b2和b3是变量，变量的值是可能变化的，在编译的时候，编译器javac不确定b2+b3的结果是什么
//因此会将结果以int类型进行处理，所以int类型不能赋值给byte类型，
byte b4=b1 + b2; //因此编译失败。
System.out.println(b3);
System.out.println(b4);
}
在jshell中的体现：
5.2 强制转换
如果将 1.5 赋值到 int 类型变量将产生编译失败，肯定无法赋值。
int i = 1.5; // 错误
double 类型内存8个字节， int 类型内存4个字节。 1.5 是 double 类型，取值范围大于 int 。
想要赋值成功，只有通过强制类型转换，将 double 类型强制转换成 int 类型才能赋值。
强制类型转换 ：将 取值范围大的类型 强制转换成 取值范围小的类型 。
比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。
转换格式：
数据类型 变量名 = （数据类型）被转数据值；
将 1.5 赋值到 int 类型，代码修改为：
// double类型数据强制转成int类型，直接去掉小数点。
int i = (int)1.5;
同样道理，当一个 short 类型与 1 相加，我们知道会类型提升，但是还想给结果赋值给short类型变量，就需要强制转换。
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);//编译成功
}
转换原理图解
强烈注意 :
浮点转成整数，直接取消小数点，可能造成数据损失精度。
int 强制转成 short 砍掉2个字节，可能造成数据丢失。
// 定义s为short范围内最大值
short s = 32767;
// 运算后，强制转换，砍掉2个字节后会出现不确定的结果
s = (short)(s + 10);
5.3 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个字节。
6. 运算符
6.1 算数运算符
| 符号 | 含义 |
|---|---|
| + | 加法运算 / 字符串连接运算 |
| - | 减法运算 |
| * | 乘法运算 |
| / | 除法运算，两个数字相除取商 |
| % | 取模运算，两个数字相除取余数 |
| ++ 、– | 自增自减运算 |
Java中，整数使用以上运算符，无论怎么计算，也不会得到小数。
+符号在遇到字符串的时候，表示连接、拼接的含义。如:“a”+“b” 的结果是“ab”，连接含义
6.2 赋值运算符
| 符号 | 含义 |
|---|---|
| = | 等于号 |
| += | 加等于 |
| -= | 减等于 |
| *= | 乘等于 |
| /= | 除等于 |
| %= | 取模等 |
关于+=符号的小思考 :
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.
6.3 比较运算符
| 符号 | 含义 |
|---|---|
| == | 比较符号两边数据是否相等，相等结果是true |
| < | 比较符号左边的数据是否小于右边的数据，如果小于结果是true |
| > | 比较符号左边的数据是否大于右边的数据，如果大于结果是true |
| <= | 比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true |
| >= | 比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是true |
| ! = | 不等于符号 ，如果符号两边的数据不相等，结果是true |
比较运算符，是两个数据之间进行比较的运算，运算结果都是布尔值 true 或者 false
6.4 逻辑运算符
逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值 true 或者 false
6.5 三元运算符
三元运算符格式：
数据类型 变量名 = 布尔类型表达式？结果1：结果2
三元运算符计算方式：
- 布尔类型表达式结果是 true，三元运算符整体结果为结果1，赋值给变量。
- 布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。
public static void main(String[] args) {
int i = (1==2 ? 100 : 200);
System.out.println(i);//200
int j = (3<=4 ? 500 : 600);
System.out.println(j);//500
}
7. 方法
方法： 就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。
7.1 方法的定义
定义格式：
修饰符 返回值类型 方法名 （参数列表）｛
代码...
return 方法的返回值;
｝
定义格式解释：
- 修饰符： 目前固定写法 public static
- 返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
- 方法名：为我们定义的方法起名，满足标识符的规范，用来调用方法
- 参数列表： 方法在运算过程中的未知数据，调用者调用方法时传递
- return：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束。如果返回值类型是void，方法大括号内的return可以不写
举例:
public static void methodName() {
System.out.println("这是一个方法");
}
方法定义注意事项：
- 定义位置 : 类中方法外, 方法不能定义在另一个方法的里面
- 返回值类型 : 必须要和 return 语句返回的类型相同，否则编译失败 。
- 不能在 return 后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码
public class Method_Demo5 {
public static void main(String[] args) {
//调用方法printHelloWorld，传递整数
printHelloWorld(9);
}
/*
定义打印HelloWorld方法
返回值类型，计算没有结果 void
参数：不确定打印几次
*/
public static void printHelloWorld(int n) {
for (int i = 0; i < n; i++) {
System.out.println("HelloWorld");
}
}
}
7.2 调用方法的三种形式
方法在定义完毕后，方法不会自己运行，必须被调用才能执行，我们可以在主方法main中来调用我们自己定义好的方法。在主方法中，直接写要调用的方法名字就可以调用了。
public static void main(String[] args) {
//调用定义的方法operator
operator();
}
//定义方法，被main方法调用，在方法中定义三元运算符
public static void operator() {
int i = 0;
i = (1==3 ? 100:200);
System.out.println(i);
int j = 0 ;
j = (5<=2 ? 500:600);
System.out.println(j);
}
- 直接调用： 直接写方法名调用
public static void main(String[] args) {
print();
}
public static void print() {
System.out.println("方法被调用");
}
- 赋值调用： 调用方法，在方法前面定义变量，接收方法返回值
public static void main(String[] args) {
int sum = getSum(5,6);
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(5,6));
}
public static int getSum(int a,int b) {
return a + b;
}
注:不能用输出语句调用 void 类型的方法。因为方法执行后没有结果，也就打印不出任何内容。
public static void main(String[] args) {
System.out.println(printHello());// 错误，不能输出语句调用void类型方法
}
public static void printHello() {
System.out.println("Hello");
}
7.3 方法重载
方法重载 ：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。
- 参数列表：个数不同，数据类型不同，顺序不同。
- 重载方法调用： JVM通过方法的参数列表，调用不同的方法。
方法重载举例 :
比较两个数据是否相等。参数类型分别为两个 byte 类型，两个 short 类型，两个 int 类型，两个 long 类型，并在 main 方法中进行测试。
public class Method_Demo6 {
public static void main(String[] args) {
//定义不同数据类型的变量
byte a = 10;
byte b = 20;
short c = 10;
short d = 20;
int e = 10;
int f = 10;
long g = 10;
long h = 20;
// 调用
System.out.println(compare(a, b));
System.out.println(compare(c, d));
System.out.println(compare(e, f));
System.out.println(compare(g, h));
}
// 两个byte类型的
public static boolean compare(byte a, byte b) {
System.out.println("byte");
return a == b;
}
// 两个short类型的
public static boolean compare(short a, short b) {
System.out.println("short");
return a == b;
}
// 两个int类型的
public static boolean compare(int a, int b) {
System.out.println("int");
return a == b;
}
// 两个long类型的
public static boolean compare(long a, long b) {
System.out.println("long");
return a == b;
}
}
8.流程控制语句
8.1判断语句
8.1.1 判断语句1–if
if(关系表达式)｛
语句体;
｝
8.1.2 判断语句2–if…else
if(关系表达式) {
语句体1;
}else {
语句体2;
}
8.1.3 判断语句3–if…else if…else
if (判断条件1) {
执行语句1;
} else if (判断条件2) {
执行语句2;
}
...
}else if (判断条件n) {
执行语句n;
} else {
执行语句n+1;
}
8.1.4 语句练习
指定考试成绩，判断学生等级
- 90-100 优秀
- 80-89 好
- 70-79 良
- 60-69 及格
- 60 以下 不及格
public static void main(String[] args) {
int score = 100;
if(score<0 || score>100){
System.out.println("你的成绩是错误的");
}else if(score>=90 && score<=100){
System.out.println("你的成绩属于优秀");
}else if(score>=80 && score<90){
System.out.println("你的成绩属于好");
}else if(score>=70 && score<80){
System.out.println("你的成绩属于良");
}else if(score>=60 && score<70){
System.out.println("你的成绩属于及格");
}else {
System.out.println("你的成绩属于不及格");
}
}
8.1.5 if 语句和三元运算符的互换
在某些简单的应用中，if语句是可以和三元运算符互换使用的。
public static void main(String[] args) {
int a = 10;
int b = 20;
//定义变量，保存a和b的较大值
int c;
if(a > b) {
c = a;
} else {
c = b;
}
//可以上述功能改写为三元运算符形式
c = a > b ? a:b;
}
8.2 选择语句
8.2.1 选择语句–switch
switch(表达式) {
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
...
default:
语句体n+1;
break;
}
switch 语句中，表达式的数据类型，可以是byte，short，int，char，enum（枚举），JDK7后可以接收字符串。
8.2.2 case 的穿透性
在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。
8.3 循环语句
8.3.1 循环语句1–for
for(初始化表达式①; 布尔表达式②; 步进表达式④){
循环体③
}
8.3.2 循环语句2–while
初始化表达式①
while(布尔表达式②){
循环体③
步进表达式④
}
8.3.3 循环语句3–do…while
初始化表达式①
do{
循环体③
步进表达式④
}while(布尔表达式②);
8.3.4 循环语句的区别
for 和 while 的小区别：
- 控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
- 在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。
8.3.5 跳出语句
break
使用场景：终止 switch或者循环
- 在选择结构 switch语句中
- 在循环语句中
- 离开使用场景的存在是没有意义的
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++) {
//需求:不打印第三次HelloWorld
if(i == 3){
continue;
}
System.out.println("HelloWorld"+i);
}
}
8.3.6 死循环
死循环： 也就是循环中的条件永远为true，死循环的是永不结束的循环。例如：while(true){}
应用死循环的场景举例：我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。
8.3.7 嵌套循环
嵌套循环:是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数
嵌套循环格式：
for(初始化表达式①; 循环条件②; 步进表达式⑦) {
for(初始化表达式③; 循环条件④; 步进表达式⑥) {
执行语句⑤;
}
}
9. 数组
9.1 数组定义和访问
容器： 是将多个数据存储到一起，每个数据称为该容器的元素。
9.1.1 数组的定义
数组概念： 数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
- 定义方式一
格式：
数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];
数组定义格式详解：
数组存储的数据类型： 创建的数组容器可以存储什么数据类型
[] : 表示数组
数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组
new ：关键字，创建数组使用的关键字
数组存储的数据类型： 创建的数组容器可以存储什么数据类型
[ 长度]：数组的长度，表示数组容器中可以存储多少个元素
注意：数组有定长特性，长度一旦指定，不可更改
举例：
int[] arr = new int[3]; //定义可以存储3个整数的数组容器
- 定义方式二
格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
举例：
int[] arr = new int[]{
1,2,3,4,5}; //定义存储1，2，3，4，5整数的数组容器
- 定义方式三
格式：
数据类型[] 数组名 = {元素1,元素2,元素3…};
举例：
int[] arr = {
1,2,3,4,5}; //定义存储1，2，3，4，5整数的数组容器
9.1.2 数组的访问
索引： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
索引格式：
数组名[索引]
数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为： 数组名 .length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为 数组名 .length-1 。
索引访问数组中的元素：
- 数组名 [索引]=数值，为数组中的元素赋值
- 变量 =数组名[索引]，获取出数组中的元素
public static void main(String[] args) {
//定义存储int类型数组，赋值元素1，2，3，4，5
int[] arr = {
1,2,3,4,5};
//为0索引元素赋值为6
arr[0] = 6;
//获取数组0索引上的元素
int i = arr[0];
System.out.println(i);
//直接输出数组0索引元素
System.out.println(arr[0]);
}
9.2 数组原理内存图
内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。
Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。
9.2.1 Java 虚拟机的内存划分
| 区域名称 | 作用 |
|---|---|
| 寄存器 | 给CPU使用，和我们开发无关 |
| 本地方法栈 | JVM在使用操作系统功能的时候使用，和我们开发无关 |
| 方法区 | 存储可以运行的class文件 |
| 堆内存 | 存储对象或者数组，new来创建的，都存储在堆内存 |
| 方法栈 | 方法运行时使用的内存，比如main方法运行，进入方法栈中执行 |
9.3 数组在内存中的存储
两个数组内存图
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) {
// 定义数组，存储3个元素
int[] arr = new int[3];
//数组索引进行赋值
arr[0] = 5;
arr[1] = 6;
arr[2] = 7;
//输出3个索引上的元素值
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//定义数组变量arr2，将arr的地址赋值给arr2
int[] arr2 = arr;
arr2[1] = 9;
System.out.println(arr[1]);
}
9.4 数组的常见操作
9.4.1 数组越界异常
public static void main(String[] args) {
int[] arr = {
1,2,3};
System.out.println(arr[3]);
}
创建数组，赋值3个元素，数组的索引就是0，1，2，没有3索引，因此我们不能访问数组中不存在的索引，程序运行后，将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中，数组的越界常是不能出现的，一旦出现了，就必须要修改我们编写的代码。
9.4.2 数组空指针异常
public static void main(String[] args) {
int[] arr = {
1,2,3};
arr = null;
System.out.println(arr[0]);
｝
arr = null 这行代码，意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了，因此运行的时候会抛出 NullPointerException 空指针异常。
9.4.3 数组遍历【重点】
数组遍历： 就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
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]);
}
}
9.4.4 数组获取最大值元素
最大值获取： 从数组的所有元素中找出最大值。
public static void main(String[] args) {
int[] arr = {
5, 15, 2000, 10000, 100, 4000 };
//定义变量，保存数组中0索引的元素
int max = arr[0];
//遍历数组，取出每个元素
for (int i = 0; i < arr.length; i++) {
//遍历到的元素和变量max比较
//如果数组元素大于max
if (arr[i] > max) {
//max记录住大值
max = arr[i];
}
}
System.out.println("数组最大值是： " + max);
}
9.4.5 数组反转
数组的反转： 数组中的元素颠倒顺序，例如原始数组为1,2,3,4,5，反转后的数组为5,4,3,2,1
public static void main(String[] args) {
int[] arr = {
1, 2, 3, 4, 5 };
/*
循环中定义变量min=0最小索引
max=arr.length‐1最大索引
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]);
}
}
9.5 数组作为方法参数和返回值
9.5.1 数组作为方法参数
数组作为方法参数传递，传递的参数是数组内存的地址。
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]);
}
}
9.5.2 数组作为方法返回值
public static void main(String[] args) {
//调用方法，接收数组的返回值
//接收到的是数组的内存地址
int[] arr = getArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
/*
方法，返回值是数组类型
return返回数组的地址
*/
public static int[] getArray() {
int[] arr = {
1, 3, 5, 7, 9 };
//返回数组的地址，返回到调用者
return arr;
}
注：一个方法只能有 0或者 1个返回值，如果希望一个方法中产生多个结果数据进行返回，可以使用一个数组作为返回值类型即可。
9.5.3 方法的参数类型区别
- 方法的参数为基本类型时,传递的是数据值.
public static void main(String[] args) {
int a = 1;
int b = 2;
System.out.println(a);
System.out.println(b);
change(a, b);
System.out.println(a);
System.out.println(b);
}
public static void change(int a, int b) {
a = a + b;
b = b + a;
}
- 方法的参数为引用类型时,传递的是地址值.
public static void main(String[] args) {
int[] arr = {
1,3,5};
System.out.println(arr[0]);
change(arr);
System.out.println(arr[0]);
}
public static void change(int[] arr) {
arr[0] = 200;
}
10. 开发工具IntelliJ IDEA
10.1 IDEA 软件安装
( 此处略过 )
10.2 IDEA 常用快捷键
| 快捷键 | 功能 |
|---|---|
| Alt+Enter | 导入包，自动修正代码 |
| Ctrl+Y | 删除光标所在行 |
| Ctrl+D | 复制光标所在行的内容，插入光标位置下面 |
| Ctrl+Alt+L | 格式化代码 |
| Ctrl+/ | 单行注释 |
| Ctrl+Shift+/ | 选中代码注释，多行注释，再按取消注释 |
| Alt+Ins | 自动生成代码，toString，get，set等方法 |
| Alt+Shift+ 上下箭头 | 移动当前代码行 |
| Ctrl+空格 (需自行修改) | 补全代码 |
10.3 IDEA 修改快捷键
在IDEA工具中， Ctrl+ 空格 的快捷键，可以帮助我们补全代码，但是这个快捷键和Windows中的输入法切换快捷键冲突，需要修改IDEA中的快捷键。
File ->Settings->keymap->Main menu->code->Completion->Basic
双击 Basic ->remove->Ctrl+空格
再次双击 Basic ->Add Keyboard->键入 Alt+/->点击OK
