java第二章

3天的作业手写作业：

###  第一章：Java基础：

<hr/>

### 1️⃣ 初识 Java:

#### 1、常识知识：

> 语言：人与人交流沟通的表达方式
>
> 计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言
>
> 编程语言分类：
>
> 编译型
>
> ​    优点：执行效率高
>
> ​    缺点：平台依赖重，跨平台不方便
>
> 解释型
>
> ​    优点：易于跨平台
>
> ​    缺点：源代码在一般情况下不便于加密,执行效率相对没有那么高
>
> 混合型：
>
> ​    可编译可解释
>
> * 计算机语⾔发展历史
> * 第⼀代 计算机语⾔：01010100010111000
> * 第⼆代 汇编语⾔00000011写成汇编语⾔就是 ADD，只要还原成⼆进制， 汇编语⾔就可以被 CPU 直接执⾏，所以它是最底层的低级语⾔
> * 第三代 ⾼级语⾔
> * ⾯向过程：c，Fortran ⾯向对象：c++，java，c#

####  Java的三大平台

* JavaSE

  ​    Java 语言的（标准版），用于桌面应用的开发，是其他两个版本的基础。

* JavaME

  ​    Java 语言的（小型版），用于嵌入式消费类电子设备。

* JavaEE 至臻

  ​    Java 语言的（企业版），用于 Web 方向的网站开发。

  

### Java 基础语法

java⽂件名：

⽂件名必须和类名相同，后缀为.java； 否则会出错

类class：

表示声明⼀个类，类名的⾸字⺟需要⼤写，多个单词的话需要使⽤驼峰形式

HelloWorld、UserAccount、User

⽅法：

⽅法名需要⼩写字⺟开头，若有⼏个单词，则后续的采⽤驼峰形式

主⽅法：

固定搭配，需要硬记，所有程序的主⼊⼝ public static void main(String [] args)

所有变量、名称都是⼤⼩写敏感的！！！！

```JAVA
 //程序入口：登陆器；进去之后才会出现游戏界面；
    //所有执行的程序；都需要入口方法来执行；
    //main 英文含义叫主体；
    //访问权限修饰符：公开的访问权限：Public 公开的；所有人都可以访问;
    //在程序里 指 在项目下所有包 都可以i访问；
    //stactic 英文叫静态的；--动态的；
    //静态 和 动态 IP; 动态时刻在改变； 199；188；166；
    //一变不变； 一直在一个地方; 类种静态方法；
    //void 空的；没有返回值；
    //main 方法名；（参数）
    //String[] 数组  args 参数名；
    public static void main(String[] args) {
        //程序入口方法；并且声明了访问权限：public 公开的；在项目下所有类是不是都可以访问；
        //stactic 是来声明这个方法是静态方法；类方法；
        //void 空的； main 方法名；（参数）；
        //String[] args 参数名；
        //Main 主体 声明声明什么内容呢？
        //输出语句：
        //由Main 来执行；
        System.out.println("Hello wolrd");
        //程序 让你说一句话：Hello wolrd；
        System.out.print("Hello wolrd");
        System.out.println("贴在一起");
        //程序告诉cpu ;你不换行打印一句话：光标处；
```

### Java跨平台工作原理

平台：指的是操作系统。 

* Windows
* MacOS
* Linux

####  跨平台

​    Java 程序不需要进行任何修改，就可以在任意操作系统上运行。 

注意：不是所有的语言都具备这样的特征。比如：C#只能在windows上运行。

编写的Java代码并不是直接运行在操作系统当中的。而是运行在安装的JVM虚拟机中的。每一个操作系统都会对应各自版本的虚拟机。

### jdk:

JVM、JRE、JDK关系？

