计算机（Computer）全称：电子计算机，俗称电脑。是一种能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备。由硬件和软件所组成，没有安装任何软件的计算机称为裸机。常见的形式有台式计算机、笔记本计算机、大型计算机等。
* 应用举例
* 1：科学计算
* 2、数据处理
* 3、自动控制
* 4、计算机辅助设计
* 5、人工智能
* 6、多媒体应用
* 7、计算机网络
* ...
什么是硬件?硬件举例
* 计算机硬件（Computer Hardware）是指计算机系统中由电子，机械和光电元件等组成的各种物理装置的总称。这些物理装置按系统结构的要求构成一个有机整体为计算机软件运行提供物质基础。
* 冯.诺依曼体系结构
* 计算机的硬件分成5大组成部件：运算器、控制器、存储器、输入设备和输出设备。
* 运算器和控制器是计算机的核心，合称中央处理单元（Central Processing Unit，CPU）或处理器。CPU的内部还有一些高速存储单元，被称为寄存器。其中运算器执行所有的算术和逻辑运算；控制器负责把指令逐条从存储器中取出，经译码后向计算机发出各种控制命令；而寄存器为处理单元提供操作所需要的数据。
* 存储器是计算机的记忆部分，用来存放程序以及程序中涉及的数据。它分为内部存储器和外部存储器。内部存储器用于存放正在执行的程序和使用的数据，其成本高、容量小，但速度快。外部存储器可用于长期保存大量程序和数据，其成本低、容量大，但速度较慢。
* 输入设备和输出设备统称为外部设备，简称外设或I/O设备，用来实现人机交互和机间通信。微型机中常用的输入设备有键盘、鼠标等，输出设备有显示器、打印机等。
* 计算机软件(Computer Software)是使用计算机过程中必不可少的东西，计算机软件可以使计算机按照事先预定好的顺序完成特定的功能
* 计算机软件按照其功能划分为系统软件与应用软件
* 系统软件： DOS(Disk Operating System), Windows, Linux, Unix, Mac, Android, iOS
* 应用软件：office QQ聊天 YY语言 扫雷
* A:什么是软件
* 按照特定顺序组织的计算机数据和指令的集合
* B:什么是开发
* 软件的制作过程
* C:什么是软件开发
* 借助开发工具与计算机语言制作软件
* D:什么是计算机语言
* 人与计算机之间进行信息交流沟通的一种特殊语言
* E:计算机语言的分类
* 机器语言：
* 机器语言是直接用二进制代码指令表达的计算机语言，指令是用0和1组成的一串代码，它们有一定的位数，并分成若干段，各段的编码表示不同的含义。
* 汇编语言：
* 汇编语言是使用一些特殊的符号来代替机器语言的二进制码，计算机不能直接识别，需要用一种软件将汇编语言翻译成机器语言。
* 高级语言：
* 使用普通英语进行编写源代码，通过编译器将源代码翻译成计算机直接识别的机器语言，之后再由计算机执行。
* 高级语言包括C,C++,C#,JAVA
* a:命令行方式
* 需要有一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记录住一些命令。
* b:图形化界面方式
* 这种方式简单直观，使用者易于接受，容易上手操作。
* A:d: 回车 盘符切换
* B:dir(directory):列出当前目录下的文件以及文件夹
* C:cd (change directory)改变指定目录(进入指定目录)
* D:cd.. : 退回到上一级目录
* E:cd\: 退回到根目录
* F:cls : (clear screen)清屏
* G:exit : 退出dos命令行(分割线上的需要掌握,下的了解)
* /=========================================================
* md (make directory) : 创建目录
* rd (remove directory): 删除目录
* del (delete): 删除文件,删除一堆后缀名一样的文件*.txt
* notepad 创建文件
* 删除带内容的文件夹
* rd + /s 文件夹名称(询问是否删除)
* rd + /q + /s 文件夹名称(直接删除)
* 詹姆斯·高斯林（James Gosling）1977年获得了加拿大卡尔加里大学计算机科学学士学位，1983年获得了美国卡内基梅隆大学计算机科学博士学位，毕业后到IBM工作，设计IBM第一代工作站NeWS系统，但不受重视。后来转至Sun公司，1990年，与Patrick，Naughton和Mike Sheridan等人合作“绿色计划”，后来发展一套语言叫做“Oak”，后改名为Java。
只要在需要运行java应用程序的操作系统上，先安装一个Java虚拟机(JVM Java Virtual Machine)即可。由JVM来负责Java程序在该系统中的运行。
(一处编译,到处运行) write once ,run anywhere!
A:什么是JRE
* 包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。
* JRE:JVM+类库。
* B:什么是JDK
* JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。
* 其中的开发工具：编译工具(javac.exe) 打包工具(jar.exe)等
* JDK:JRE+JAVA的开发工具。
* C:为什么JDK中包含一个JRE
* 为什么JDK中包含一个JRE呢？
网上有很多，这里简略讲
* A:JDK的下载
* a:官网 http://www.oracle.com
* b:演示下载流程
* B:JDK的安装
* a:傻瓜式安装
* 双击安装程序，然后一路next即可(但是不建议)
* b:安装的推荐方式
* 安装路径不要有中文或者特殊符号如空格等。
* 所有和开发相关的软件最好安装目录统一。
* 举例：我的JDK安装路径
* D:\develop\Java\jdk1.7.0_72
* 当提示安装JRE时，可以选择不安装。建议还是安装上。
* c:演示安装流程
* 可以先在d盘建立一个文件夹develop
* 然后演示安装过程
* C:验证安装是否成功
* a:通过DOS命令，切换到JDK安装的bin目录下。
* D:\develop\Java\jdk1.7.0_72\bin
* b:然后分别输入javac和java，如果正常显示一些内容，说明安装成功
*D:配置环境*
* a:先配置JAVA_HOME
* b:再修改path
* c:最后说一下path是有先后顺序关系的
* e:为什么要配置classpath
* f:classpath配置的原理
* g:如何配置classpath
* path和classpath的区别
* path配置的是可执行的文件.exe,配置后可以在不同的盘符下访问path路径下的可执行文件
* classpath配置的java的类文件,就是.class文件
* A:什么是常量
* 在程序执行的过程中其值不可以发生改变
* B:Java中常量的分类
* 字面值常量
* 自定义常量(面向对象部分讲)
* C:字面值常量的分类
* 字符串常量 用双引号括起来的内容
* 整数常量 所有整数
* 小数常量 所有小数
* 字符常量 用单引号括起来的内容,里面只能放单个数字,单个字母或单个符号
* 布尔常量 较为特殊，只有true和false
* 空常量 null(数组部分讲解)
* A:什么是进制
* 进制：就是进位制，是人们规定的一种进位方法。 对于任何一种进制--X进制，就表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一。
* 例如一周有七天,七进制,一年有十二个月,十二进制
* B:十进制的由来
* 十进制的由来是因为人类有十个手指
* C:二进制的由来
* 其实二进制来源与中国,请看史料记载
* 18世纪德国数理哲学大师莱布尼兹从他的传教士朋友鲍威特寄给他的拉丁文译本《易经》中，读到了八卦的组成结构，惊奇地发现其基本素数（0）（1），即《易经》的阴爻yao- -和__阳爻，其进位制就是二进制，并认为这是世界上数学进制中最先进的。20世纪被称作第三次科技革命的重要标志之一的计算机的发明与应用，其运算模式正是二进制。它不但证明了莱布尼兹的原理是正确的，同时也证明了《易经》数理学是很了不起的。
* D:八进制的由来
* 任何数据在计算机中都是以二进制的形式存在的。二进制早期由电信号开关演变而来。一个整数在内存中一样也是二进制的，但是使用一大串的1或者0组成的数值进行使用很麻烦。
* 所以就想把一大串缩短点，将二进制中的三位用一位表示。这三位可以取到的最大值就是7.超过7就进位了，这就是八进制。
* E:十六进制的由来
* 但是对于过长的二进制变成八进制还是较长，所以出现的用4个二进制位表示一位的情况，四个二进制位最大是15，这就是十六进制。
* F:不同进制表现同一个数据的形式特点
* 进制越大，表现形式越短
* A:二进制的数据表现形式
* 由0,1组成。以0b(b可以大写也可以小写)开头(JDK1.7版本可以表示二进制了)
* B:八进制的数据表现形式
* 由0,1,…7组成。以0开头
* C:十进制的数据表现形式
* 由0,1,…9组成。整数默认是十进制的
* D:十六进制的数据表现形式
* 由0,1,…9,a,b,c,d,e,f(大小写均可)。以0x开头
* E:案例演示
* 输出不同进制表现100的数据。
* 0b100
* 0100
* 100
* 0x100
* A:8421码及特点
* 8421码是中国大陆的叫法，8421码是BCD代码中最常用的一种。在这种编码方式中每一位二值代码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数码。
* B:通过8421码的方式进行二进制和十进制的相互转换
* C:二进制到八进制的简易方式
* D:二进制到十六进制的简易方式
* A:为什么要学习原码反码补码?
* 后面要学习强制类型转换,如果不知道有原反补会看不懂结果
* B:有符号数据表示法的几种方式
* 原码
* 就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
* 通过一个字节,也就是8个二进制位表示+7和-7
* 0(符号位) 0000111
* 1(符号位) 0000111
* 反码
* 正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
* 补码
* 正数的补码与其原码相同；负数的补码是在其反码的末位加1。
* A:为什么有数据类型
* Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
* B:Java中数据类型的分类
* 基本数据类型
* 引用数据类型
* 面向对象部分讲解
* C:基本数据类型分类(4类8种)
* 整数型
* byte 占一个字节 -128到127
* short 占两个字 -2^15~2^15-1
* int 占四个字节 -2^31~2^31-1
* long 占八个字节 -2^63~2^63-1
* 浮点型
* float 占四个字节 -3.403E38~3.403E38 单精度
* double 占八个字节-1.798E308~1.798E308 双精度
* 字符型
* char 占两个字节 0~65535
* 布尔型
* boolean
* boolean理论上是占八分之一个字节,因为一个开关就可以决定是true和false了,但是java中boolean类型没有明确指定他的大小
* a:作用域问题
* 同一个区域不能使用相同的变量名
* b:初始化值问题
* 局部变量在使用之前必须赋值
* c:一条语句可以定义几个变量
* int a,b,c...;
* A:案例演示
* a:int + int
* b:byte + int
* B:Java中的默认转换规则
* 取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算
* C:画图解释byte+int类型的问题
* A:强制转换问题
* int a = 10;
* byte b = 20;
* b = a + b;
* B:强制转换的格式
* b = (byte)(a + b);
* C:强制转换的注意事项
* 如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同
* A:案例演示
* 面试题:看下面的程序是否有问题，如果有问题，请指出并说明理由。
* byte b1 = 3;
* byte b2 = 4;
* byte b3 = b1 + b2;
* 从两方面去回答这个题
* b1和b2是两个变量,变量里面存储的值都是变化的,所以在程序运行中JVM是无法判断里面具体的值
* byte类型的变量在进行运算的时候,会自动类型提升为int类型
* byte b4 = 3 + 4;
* 3和4都是常量,java有常量优化机制,就是在编译的的时候直接把3和4的结果赋值给b4了
* 进行混合运算的时候,byte,short,char不会相互转换,都会自动类型提升为int类型,其他类型进行混合运算的是小的数据类型提升为大的
* byte,short,char -- int -- long -- float -- double
* long: 8个字节
* float：4个字节
* IEEE754
* 4个字节是32个二进制位
* 1位是符号位
* 8位是指数位
* 00000000 11111111
* 0到255
* 1到254
* -126到127
* 23位是尾数位
* 每个指数位减去127
* A:它们底层的存储结构不同。
* B:float表示的数据范围比long的范围要大
* long：2^63-1
* float：3.4*10^38 > 2*10^38 > 2*8^38 = 2*2^3^38 = 2*2^114 > 2^63-1
* A:什么是运算符
* 就是对常量和变量进行操作的符号。
* B:运算符的分类
* 算术运算符，赋值运算符，比较(关系或条件)运算符，逻辑运算符，位运算符，三目(元)运算符
* C:算数运算符有哪些
* +,-,*,/,%,++,--
* D:注意事项：
* a:+号在java中有三种作用,代表正号,做加法运算,字符串的连接符
* b:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
* c:/获取的是除法操作的商，%获取的是除法操作的余数
* %运算符
* 当左边的绝对值小于右边绝对值时,结果是左边
* 当左边的绝对值等于右边或是右边的倍数时,结果是0
* 当左边的绝对值大于右边绝对值时,结果是余数
* %运算符结果的符号只和左边有关系,与右边无关
* 任何一个正整数%2结果不是0就是1可以用来当作切换条件
* A:++,--运算符的作用
* 自加（++）自减（--）运算
* ++:自加。对原有的数据进行+1
* --:自减。对原有的数据进行-1
* B:案例演示
* a:单独使用：
* 放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
* b:参与运算使用：
* 放在操作数的前面，先自增或者自减，然后再参与运算。
* 放在操作数的后面，先参与运算，再自增或者自减。
* A:逻辑运算符有哪些
* &,|,^,!
* &&,||
* B:案例演示
* 逻辑运算符的基本用法
* 注意事项：
* a:逻辑运算符一般用于连接boolean类型的表达式或者值。
* b:表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
* 算术表达式：a + b
* 比较表达式：a == b(条件表达式)
* C:结论：
* &逻辑与:有false则false。
* |逻辑或:有true则true。
* ^逻辑异或:相同为false，不同为true。
* !逻辑非:非false则true，非true则false。
* 特点：偶数个不改变本身。
* A:案例演示
* &&和&的区别?
* a:最终结果一样。
* b:&&具有短路效果。左边是false，右边不执行。
* &是无论左边是false还是true,右边都会执行
* B:同理||和|的区别?
* C:开发中常用谁?
* &&, ||, !
* A:位运算符有哪些
* &,|,^,~ ,>>,>>>,<<
* B:案例演示
* 位运算符的基本用法1
* &,|,^,~ 的用法
* &:有0则0
* |:有1则1
* ^:相同则0，不同则1
* ~:按位取反
* A:案例演示
* 位异或运算符的特点
* ^的特点：一个数据对另一个数据位异或两次，该数本身不变。
* B:面试题：
* 请自己实现两个整数变量的交换
* 注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。
* C:案例演示 >>,>>>,<<的用法:
* <<:左移 左边最高位丢弃，右边补齐0
* >>:右移 最高位是0，左边补齐0;最高为是1，左边补齐1
* >>>:无符号右移 无论最高位是0还是1，左边补齐0
* 最有效率的算出2 * 8的结果
* A:三元运算符的格式
* (关系表达式) ? 表达式1 : 表达式2;
* B:三元运算符的执行流程
* C:案例演示
* 获取两个数中的最大值
* A:为什么要使用键盘录入数据
* a:为了让程序的数据更符合开发的数据
* b:让程序更灵活一下
* B:如何实现键盘录入呢?
* 先照格式来。
* a:导包
* 格式：
* import java.util.Scanner;
* 位置：
* 在class上面。
* b:创建键盘录入对象
* 格式：
* Scanner sc = new Scanner(System.in);
* c:通过对象获取数据
* 格式：
* int x = sc.nextInt();
* C:案例演示
* 键盘录入1个整数，并输出到控制台。
* 键盘录入2个整数，并输出到控制台。
* A:什么是流程控制语句
* 流程控制语句：可以控制程序的执行流程。
* B:流程控制语句的分类
* 顺序结构
* 选择结构
* 循环结构
* C:执行流程：
* 从上往下，依次执行。
* D:案例演示
* 输出几句话看效果即可
* A:选择结构的分类
* if语句
* switch语句
* B:if语句有几种格式
* 格式1
* 格式2
* 格式3
* C:if语句的格式1
*
if(比较表达式) {
语句体;
}
* D:执行流程：
* 先计算比较表达式的值，看其返回值是true还是false。
* 如果是true，就执行语句体；
* 如果是false，就不执行语句体；
* A:if语句的格式2
*
if(比较表达式) {
语句体1;
}else {
语句体2;
}
* B:执行流程：
* 首先计算比较表达式的值，看其返回值是true还是false。
* 如果是true，就执行语句体1；
* 如果是false，就执行语句体2；
* C:案例演示
* a:获取两个数据中较大的值
* b:判断一个数据是奇数还是偶数,并输出是奇数还是偶数
* 注意事项：else后面是没有比较表达式的，只有if后面有。
* A:if语句的格式3：
*
if(比较表达式1) {
语句体1;
}else if(比较表达式2) {
语句体2;
}else if(比较表达式3) {
语句体3;
}
...
else {
语句体n+1;
}
* B:执行流程：
* 首先计算比较表达式1看其返回值是true还是false，
* 如果是true，就执行语句体1，if语句结束。
* 如果是false，接着计算比较表达式2看其返回值是true还是false，
* 如果是true，就执行语句体2，if语句结束。
* 如果是false，接着计算比较表达式3看其返回值是true还是false，
* 如果都是false，就执行语句体n+1。
* C:注意事项:最后一个else可以省略,但是建议不要省略,可以对范围外的错误值提示
* A:案例演示
* if语句和三元运算符完成同一个效果
* B:案例演示
* if语句和三元运算符的区别
* 三元运算符实现的，都可以采用if语句实现。反之不成立。
* 什么时候if语句实现不能用三元改进呢?
* 当if语句控制的操作是一个输出语句的时候就不能。
* 为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。
* A:练习1
*
需求：键盘录入一个成绩，判断并输出成绩的等级。
90-100 优
80-89 良
70-79 中
60-69 及
0-59 差
* B:练习2
* 需求：
* 键盘录入x的值，计算出y的并输出。
* x>=3 y = 2 * x + 1;
* -1<x<3 y = 2 * x;
* x<=-1 y = 2 * x - 1;
* A:switch语句的格式
*
switch(表达式) {
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default：
语句体n+1;
break;
}
* B:switch语句的格式解释
* C:面试题
* byte可以作为switch的表达式吗?
* long可以作为switch的表达式吗?
* String可以作为switch的表达式吗?
* C:执行流程
* 先计算表达式的值
* 然后和case后面的匹配，如果有就执行对应的语句，否则执行default控制的语句
* A:案例演示
* a:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
* b:default可以省略吗?
* 可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
* 特殊情况：
* case就可以把值固定。
* A,B,C,D
* c:break可以省略吗?
* 最后一个可以省略,其他最好不要省略
* 会出现一个现象：case穿透。
* 最终我们建议不要省略
* d:default一定要在最后吗?
* 不是，可以在任意位置。但是建议在最后。
* e:switch语句的结束条件
* a:遇到break就结束了
* b:执行到switch的右大括号就结束了
* A:看程序写结果：
*
int x = 2;
int y = 3;
switch(x){
default:
y++;
break;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y);
* B:看程序写结果：
*
int x = 2;
int y = 3;
switch(x){
default:
y++;
case 3:
y++;
case 4:
y++;
}
System.out.println("y="+y);
* A:总结switch语句和if语句的各自使用场景
* switch建议判断固定值的时候用
* if建议判断区间或范围的时候用
* B:案例演示
* 分别用switch语句和if语句实现下列需求：
* 键盘录入月份，输出对应的季节
* A:循环结构的分类
* for,while,do...while
* B:循环结构for语句的格式：
*
for(初始化表达式;条件表达式;循环后的操作表达式) {
循环体;
}
* C执行流程：
* a:执行初始化语句
* b:执行判断条件语句,看其返回值是true还是false
* 如果是true，就继续执行
* 如果是false，就结束循环
* c:执行循环体语句;
* d:执行循环后的操作表达式
* e:回到B继续。
* D:案例演示
* 在控制台输出10次"helloworld"
* A:循环结构while语句的格式：
*
while循环的基本格式：
while(判断条件语句) {
循环体语句;
}
完整格式：
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
* B:执行流程：
* a:执行初始化语句
* b:执行判断条件语句,看其返回值是true还是false
* 如果是true，就继续执行
* 如果是false，就结束循环
* c:执行循环体语句;
* d:执行控制条件语句
* e:回到B继续。
* C:案例演示
* 需求：请在控制台输出数据1-10
* A:循环结构do...while语句的格式：
*
do {
循环体语句;
}while(判断条件语句);
完整格式；
初始化语句;
do {
循环体语句;
控制条件语句;
}while(判断条件语句);
* B:执行流程：
* a:执行初始化语句
* b:执行循环体语句;
* c:执行控制条件语句
* d:执行判断条件语句,看其返回值是true还是false
* 如果是true，就继续执行
* 如果是false，就结束循环
* e:回到b继续。
* C:案例演示
* 需求：请在控制台输出数据1-10
* A:案例演示
* 三种循环语句的区别:
* do...while循环至少执行一次循环体。
* 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
* B:案例演示
* for循环和while循环的区别：
* A:如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用谁就用for循环。因为变量及早的从内存中消失，可以提高内存的使用效率。
* A:break的使用场景
* 只能在switch和循环中
* A:continue的使用场景
* 只能在循环中
* 标号:标记某个循环对其控制
* 标号组成规则:其实就是合法的标识符
* A:为什么要有方法
* 提高代码的复用性
* B:什么是方法
* 完成特定功能的代码块。
* C:方法的格式
*
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
方法体语句;
return 返回值;
}
* D:方法的格式说明
* 修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。
* 返回值类型：就是功能结果的数据类型。
* 方法名：符合命名规则即可。方便我们的调用。
* 参数：
* 实际参数：就是实际参与运算的。
* 形式参数；就是方法定义上的，用于接收实际参数的。
* 参数类型：就是参数的数据类型
* 参数名：就是变量名
* 方法体语句：就是完成功能的代码。
* return：结束方法的。
* 返回值：就是功能的结果，由return带给调用者。
* A:方法调用(有具体返回值)
* a:单独调用,一般来说没有意义，所以不推荐。
* b:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。
* c:赋值调用,推荐方案。
* B:案例演示
* a:方法不调用不执行
* b:方法与方法是平级关系，不能嵌套定义
* c:方法定义的时候参数之间用逗号隔开
* d:方法调用的时候不用在传递数据类型
* e:如果方法有明确的返回值，一定要有return带回一个值
* A:方法重载概述
* 求和案例
* 2个整数
* 3个整数
* 4个整数
* B:方法重载：
* 在同一个类中，方法名相同，参数列表不同。与返回值类型无关。
* 参数列表不同：
* A:参数个数不同
* B:参数类型不同
* C:参数的顺序不同(算重载,但是在开发中不用)
* A:为什么要有数组(容器)
* 为了存储同种数据类型的多个值
* B:数组概念
* 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。
* 数组既可以存储基本数据类型，也可以存储引用数据类型。
* C:数组定义格式
数据类型[] 数组名 = new 数据类型[数组的长度];
* A:什么是数组的初始化
* 就是为数组开辟连续的内存空间，并为每个数组元素赋予值
* B:如何对数组进行初始化
* a:动态初始化 只指定长度，由系统给出初始化值
* int[] arr = new int[5];
* b:静态初始化 给出初始化值，由系统决定长度
* C:动态初始化的格式：
* 数据类型[] 数组名 = new 数据类型[数组长度];
* D:案例演示
* 输出数组名称和数组元素
* A:栈(掌握)
* 存储局部变量
* B:堆(掌握)
* 存储new出来的数组或对象
* C:方法区
* 面向对象部分讲解
* D:本地方法区
* 和系统相关
* E:寄存器
* 给CPU使用
详见类一篇随笔，java虚拟机
* A:案例演示
* a:ArrayIndexOutOfBoundsException:数组索引越界异常
* 原因：你访问了不存在的索引。
* b:NullPointerException:空指针异常
* 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。
* int[] arr = {1,2,3};
* arr = null;
* System.out.println(arr[0]);
* A:案例演示
* 数组遍历: 就是依次输出数组中的每一个元素。
* 数组的属性: arr.length数组的长度
* 数组的最大索引: arr.length - 1;
public static void print(int[] arr) {
for (int i = 0;i < arr.length ;i++ ) {
System.out.print(arr[i] + " ");
}
}
* A:案例演示
* 数组获取最值(获取数组中的最大值最小值)
public static int getMax(int[] arr) {
int max = arr[0];
for (int i = 1;i < arr.length ;i++ ) { //从数组的第二个元素开始遍历
if (max < arr[i]) { //如果max记录的值小于的数组中的元素
max = arr[i]; //max记录住较大的
}
}
return max;
}
* A:案例演示
* 数组元素反转(就是把元素对调)
public static void reverseArray(int[] arr) {
for (int i = 0;i < arr.length / 2 ; i++) {
//arr[0]和arr[arr.length-1-0]交换
//arr[1]和arr[arr.length-1-1]交换
//arr[2]和arr[arr.lentth-1-2]
//...
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
}
* A:案例演示
* 数组查表法(根据键盘录入索引,查找对应星期)
public static char getWeek(int week) {
char[] arr = {‘ ‘,‘一‘,‘二‘,‘三‘,‘四‘,‘五‘,‘六‘,‘日‘}; //定义了一张星期表
return arr[week]; //通过索引获取表中的元素
}
* A:案例演示
* 数组元素查找(查找指定元素第一次在数组中出现的索引)
public static int getIndex(int[] arr,int value) {
for (int i = 0;i < arr.length ;i++ ) { //数组的遍历
if (arr[i] == value) { //如果数组中的元素与查找的元素匹配
return i;
}
}
return -1;
}
* A:二维数组概述
* B:二维数组格式1
* int[][] arr = new int[3][2];
* C:二维数组格式1的解释
* D:注意事项
* a:以下格式也可以表示二维数组
* 1:数据类型 数组名[][] = new 数据类型[m][n];
* 2:数据类型[] 数组名[] = new 数据类型[m][n];
* B:注意下面定义的区别
*
int x;
int y;
int x,y;
int[] x;
int[] y[];
int[] x,y[]; x是一维数组,y是二维数组
* E:案例演示
* 定义二维数组，输出二维数组名称，一维数组名称，一个元素
* A:案例演示
* 需求：二维数组遍历
* 外循环控制的是二维数组的长度，其实就是一维数组的个数。
* 内循环控制的是一维数组的长度。
int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};
for (int i = 0;i < arr.length ;i++ ) { //获取到每个二维数组中的一维数组
for (int j = 0;j < arr[i].length ;j++ ) { //获取每个一维数组中的元素
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
* A:案例演示
*
需求：公司年销售额求和
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};
int sum = 0; //定义变量,记录每次相加的结果
for (int i = 0;i < arr.length ;i++ ) { //获取每一个一维数组
for (int j = 0;j < arr[i].length ;j++ ) { //获取每一个一维数组中的元素
sum = sum + arr[i][j]; //累加
}
}
System.out.println(sum);
原文：https://www.cnblogs.com/zhaochuming/p/12484530.html