java从零开始系统性学习完整超全资源+笔记(还在更新中）

java从零开始系统性学习完整超全资源+笔记(还在更新中）

前言

资源来自：王汉远java基础，
B站视频： https://www.bilibili.com/video/BV1b4411g7bj/?spm_id_from=333.1007.top_right_bar_window_custom_collection.content.click&vd_source=33eb2731cb742522d03acd26e5b17ba3
网盘链接（含源代码和笔记资料PPT）：1,java基础学习：
链接：https://pan.baidu.com/s/1lxrpAW6yAxzSouYQz-GaKg
提取码：anr4
课件：
链接：https://pan.baidu.com/s/1zV-4jtSKHzkmS4c6wp7Qag
提取码：cgw6
下半部分
链接：https://pan.baidu.com/s/15xOnqGo-CQelWyk4naVsJQ
提取码：sk57
之前学的java忘记差不多了，最近得好好再学一遍，计划三周学完，特写此笔记便于后期做毕设项目和工作使用。
学习开始日期：2022.11.2
学习截止日期：进行中
**注意：**视频是基于eclipse进行编写的，最好还是用IDEA，eclipse老旧了，但是基本知识点还是不变的，等下学完这些视频，和IEDA里面有不同的地方再进行对比补充笔记。
IDEA版本：链接：https://pan.baidu.com/s/1znJc2zSpj84cvB6DGQ5NAw
提取码：pj3r

---

一、变量与数据类型

Java语言概述

1. java语言的跨平台原理

• 平台:指的是操作系统(Windows，Linux， Mac)
• 跨平台: Java程序可以在任意操作系统上运行，一次编写到处运行
• 原理:实现跨平台需要依赖Java的虚拟机JVM ( Java Virtual Machine）
  
  2.JRE和JDK
  JRE：java的运行环境
  JDK：java的开发工具包

联系：使用JDK开发完成java程序，交给JRE去运行。

常用DOS命令

1. 打开控制台
win+ R，然后cmd回车；或者开始-搜索-输入cmd-回车。
常见DOS命令

• d:回车盘符切换

• dir(directory):列出当 前目录下的文件以及文件夹
  

• cd (change directory)改变指定目录(进入指定目录)
  

• 进入cd目录; cd 目录名称，或者目录路径
  同上图

• 回退cd…; cd
  

• cls: (clear screen)清屏- exit:退出dos命令行
  

HelloWorld案例

1.Notepad++的使用
下载安装之后新建文件，点击上方的设置按钮——选择首选项——新建——格式：windows——语言：java——编码：ANSI。

2.HelloWorld案例编写

• 首先定义一个类
  public class 类名
• 在类定义后加上一对大括号{}
• 在大括号中间添加一个主(main)方法/函数
  public static void main(String [] args){ }
• 在主方法的大括号中间添加一行输出语句
  System.out.println(“HelloWorld”);
  完整代码：

public class HelloWorld {
	public static void main(String [] args) {
		System.out.println(“HelloWorld”);
	}
}

单词拼写注意问题：

---

注释

●注释概述
-用于解释说明程序的文字
●Java中注释分类
-单行注释
●格式: //注释文字
-多行注释
●格式:/注释文字/
-文档注释
●格式: /*注释文字/
●注释的作用
-解释说明程序，提高程序的阅读性

关键字

• 关键字概述
  被Java语言赋予特定含义的单词
• 关键字特点
  -组成关键字的字母全部小写
  -常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观，所以我们不需要去死记硬背，在今后的学习中重要的关键字也会不断的出来。
  
  

常量

常量概述:
在程序执行的过程中，其值不可以发生改变的量
常量分类
-字符串常量
用双引号括起来的内容(“HelloWorld”)
-整数常量
所有整数(12,-23)
-小数常量
所有小数(12.34)
-字符常量.
用单引号括起来的内容(a,‘A’,‘0’)
-布尔常量.
较为特有，只有true和false
空常量
null(数组部分讲解)

public class HelloWorld{
	public final static String CONSTANT = "HelloWorld";
	public final static float PI = 3.14f;
	/*主方法*/
	public static void main(String[] args){
		System.out.println(CONSTANT);
	}

变量

• 变量概述

  • 在程序执行的过程中，在某个范围内其值可以发生改变的量
  • 从本质上讲，变量其实是内存中的一小块区域

• 变量定义格式

  • 数据类型 变量名=初始化值;
  • 注意:格式是固定的，记住格式，以不变应万变

• 计算机存储单元
  变量是内存中的小容器，用来存储数据。那么计算机内存是怎么存储数据的呢？无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母b表示。而计算机最小的存储单元叫“字节（byte）”，通常用大写字母B表示，字节是由连续的8个位组成。
  除了字节外还有一些常用的存储单位，大家可能比较熟悉，我们一起来看看：
  1B（字节） = 8bit
  1KB = 1024B
  1MB = 1024KB
  1GB = 1024MB
  1TB = 1024GB

数据类型

Java语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间，所以它们表示的数据大小也是不一样的。

基本数据类型（4类8种）

标示符

• 作用
  给包,类,方法,变量等起名字

• 组成规则
  由字符，下划线_，美元符$组成

• 这里的字符采用的是unicode字符集，所以包括英文大小写字母，中文字符，数字字符等。

• 注意事项

  • 不能以数字开头
  • 不能是Java中的关键字

• 命名规则

  • 基本要求
    见名知意

• 常见命名的规则

  • 包 (其实就是文件夹,用于对类进行管理)
    全部小写，多级包用点隔开。
    com,cn,com.demo

• 类

  • 一个单词首字母大写 Student,Car
  • 多个单词，每个单词首字母大写 HelloWorld

• 变量或者方法

  • 一个单词首字母小写。 age,show()
  • 多个单词，从第二个单词开始每个单词首字母大写 maxAge,getAge()

编写案例演示每种不同数据类型的变量定义

变量的定义和使用

• 变量定义的注意事项

1. 变量未赋值,不能直接使用
2. 引出变量的第二种使用格式
3. 变量只在它所属的范围内有效。
4. 变量在哪对大括号内，变量就属于哪对大括号
5. 一行上可以定义多个变量，但是不建议

类型转换

• +是一个运算符, 我们应该能够看懂，做数据的加法。
  boolean类型不能转换为其他的数据类型
• 默认转换
  byte,short,char—int—long—float—double
  byte,short,char相互之间不转换，他们参与运算首先转换为int类型
• 强制转换
  目标类型 变量名=(目标类型)(被转换的数据);

---

二、Eclipse/IDEA基本使用与配置

1:基本使用

A:创建Java项目：
	点击File或者在最左侧空白处，选择Java项目，在界面中写一个项目名称，然后Finish即可。
B:创建包：展开项目，在源包src下建立一个包com.itheima
C:创建类：在com.ithiema包下建立一个类HelloWorld
	在界面中写一个类名：HelloWorld，然后finish即可。
D:编写代码
	在HelloWorld类写main方法，在main方法中写一条输出语句：我是程序员，我骄傲，我自豪。
E:编译
	自动编译，在保存的那一刻帮你做好了
F:运行
	选择要运行的文件或者在要运行的文件内容中
	右键 -- Run as - Java Application即可

2:基本配置

A:行号的显示和隐藏
	显示：在代码区域的最左边的空白区域，右键 -- Show Line Numbers即可。
	隐藏：把上面的动作再做一次。
		
B:字体大小及颜色
	a:Java代码区域的字体大小和颜色：
		window -- Preferences -- General -- Appearance -- Colors And Fonts -- Java -- Java Edit Text Font
	b:控制台
		window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console font
	c:其他文件
		window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text Font
		
C:窗体给弄乱了，怎么办?
	window -- Perspective -- Reset Perspective
		
D:控制台找不到了，怎么办?
	Window--Show View—Console

3:删除和导入项目

A:删除项目
	选中项目 – 右键 – 删除
	从项目区域中删除
	从硬盘上删除
B:导入项目
	在项目区域右键找到import
	找到General，展开，并找到
	Existing Projects into Workspace
	点击next,然后选择你要导入的项目
	注意：这里选择的是项目名称

创建eclipse程序如图

4.快捷键汇总

• 自己常用的
  注释：Ctrl+/ | Ctrl+Shift+/ 前者将当前行注释掉（行首加上//） ，后者将当前选中的内容注释掉（两端打上/* … */）
  内容辅助：Alt + / 自动写代码，类似代码提示。
  方法定位：按住Ctr1+鼠标左键，可以快速定位到对应的变量、方法或者其他的类等。
  格式化：ctrl+shift+F
  或者设置保存（ctrl+S）的时候格式化
  导包： CTRL + SHIFT + O
  

注释多行代码：ctrl+shift+/
有用的快键键整理
来自：Eclipse快捷键大全

• 编辑
  Ctrl+1 快速修复（最经典的快捷键,就不用多说了，可以解决很多问题，比如import类、try catch包围等）
  Ctrl+Shift+F 格式化当前代码
  Ctrl+Shift+M 添加类的import导入
  Ctrl+Shift+O 组织类的import导入（既有Ctrl+Shift+M的作用，又可以帮你去除没用的导入，很有用）
  Ctrl+Y 重做（与撤销Ctrl+Z相反）
  ==Alt+/ 内容辅助（帮你省了多少次键盘敲打，太常用了） ==
  Ctrl+D 删除当前行或者多行
  ==Alt+↓ 当前行和下面一行交互位置（特别实用,可以省去先剪切,再粘贴了） ==
  Alt+↑ 当前行和上面一行交互位置（同上）
  Ctrl+Alt+↓ 复制当前行到下一行（复制增加）
  Ctrl+Alt+↑ 复制当前行到上一行（复制增加）
  Shift+Enter 在当前行的下一行插入空行（这时鼠标可以在当前行的任一位置,不一定是最后）
  Ctrl+/ 注释当前行,再按则取消注释

• 选择
  Alt+Shift+↑ 选择封装元素
  Alt+Shift+← 选择上一个元素
  Alt+Shift+→ 选择下一个元素
  Shift+← 从光标处开始往左选择字符
  Shift+→ 从光标处开始往右选择字符
  Ctrl+Shift+← 选中光标左边的单词
  Ctrl+Shift+→ 选中光标又边的单词

• 移动
  Ctrl+← 光标移到左边单词的开头，相当于vim的b
  Ctrl+→ 光标移到右边单词的末尾，相当于vim的e

• 搜索
  Ctrl+K 参照选中的Word快速定位到下一个（如果没有选中word，则搜索上一次使用搜索的word）
  Ctrl+Shift+K 参照选中的Word快速定位到上一个
  Ctrl+J 正向增量查找（按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在状态栏中显示没有找到了,查一个单词时,特别实用,要退出这个模式，按escape建）
  Ctrl+Shift+J 反向增量查找（和上条相同,只不过是从后往前查）
  Ctrl+Shift+U 列出所有包含字符串的行
  Ctrl+H 打开搜索对话框
  Ctrl+G 工作区中的声明
  Ctrl+Shift+G 工作区中的引用

• 导航
  Ctrl+Shift+T 搜索类（包括工程和关联的第三jar包）
  Ctrl+Shift+R 搜索工程中的文件
  Ctrl+E 快速显示当前Editer的下拉列表（如果当前页面没有显示的用黑体表示）
  F4 打开类型层次结构
  F3 跳转到声明处
  Alt+← 前一个编辑的页面
  Alt+→ 下一个编辑的页面（当然是针对上面那条来说了）
  Ctrl+PageUp/PageDown 在编辑器中，切换已经打开的文件

• 调试
  F5 单步跳入
  F6 单步跳过
  F7 单步返回
  F8 继续
  Ctrl+Shift+D 显示变量的值
  Ctrl+Shift+B 在当前行设置或者去掉断点
  Ctrl+R 运行至行(超好用，可以节省好多的断点)

• 重构
  （一般重构的快捷键都是Alt+Shift开头的了）
  Alt+Shift+R 重命名方法名、属性或者变量名 （是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力）
  Alt+Shift+M 把一段函数内的代码抽取成方法 （这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用）
  Alt+Shift+C 修改函数结构（比较实用,有N个函数调用了这个方法,修改一次搞定）
  Alt+Shift+L 抽取本地变量（ 可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候）
  Alt+Shift+F 把Class中的local变量变为field变量 （比较实用的功能）
  Alt+Shift+I 合并变量（可能这样说有点不妥Inline）
  Alt+Shift+V 移动函数和变量（不怎么常用）
  Alt+Shift+Z 重构的后悔药（Undo）

• 其他
  Alt+Enter 显示当前选择资源的属性，windows下的查看文件的属性就是这个快捷键，通常用来查看文件在windows中的实际路径
  Ctrl+↑ 文本编辑器 上滚行
  Ctrl+↓ 文本编辑器 下滚行
  Ctrl+M 最大化当前的Edit或View （再按则反之）
  Ctrl+O 快速显示 OutLine（不开Outline窗口的同学，这个快捷键是必不可少的）
  Ctrl+T 快速显示当前类的继承结构
  Ctrl+W 关闭当前Editer（windows下关闭打开的对话框也是这个，还有qq、旺旺、浏览器等都是）
  Ctrl+L 文本编辑器 转至行
  F2 显示工具提示描述

• idea与eclipse快捷键对比
  参考文章：IDEA和Eclipse的比较
  

三、运算符和表达式

运算符

代码

package com.yunSuanFu;

public class YunSuanFu {
/**
 * Alt + / 自动写代码，类似代码提示
 */

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//加法
		int c = add(1,2);
		System.out.println(c);
		//减法
		float d = substract(3, 2);
		System.out.println(d);
		//乘法
		YunSuanFu yunsuanfu = new YunSuanFu();	//不能将静态的方法写在非静态的方法中
//		非静态的变量(动态的类）就要新建一个对象
		int e = yunsuanfu.multiply(5, 6);
		System.out.println(e);
		//除法
		float f = yunsuanfu.divide(33.3f, 3.0f);
		System.out.println(f);
		int h = yunsuanfu.divide(10, 5);
		System.out.println("整数的除法" + h);
		//取余
		long g = yunsuanfu.mod(10, 3);
		System.out.println(g);			
	}
	/** 文档注释  
	* 两个整数相加
	* @param a
	* @param b
	* return */
	public static int add(int a,int b) {
		int c = a + b;
		return c;
	}
	/** 减法*/
	public static float substract(float a,float b) {
		float c = a - b;
		return c;
	}
	/**  乘法*/
	public int multiply(int a,int b) {
		int c = a * b;
		return c;
	}
	/** 除法*/
	public float divide(float a,float b) {
		return a/b;
	}
	
	public int divide(int a,int b) {
		return a/b;
	}
	
	/** 取余*/
	public long mod(long a,long b) {
		return a % b;		
	}
}

运算符

• 对常量和变量进行操作的符号称为运算符
  表达式
• 用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。不同运算符连接的式子体现的是不同类型的表达式。
  定义两个int类型的变量a,b，做加法(a+ b)
• 常用运算符
  算术运算符
  赋值运算符
  关系运算符
  逻辑运算符
  三元运算符

算术运算符
• +,-,*,/的基本使用
%的使用
– %和/的区别
• ++,–
自增自减

• 字符和字符串参与+运算

int i = 10;
		int j = 5;
		System.out.println(++i);	//++放在前面的时候先加1再做其他运算
		System.out.println(j++);	//++放在后面的时候先调用它的值再加1
		System.out.println(j);

输出结果：

11
5
6

• 字符参与运算
– 其实是拿该字符对应的数值来操作
– ‘a’ 97
– ‘A’ 65
– ‘0’ 48

• 字符串参与运算
– 这里其实做的不是加法运算，而是字符串拼接。
– 字符串和其他类型的数据做拼接，结果是字符串类型的。

• 赋值运算符
  • 基本的赋值运算符： =
  • 扩展的赋值运算符：+=,-=,*=,/=,…
  关系运算符
  • ==,!=,>,>=,<,<=
  • 关系运算符的结果都是boolean型，也就是要么是true，要么是false。
  • 注意事项
  – 关系运算符“ ==”不能误写成“=” 。

-逻辑运算符
• 逻辑运算符用于连接布尔型表达式，在Java中不
可以写成33 && x<6 。
• &,|,^,!
• &&,||
– “&”和“&&”的区别：
• 单&时，左边无论真假，右边都进行运算；
• 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
• “|”和“||”的区别同理，双或时，左边为真，右边不参与运算。第一个左边为假判断右边第二个。

• 三元运算符
  • 格式
  – (关系表达式)?表达式1：表达式2；
  – 如果条件为true，运算后的结果是表达式1；
  – 如果条件为false，运算后的结果是表达式2；
  • 示例：
  – 获取两个数中大数。
  – int x=3,y=4,z;
  – z = (x>y)?x:y;//z变量存储的就是两个数的大数。

键盘录入

键盘录入数据概述
我们目前在写程序的时候，数据值都是固定的，但是实际开发中，数据值肯定是变化的，所以，把数据改进为键盘录入，提高程序的灵活性。
如何实现键盘录入数据呢?(目前先记住使用)

导包(位置放到class定义的上面)
import java.util.Scanner;
创建对象
Scanner sc = new Scanner(System.in);
接收数据
int x = sc.nextInt();

核心步骤：

//0.导入包
import java.util.Scanner;
// 1.创建键盘录入的对象
		Scanner sc = new Scanner(System.in);
		// 2.接收数据
		System.out.println("请输入第一个数据:");
		int a = sc.nextInt();
		System.out.println("请输入第二个数据:");
		int b = sc.nextInt();

练习：
键盘录入两个数据，并对这两个数据求和，输出其结果
键盘录入两个数据，获取这两个数据中的最大值
键盘录入两个数据，比较这两个数据是否相等
键盘录入三个数据，获取这三个数据中的最大值

代码：

package com.demo;

import java.util.Scanner;

/**
 * 引入包 CTRL + SHIFT + O
 */

public class ScannerDemo {
	public static void main(String[] args) {
		// 1.创建键盘录入的对象
		Scanner sc = new Scanner(System.in);
		// 2.接收数据
		System.out.println("请输入第一个数据:");
		int a = sc.nextInt();
		System.out.println("请输入第二个数据:");
		int b = sc.nextInt();
		// 对数据进行求和
		int sum = a + b;
		System.out.println("sum = " + sum);
		// 三元组运算符判断两个数是否相等
		boolean flag = ((a == b) ? true : false);
		System.out.println("flag:" + flag);
		System.out.println("请输入第三个数据:");
		int c = sc.nextInt();
		int temp = ((a > b) ? a : b);
		int max = ((temp > c) ? temp : c);
		System.out.println("max: " + max);

	}
}

四、条件判断与循环语句

选择结构

• if
  if语句有三种格式
  if语句第一种格式：

if(关系表达式) {
		     语句体
	}

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

if语句第二种格式：

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

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

if语句第三种格式：

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

• switch
  switch语句格式：

switch(表达式) {
	      case 值1：
			语句体1;
			break;
		    case 值2：
			语句体2;
			break;
		    …
		    default：	
			语句体n+1;
			break;
    }

格式解释
switch表示这是switch语句
表达式的取值：byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是String
case后面跟的是要和表达式进行比较的值
语句体部分可以是一条或多条语句
break表示中断，结束的意思，可以结束switch语句
default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

循环结构

• for
  for循环语句格式：

for(初始化语句;判断条件语句;控制条件语句) {
         循环体语句;
    }

执行流程
A:执行初始化语句
B:执行判断条件语句，看其结果是true还是false
如果是false，循环结束。
如果是true，继续执行。
C:执行循环体语句
D:执行控制条件语句
E:回到B继续

• while
  while循环语句格式：

基本格式
   while(判断条件语句) {
         循环体语句;
   }
改版格式
   初始化语句;
   while(判断条件语句) {
         循环体语句;
         控制条件语句;
    }

• do … while
  do…while循环语句格式：
  基本格式

 do {
         循环体语句;
   }while((判断条件语句);
改版格式
   初始化语句;
   do {
         循环体语句;
         控制条件语句;
    } while((判断条件语句);

• for while do…while对比
  虽然可以完成同样的功能，但是还是有小区别：
  do…while循环至少会执行一次循环体。
  for循环和while循环只有在条件成立的时候才会去执行循环体
  for循环语句和while循环语句的小区别：
  使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
• continue 与 break

  • continue的使用场景：
    在循环语句中
    离开使用场景的存在是没有意义的
    continue的作用：
    单层循环对比break，然后总结两个的区别
    break 退出当前循环
    continue 退出本次循环

  • break的使用场景：
    在选择结构switch语句中
    在循环语句中
    离开使用场景的存在是没有意义的
    break的作用：
    跳出单层循环

随机数

作用：
用于产生一个随机数
使用步骤(和Scanner类似)

导包
import java.util.Random;
创建对象
Random r = new Random();
获取随机数
int number = r.nextInt(10);
//10表示随机数的范围0-10

产生的数据在0到10之间，包括0，不包括10。

Random r = new Random();
int number = r.nextInt(10);	

如何获取一个1-100之间的随机数呢?

Random r = new Random();
int number = r.nextInt(10) + 1;	//在结果出加1，随机数是默认范围从0开始。

综合练习
猜数字小游戏案例
系统产生一个1-100之间的随机数，请猜出这个数据是多少。
分析：
A:系统产生一个1-100之间的随机数
Random r = new Random();
int number = r.nextInt(100) + 1;
B:键盘录入我们要猜的数据
C:比较这两个数据,用if语句实现
大了：提示大了
小了：提示小了
猜中了：提示恭喜你,猜中了
D:多次猜数据,而我们不知道猜多少次,怎么办呢?
==while(true) {循环体语句;}==表示一直运行。

public class RandomTest {
	public static void main(String[] args) {
		//系统产生一个1-100之间的随机数
		Random r = new Random();
		//获取随机数
		int number = r.nextInt(100) + 1;
		
		//多次猜数据
		while(true) {	//while(true)表示一直运行
			//键盘录入我们要猜的数据
			Scanner sc = new Scanner(System.in);
			//接收数据
			System.out.println("请输入你要猜的数据(1-100)：");
			int guessNumber = sc.nextInt();
			
			//比较这两个数据,用if语句实现
			if(guessNumber > number) {
				System.out.println("你猜的数据"+guessNumber+"大了");
			}else if(guessNumber < number) {
				System.out.println("你猜的数据"+guessNumber+"小了");
			}else {
				System.out.println("恭喜你,猜中了");
				break;	//跳出循环
			}
		}
	}
}

数组

一维数组&内存图解

• 数组的概念
  • 定义格式

格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
注意：这两种定义做完了，数组中是没有元素值的。

数组初始化概述：
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式：
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：
int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：
int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
其实这种写法还有一个简化的写法
int[] arr = {1,2,3};

java中的内存分配：
Java 程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈 存储局部变量
堆 存储new出来的东西
方法区 (面向对象进阶讲)
本地方法区 (和系统相关)
寄存器 (给CPU使用)

• 数组操作的两个常见小问题
  1.数组索引越界
  ArrayIndexOutOfBoundsException
  访问到了数组中的不存在的索引时发生。
  2.空指针异常
  NullPointerException
  数组引用没有指向对象，却在操作对象中的元素时。

• 内存图解1：
  定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。
  

• 内存图解2：
  定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。
  

• 内存图解3：
  定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素。
  

• 练习
  一维数组遍历：

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

• 获取数值长度：数值名.length
• 数组获取最值(获取数组中的最大值最小值)
  先画图，然后讲解

二维数组

• 定义格式
  数据类型[][] 数组名;
  数据类型 数组名[][]; 不推荐
  数据类型[] 数组名[]; 不推荐
• 初始化方式
  数据类型[][] 变量名 = new 数据类型[m][n];
  数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
  简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
• 二维数组遍历
  int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};