- JVM
- Java Virtual Machine Java 虚拟机，简单看成⼀个操作系统，java程序会⾸先被编译
- 为.class的字节码，根据字节码指令进⾏识别并调⽤上层操作系统
- JRE
- Java Runtime Environment java 运⾏时环境, 是整个 Java 程序运⾏的核⼼
- JDK
- Java Development Kit 是我们的开发⼯具包，它集成了 JRE, 是整个 Java 开发的核⼼
- 总结
- JRE = 基本类库 + JVM，没有JRE，java程序⽆法运⾏
- JDK = JRE+JVM+开发⼯具包
- Java核⼼优势:⼀次编译，到处运⾏，能够跨平台运⾏的核⼼在于 JVM

- **JRE ** (Java Runtime Environment) ：是Java程序的运行时环境，包含`JVM` 和运行时所需要的`核心类库` 。
- **JDK**  (Java Development Kit)：是Java程序开发工具包，包含`JRE` 和开发人员使用的工具。

我们想要运行一个已有的Java程序，那么只需安装`JRE` 即可。

我们想要开发一个全新的Java程序，那么必须安装`JDK` 。

> 小贴士：
>
> 三者关系： JDK > JRE > JVM

#### JDK的安装目录介绍

| 目录名称 | 说明                                                         |
| -------- | ------------------------------------------------------------ |
| bin      | 该路径下存放了JDK的各种工具命令。javac和java就放在这个目录。 |
| conf     | 该路径下存放了 JDK 的相关配置文件                            |
| include  | 该路径下存放了一些平台特定的头文件                           |
| jmods    | 该路径下存放了 JDK 的各种模块                                |
| legal    | 该路径下存放了 JDK 各模块的授权文档                          |
| lib      | 该路径下存放了 JDK 工具的一些补充 JAR 包                     |

#### 什么是注释

​    **注释**：就是对代码的解释和说明。其目的是让人们能够更加轻松地了解代码。为代码添加注释，是十分必须要的，它不影响程序的编译和运行。

#### 注释的分类

- 单行注释

  ​    格式：`// 注释信息`

- 多行注释

  ​    格式： `/* 注释信息 */`

- 文档注释

  ​    格式：`格式：/** 注释信息 */` 

  

#### project（项目、工程）

​    淘宝、京东、网站都属于一个个项目，IDEA中就是一个个的Project。

##### module（模块）

​    在一个项目中，可以存放多个模块，不同的模块可以存放项目中不同的业务功能代码。在黑马程序员的官方网站中，至少包含了以下模块：

* 论坛模块
* 报名、咨询模块

为了更好的管理代码，我们会把代码分别放在两个模块中存放。

##### package（包）

​    一个模块中又有很多的业务，以黑马程序员官方网站的论坛模块为例，至少包含了以下不同的业务。

* 发帖
* 评论

为了把这些业务区分的更加清楚，就会用包来管理这些不同的业务。

##### class（类）

​    就是真正写代码的地方。

####  小结

* 层级关系

  ​    project - module - package - class

* 包含数量

  ​    project中可以创建多个module
  ​    module中可以创建多个package
  ​    package中可以创建多个class

  ​    这些结构的划分，是为了方便管理类文件的。

### IDEA中层级结构介绍

####  结构分类

* project（项目、工程）
* module（模块）
* package（包）
* class（类）

### **关键字**

Java自己保留的一些单词，作为特殊功能的，例如：public、class、byte、short、int、long、double… 

我们不能用来作为类名或者是变量名称，否则报错。

注意：关键字很多，不用刻意去记。

**标志符**

标志符就是由一些字符、符号组合起来的名称，用于给类，方法，变量等起名字的规矩。

基本要求：由数字、字母、下划线(_)和美元符($)等组成

强制要求：不能以数字开头、不能是关键字、区分大小写

**基本命令规范**

变量名称：满足标识符规则，建议全英文、有意义、首字母小写，满足“驼峰模式”，例如：int studyNumber = 59。

类名称： 满足标识符规则，建议全英文、有意义、首字母大写，满足“驼峰模式”，例如：HelloWorld.java。

### 面试题1：

```
Java跨平台工作原理:
你是怎么理解Java是一门「跨平台」的语言，也就是「一次编译，到处运行的」？

精确答案：
JVM 虚拟机本身不允许跨平台，每一个操作系统都有对应版本的虚拟机。允许跨平台的是 Java 程序；
Java源代码会被编译为class文件，class文件是运行在JVM之上的。
当我们日常开发安装JDK的时候，可以发现JDK是分「不同的操作系统」，JDK里是包含JVM的，所以Java依赖着JVM实现了『跨平台』
JVM是面向操作系统的，它负责把Class字节码解释成系统所能识别的指令并执行

```

### 面试题2：

```
聊聊源码文件(.java)到代码执行的过程
精确回答：
4个步骤：编译->加载->解释->执行
编译：将源码文件编译成JVM可以解释的class文件。
编译过程会对源代码程序做 「语法分析」「语义分析」「注解处理」等等处理，最后才生成字节码文件。
加载：将编译后的class文件加载到JVM中。
「解释」这个阶段它做的事情可以总结为：把字节码转换为操作系统识别的指令
在解释阶段会有两种方式把字节码信息解释成机器指令码，一个是字节码解释器、一个是即时编译器(JIT)。
「执行」这个阶段它做的事情可以总结为：操作系统把解释器解析出来的指令码，调用系统的硬件执行最终的程序指令。

```

### 2️⃣基本数据类型和变量

#### 变量的定义

变量：在程序运行过程中，其值可以发生改变的量。生活中也有很多 变量 比如年龄 、等等；

当 Java 程序运行过程中，我们需要存储一些数据，此时就可以在内存开辟一个个变量空间来存储这些可变的数据。

通俗的来讲：变量就是一个数据存储空间的表示，不同数据存入具有不同内存地址的空间，彼此相互独立。从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。

 所以，变量的组成是由：变量名、变量类型、变量值三个部分组成。

### 变量名

变量名也就是标识符，其实就是为了方便区分不同的变量。但这个名也不是随便起的，在长久的演化中，我们有了约定俗成的规范。

1.可以使用数字、字母，下划线和 $ 符号组成，但数字不能开头。

2.不能使用关键字（public、void等）和保留字（goto、def等）！关键字：被系统定义了特殊含义的单词。保留字：现在还不是关键字，未来可能有特殊含义。

3.起名要见名知意。例如：name 一看就知道是名字，password是密码等。

4.采用小驼峰式命名法（Lower Camel Case）。(所谓小驼峰命名法，即首字母小写，如果有多个单词那么后面的每个单词首字母大写。e.g. userPassword) ；另外因为支持下划线，所以有些时候会有下划线连接法命名的变量。e.g. user_password。

#### 变量的定义格式：

```
数据类型 变量名 = 初始化值; // 声明变量并赋值
int age = 18;
System.out.println(age);

// 先声明，后赋值（使用前赋值即可）
数据类型 变量名;
变量名 = 初始化值;
double money;
money = 55.5;
System.out.println(money);

int c,d; // 声明int类型的变量c和d，中间使用逗号隔开
c = 30;
d = 40;
System.out.println(c);
System.out.println(d);

使用变量时的注意事项

1. 在同一对花括号中，变量名不能重复。
2. 变量在使用之前，必须初始化（赋值）。
3. 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。
4. 定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。
```

##### Java中的数据类型

Java是一个强类型语言，Java中的数据必须明确数据类型。在Java中的数据类型包括基本数据类型和引用数据类型两种。

Java中的基本数据类型：

| 数据类型 | 关键字  | 内存占用 |                 取值范围                  |
| :------: | :-----: | :------: | :---------------------------------------: |
|   整数   |  byte   |    1     |    负的2的7次方 ~ 2的7次方-1(-128~127)    |
|          |  short  |    2     | 负的2的15次方 ~ 2的15次方-1(-32768~32767) |
|          |   int   |    4     |        负的2的31次方 ~ 2的31次方-1        |
|          |  long   |    8     |        负的2的63次方 ~ 2的63次方-1        |
|  浮点数  |  float  |    4     |        1.401298e-45 ~ 3.402823e+38        |
|          | double  |    8     |      4.9000000e-324 ~ 1.797693e+308       |
|   字符   |  char   |    2     |                  0-65535                  |
|   布尔   | boolean |    1     |                true，false                |

### 常量概述

在程序运行中，我们需要使用一些数据，但是这些数据在存储好后不应该再次发生变化（例如：π）。这时候，单纯使用变量存储，毕竟叫变量，难保未来可能被不小心重新赋值。

此时我们可以使用常量来解决此问题。

在Java中，其值不能改变的变量被称为常量。常量被final修饰，被final修饰则无法二次修改值。

常量的命名规范：(为了和变量做出区别，所以它也有一些小要求)

1.常量名所有字母都要大写。

2.如果有多个单词，多个单词之间使用下划线分隔。例如：MY_NAME

3.只能被赋值一次（被final修饰），通常定义时即对其初始化。

### 面试题：

```
常量概述

在程序运行中，我们需要使用一些数据，但是这些数据在存储好后不应该再次发生变化（例如：π）。这时候，单纯使用变量存储，毕竟叫变量，难保未来可能被不小心重新赋值。

此时我们可以使用常量来解决此问题。

在Java中，其值不能改变的变量被称为常量。常量被final修饰，被final修饰则无法二次修改值。

常量的命名规范：(为了和变量做出区别，所以它也有一些小要求)

1.常量名所有字母都要大写。

2.如果有多个单词，多个单词之间使用下划线分隔。例如：MY_NAME

3.只能被赋值一次（被final修饰），通常定义时即对其初始化。
```

### 类型转换

理解类型转换的故事举例： 假设现在有一个100斤的小麦口袋，还有一个40斤的大米口袋，如果我想把两个口袋换着装东西，40斤大米口袋内的大米自然可以放到100斤小麦口袋里(自动类型转换)，但是反之则不行，如果非要这么做，多余的小麦肯定会洒出来（强制类型转换）。

```

// 口袋：100斤小麦
double mian = 100;
// 口袋：40斤大米
int mi = 40;

mi = (int)mian;

```

赋值运算符：

```
 = 号 表示赋值给XXX；
```

####  算术运算符：

算术运算符中+，-，*，/，%

++(自增)，--(自减)

```
/ 和 % 的区别：
/ 是取两个数相除的商：
% 是取两个数相处的余数；

%是取模运算符，就是我们常说的求余数操作。

有区别的：
int a = 3; int b = a++; //执行完后,b=3。先给b赋值，再自增。

a = 3; b = ++a; //执行完后,b=4。a先自增，再给b赋值

```

**赋值运算符** 


**关系运算符**



**逻辑运算符** 


短路与和短路或采用短路的方式。从左到右计算，如果只通过运算符左边的操作数就能

够确定该逻辑表达式的值，则不会继续计算运算符右边的操作数，提高效率

**条件运算符** （三目运算符）

```
x ? y : z
其中 x 为 boolean 类型表达式，先计算 x 的值，若为 true，则整个运算的结果为表达 式 y 的值，否则整个运算结果为表达式 z 的值。
int score = 80; 
int x = -100; 
String type =score<60?"不及格":"及格";
int flag = x > 0 ? 1 : (x == 0 ? 0 : -1);
System.out.println("type= " + type); 
System.out.println("flag= "+ flag);
```

**运算符优先级的问题**


变量的分类：局部变量、实例变量、静态变量

常量的声名格式

final type varName = value ;

### 面试题1：

```
详述8种基本数据类型：
byte-short-int-long-folat-double-boolean-char
```

### 面试题2：

```
& && | || ! 的区别：
答案往上看；自己摘写下来就行； 
```

### 3️⃣   选择结构（流程控制）

不论哪一种编程语言，都会提供两种基本的流程控制结构：分支结构和循环结构。其中分支结构用于实现根据条件来选择性地执行某段代码，循环结构则用于实现根据循环条件重复执行某段代码。

## 顺序结构

任何编程语言中最常见的程序结构就是顺序结构。顺序结构就是程序从上到下逐行地执行，中间没有任何判断和跳转。如果main方法的多行代码之间没有任何流程控制，则程序总是从上向下依次执行，排在前面的代码先执行，排在后面的代码后执行。

## 分支结构：if语句第一种格式

- **if语句第一种格式：** 

```
if(条件表达式)｛
      语句体;
｝
```

**执行流程**

- 首先判断条件表达式看其结果是true还是false
- 如果是true就执行语句体
- 如果是false就不执行语句体


```java
 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("结束");｝
```

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

执行流程

- 首先判断关系表达式看其结果是true还是false

- 如果是true就执行语句体1

- 如果是false就执行语句体2
```



###  分支结构：if语句第三种格式

````
- if语句第三种格式：** if...else if ...else

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

- 执行流程
  - 首先判断关系表达式1看其结果是true还是false

  - 如果是true就执行语句体1，然后结束当前多分支

  - 如果是false就继续判断关系表达式2看其结果是true还是false

  - 如果是true就执行语句体2，然后结束当前多分支

  - 如果是false就继续判断关系表达式…看其结果是true还是false

  - …

  - 如果没有任何关系表达式为true，就执行语句体n+1，然后结束当前多分支。
````


## 分支结构：if..else嵌套

在if的语句块中，或者是在else语句块中，
又包含了另外一个条件判断（可以是单分支、双分支、多分支）

执行的特点：
（1）如果是嵌套在if语句块中的
只有当外部的if条件满足，才会去判断内部的条件
（2）如果是嵌套在else语句块中的
只有当外部的if条件不满足，进入else后，才会去判断内部的条件

### 分支结构：switch选择结构

```
switch(表达式){
    case 常量值1:
        语句块1;
        【break;】
    case 常量值2:
        语句块2;
        【break;】   
    。。。
   【default:
        语句块n+1;
        【break;】
     】
}
执行过程：

（1）入口

①当switch(表达式)的值与case后面的某个常量值匹配，就从这个case进入；

②当switch(表达式)的值与case后面的所有常量值都不匹配，寻找default分支进入;不管default在哪里

（2）一旦从“入口”进入switch，就会顺序往下执行，直到遇到“出口”，即可能发生贯穿

（3）出口

①自然出口：遇到了switch的结束}

②中断出口：遇到了break等

> 注意：
>
> （1）switch(表达式)的值的类型，只能是：4种基本数据类型（byte,short,int,char），两种引用数据类型（JDK1.5之后枚举、JDK1.7之后String）
>
> （2）case后面必须是常量值，而且不能重复
```

### 面试题1：

```
说说if和switch的区别?

1.if和switch判断条件的数据类型不同，if的判断条件数据类型是布尔类型，switch的判断条件数据类型一般是int类型。

2.if elseif 流程语句中可以允许有多个判断条件为true但只会执行第一个判断条件为true的语句体，switch语句中case条件取值是不能重复的。

3.写法上，当if 流程语句中只有一个判断条件的时候语句体的{}可以省略不写，switch语句中只有一个case条件语句体的{}也不能省略，当switch语句有多个case时，每个case后面的break关键字不能省略，不然可能会发生向下穿透的问题。

```

### 总结：

从结构化程序设计角度出发，程序有三种结构：顺序结构、选择结构和循环结构 

 选择结构 

if 单选择结构 if-else 双选择结构 if-else if-else 多选择结构 

 switch 多选择结构 

多选择结构与 switch 的关系：当布尔表达式是等值判断的情况，可使用多重选择 

结构或 switch 结构，如果布尔表达式区间判断的情况，则只能使用多重选择结构

### 4️⃣ 循环结构

 **for**循环结构（掌握）

循环：

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，

当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形 成死循环。

for循环格式：

```
for (初始化语句;条件判断语句;条件控制语句) { 

循环体语句; 

}
```

格式解释：

初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样

条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去

循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情

条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

```
public class ForTest01 { 
public static void main(String[] args) { 
//需求：输出数据1-5 for(int i=1; i<=5; i++) {
System.out.println(i); }System.out.println("--------");
//需求：输出数据5-1 
for(int i=5; i>=1; i--) {
System.out.println(i); 
} 
} 
}
```

###  **while**结构（掌握）

while循环完整格式：

```
初始化语句; 

while (条件判断语句) { 

循环体语句; 

条件控制语句; 

} 
```

while循环执行流程：

①执行初始化语句

②执行条件判断语句，看其结果是true还是false

如果是false，循环结束

如果是true，继续执行

③执行循环体语句

④执行条件控制语句

⑤回到②继续

### do-while 

去翻笔记 自己补上；

### **跳转控制语句（掌握）**

跳转控制语句（break）

跳出循环，结束循环

跳转控制语句（continue）

跳过本次循环，继续下次循环

注意： continue只能在循环中进行使用！

break 语句

* break语句用于终止某个语句块的执行
* break : 只能用于结束所在循环, 或者结束所在switch分支的执行。
* break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是
  哪一层语句块
* 使用场合
  break常用于switch结构和循环结构中

### 面试题 1:

```
For- while -do-whlie 的区别

翻笔记：补上；

```

### 5️⃣一维数组与多维数组

**数组概述和特点** 

**数组的定义** 

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先 

后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标） 

来访问它们。数组的三个基本特点： 

1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。 

2. 其元素必须是相同类型，不允许出现混合类型。 

3. 数组类型可以是任何数据类型，包括基本类型和引用类型。 

4. 数组变量属于引用类型

```
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员 变量。数组本身就是对象，Java 中对象是在堆中的，因此数组无论保存原始类型还是其 他对象类型，数组对象本身是在堆中存储的。
```

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。下面针对这三 

种方式分别讲解

```
数组的静态初始化 int [ ] a = { 1, 2, 3 };// 静态初始化基本类型数组； 
Man[ ] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；
```

```
动态初始化 数组定义与为数组元素分配空间并赋值的操作分开进行。
数组的动态初始化 int[ ] a1 = new int[2];//动态初始化数组，
先分配空间；
a1[0]=1;//给数组元素赋值； a1[1]=2;//给数组元素赋值；
```

```
3.数组的默认初始化 数组是引用类型，它的元素相当于类的实例变量，
因此数组一经分配空间，其中的每个 元素也被按照实例变量同样的方式被隐式初始化。
数组的默认初始化 
int a2[ ] = new int[2]; // 默认值：0,0 
boolean[ ] b = new boolean[2]; // 默认值：false,false 
String[ ] s = new String[2]; //
```

**数组的遍历** 

数组元素下标的合法区间：[0, length-1]。我们可以通过下标来遍历数组中的元素，遍历 

时可以读取元素的值或者修改元素的值

**for-each** **循环** 

增强 for 循环 for-each 是 JDK1.5 新增加的功能，专门用于读取数组或集合中所有的元 

素，即对数组进行遍历。

### 多维数组

多维数组可以看成以数组为元素的数组。可以有二维、三维、甚至更多维数组，但是实 

际开发中用的非常少。最多到二维数组（学习容器后，我们一般使用容器，二维数组用的都 

很少）

```JAVA
public static void main(String[ ] args) {
// Java中多维数组的声明和初始化应按从低维到高维的顺序进行
int[ ][ ] a = new int[3][ ];
a[0] = new int[2];
a[1] = new int[4];
a[2] = new int[3]; 
// int a1[ ][ ]=new int[ ][4];//非法
```

### 面试题:

```
1、数组的特点：

数组是相同类型数据的有序集合。 

数组的四个基本特点： 

其长度是确定的 

其元素必须是相同类型 

可以存储基本数据类型和引用数据类型 

数组变量属于引用类型 

数组的初始化：静态初始化、动态初始化和默认初始化。 

 数组的长度:数组名.length，下标的合法区间[0,数组名.length-1]。 

 数组拷贝:System 类中的 static void arraycopy(object src，int srcpos，object dest， int 

destpos，int length)方法。 

数组操作的常用类 java.util.Arrays 类 

打印数组:Arrays.toString(数组名); 

 数组排序:Arrays.sort(数组名); 

二分查找:Arrays.binarySearch(数组名,查找的元素); 

```