1. Java语言的发展史

java是哪家公司哪一年推出的？
sun公司在1995推出的编程语言
java之父是谁？
詹姆斯.高斯林
java的主要发展历程？
1995由sun公司推出。
2004推出JDK1.5，这是里程碑式的版本。
2009年sun公司被oracle（甲骨文公司）收购。
目前最新版本JDK12。
java的三大技术架构
JavaSE：java标准版，主要用于桌面应用软件的开发。比如计算器，QQ软件等。
JavaEE：java企业版，基于JavaSE的企业级应用的开发。比如淘宝，京东，ERP系统等。（大型互联网）
JavaME：java微型版，应用于移动设备和电子类产品的嵌入式开发。比如手机游戏，手机软件等。（安卓，IOS，HTML，微信小程序）

2. Java语言跨平台原理

java语言的特点
java语言具有简单易学、面向对象、健壮性、安全性、与平台无关性等特点。
什么是平台？
平台即操作系统，目前主流的有微软Windows系统，苹果Mac系统，Linux系统
什么是java跨平台？
通过java语言编写的应用程序可以在不同的操作系统上直接运行。具有一次编译，到处运行的特点。
java如何实现跨平台？
通过JVM虚拟机实现的跨平台。在不同的操作系统上安装对应的JVM虚拟机。

java跨平台的原理
java程序并非是直接运行的， javac编译器将java源程序（.java文件）编译成与平台无关的字节码文件（.class文件），然后通过java运行工具启动java虚拟机，由java虚拟机（JVM）对字节码文件解释执行。所以在不同的操作系统下， 只需安装不同的java虚拟机即可实现java程序的跨平台

3. JVM、JRE、JDK

JVM、JRK、JDK三者之间的关系

JVM：Java虚拟机，保证java程序跨平台。 //JVM保证java程序的跨平台性 JRE：Java运行环境，包含JVM和核心类库。如果只是想运行java程序，只要安装JRE即可。 //JRE=JVM+核心类库 核心类库包括：java.util包中的Random/Scanner/Arrays等 JDK：Java开发工具包，包含JRE和开发工具。如果程序员想要开发java程序，需要安装JDK环境 //JDK=JRE+开发工具 开发工具包括：编译工具javac.exe ，运行工具java.exe 等

JVM、JRE、JDK关系图解

4. 常用的DOS命令

进入DOS命令行窗口
快捷键win + R打开运行窗口，输入cmd，按回车进入。
常用DOS命令

操作说明盘符名称盘符切换。E:回车，表示切换到E盘dir查看当前路径下的内容cd 目录进入单级目录。cd develop，表示进入develop文件夹cd …回退到上一级目录cd 目录1\目录2…进入多级目录。cd develop\java，表示进入develop下的java文件夹cd \回退到盘符根目录cls清屏exit退出命令提示符窗口

5. Path环境变量的配置

什么是环境变量
环境变量：指在操作系统中用来指定操作系统运行环境的一些参数
为什么要配置环境变量
开发java程序， 需要使用JDK提供的开发工具（比如javac.exe、java.exe等命令），而这些工具在JDK的安装目录的bin目录下，如果不配置环境变量，那么这些命令只可以在该目录下执行。 我们不可能把所有的java文件都放到JDK的bin目录下， 所以配置环境变量的作用就是可以使bin目录下的java相关命令可以在任意目录下使用。
常见配置的环境变量

环境变量名作用JAVA_HOME指 JDK 安装的根目录，如：C:\develop\Java\jdk-11PATH指 java 开发工具的位置，如：C:\develop\Java\jdk-11\binCLASSPATH指 JVM 在运行时到哪一个目录去加载字节码文件

6. 注释

注释的作用？
对代码进行解释说明，便于开发人员理解和维护代码。
注释不会被程序编译和运行。
注释的分类？
单行注释 // 注释内容，单行注释可以嵌套。
多行注释 /* 注释内容 /，多行注释不能嵌套使用。
文档注释 /* 注释内容 */，文档注释不能嵌套使用。

7. 关键字

什么是关键字？
在java语言中有特殊意义的英文单词。
java关键字的特点？
单词全部小写。
在高级开发工具中，关键字会有特殊的颜色标记。
java中的关键字/保留字
goto和const是java中的预留关键字（goto和const也叫保留字）。

8. 常量

什么是常量？
在程序运行过程中，其值不可以发生改变的量。
常量的分类

字符串常量：使用双引号 "" 括起来的0到多个字符。"java" ,"程序员" ， "" ， " "，"A" // 大于等于0个字符 字符常量：使用单引号 '' 括起来的单个字符。 'a' , '0' ,'我' //1个字符 整数常量：正负整数 10 -20 小数常量：带小数点的数字 -3.14 5.12 布尔常量：表示真或假，只有true或false两个值 空常量：值为null，不能使用输出语句直接输出。//System.out.println(null),会编译报错 定义的final变量

9. 数据类型

java是强类型的语言，每一个数据都有对应的数据类型。
位：计算机计算的基本单位，计算机底层是二进制 0 1
字节：计算机存储的基本单位，1字节=8位。
java数据类型分类？
基本数据类型：4型8种
整数：byte short int long （整数默认是：int类型）
小数：float double （小数默认是：double类型）
字符：char
布尔：boolean
引用数据类型：字符串，数组，类，接口 ,null
基本数据类型分类

1.定义 long 类型加L int number = 100L; 2.定义 float 类型加F int f = 10.0F;

10. 变量

什么是变量？
变量指程序运行过程中，其值在一定范围内会发生变化的量。
变量的定义格式

数据类型 变量名 = 初始化值 int a = 12;

变量的分类

成员变量：（也叫全局变量，字段） 直接定义在类中，方法外，默认有初始值 1.类成员变量：使用static修饰符修饰的成员变量 2.实例成员变量：没有使用static修饰符修饰的成员变量 局部变量：变量除了成员变量之外,其他就是局部变量 分为：方法形参，方法内变量，代码块变量 没有初始化值，必须先初始化才能使用

变量使用的注意事项

1、变量可以定义时初始化，也可以先定义，使用前进行初始化。 //定义的时候初始化 double d = 3.14; //先定义，后初始化 double d; d = 3.14; 2、没有初始化的变量不能直接使用。 int a ; System.out.println(a); //编译报错， 3、相同范围内，变量名不能重复。 //第一种:方法的形参上变量名不能相同 public static void sum(int a,int a){ //编译报错 } //第二种:一对 {} 内变量名不能相同 public static void sum(){ int a = 10; //编译报错 int a = 20; //编译报错 } 4、整数默认是int类型，定义long类型时需要加L 或者l,建议加L。 long num = 10L; 5、小数默认是double类型，定义float类型的时候需要在数字后面加F或者f,建议加F。 float f = 3.14F; 6、一行代码上可以定义多个变量。（不推荐） int a=10,b=20; int a,b =20; a=10;

变量的生命周期

存在位置生命周期开始生命周期结束在内存中的位置类成员变量使用static修饰的成员变量当所在字节码被加载进JVM当JVM停止方法区实例成员变量没有使用static修饰的成员变量当创建所在类的对象的时候当该对象被垃圾回收器回收堆局部变量方法形参，代码块中，方法内当代码执行到初始化变量的时候所在的方法/代码块结束栈

11. 标识符

标识符的作用
给 包，类，方法，变量起名的符号。
标识符的组成规则
大小写英文字母、数字、下划线_、美元符$、中文（不推荐）
注意事项：
1、不能是数字开头
2、不能是关键字
3、区分大小写
标识符的命名规范
小驼峰式命名：变量名、方法名
第一个单词首字母小写，从第二个单词开始每个单词的首字母大写。

userName，maxValue等

大驼峰式命名：类名
每个单词的首字母都大写。

String， ArrayList等

建议：标识符的起名尽量做到见名知意。

12. 类型转换

隐式类型转换（自动类型转换）
从范围小的类型到范围大类型的转换，系统会自动进行类型提升，称为自动类型转换。

1.boolean不参与类型转换 2.byte不能自动类型转换为char 3.char不能自动类型转换为short 4.short不能自动类型转换为char

强制类型转换
从范围大的类型到范围小的类型的转换，需要进行强制类型转换。
格式：

目标数据类型 变量名 = （目标数据类型）变量值（常量值）；

弊端：会造成数据精度丢失。尽量少用强制转换。

1.boolean不参与类型转换 2.char可以强制类型转换为byte 3.short可以强制类型转换为char 4.char可以强制类型转换为short

13. 运算符和表达式

运算符：对常量或者变量进行操作的符号。
表达式：通过运算符连接起来的式子

例如： + 是运算符，10 + 20 是表达式 - 是运算符，a - b 是表达式

常用的运算符
算术运算符、赋值运算符、自增自减运算符、关系运算符、逻辑运算符、三元运算符

13.1 算术运算符

符号作用说明+加对数字进行加法运算，对字符串进行拼接-减进行减法操作*乘进行乘法操作/除整数相除的结果只能是整数，想要得到小数，必须有浮点数参与运算。 a / b ,获得 a 和 b 的商%取余a%b 获得 a 和 b 相除的余数

13.1.1 表达式类型提升

byte、short、char变量之间进行运算时，类型自动提升为int。
变量参与运算时，最终结果以最高类型为准。

/* 表达式类型提升: 1. byte、short、char变量之间进行运算时，类型自动提升为int。 2. 变量参与运算时，最终结果以最高类型为准。 */ public class OperatorDemo02 { public static void main(String[] args) { // 1、byte、short、char变量之间进行运算时，类型自动提升为int。 byte b = 10; //编译报错，b+5，变量b会自动提升为int类型，运算结果为int，赋值给byte需要强转。 // byte b2 = b + 5; int b2 = b+5; System.out.println(b2); // 2. 变量参与运算时，最终结果以最高类型为准。 int num1 = 10; long num2 = 20L; long num3 = num1 + num2; //int + long --->long System.out.println(num3); } }

13.1.2 字符的 + 运算

字符参与运算的规则：
将字符换算成编码表里对应的数值进行运算。
等价于：把char类型数据换成对应的十进制数来参与运算
编码表：
计算机底层使用二进制运算，所以文字和符号必须转换成二进制数才能被计算机识别，编码表就是将文字等符号编成对应的数的表格，因为二进制记录起来比较麻烦，所以使用十进制数进行文字编码。
世界上第一张编码表ASCII（美国标准信息交换码）。常用编码表都兼容ASCII码表。
常用的编码：
ASCII编码：美国标准信息交换码，世界上第一张编码表。
GB2312编码：简体中文编码，对常用汉字进行了编码，兼容ASCII。
GBK：加强版的中文编码表，对更多汉字进行了编码，兼容ASCII
UTF-8编码：万国码表，常作为浏览器上的网页编码，可以统一显示各国文字，兼容ASCII。
常见字符对应的十进制数：
‘ a’ ~ ‘z’ : 97 ~ 122
‘A’ ~ ‘Z’ : 65 ~ 90
‘0’ ~ ‘9’ : 48 ~ 57
基本汉字：19968 ~ 40869
char类型表示的范围：0~65535
ASCII编码表

/* 字符参与运算的规则： 将字符换算成编码表里对应的数值进行运算。 */ public class CharDemo2{ public static void main(String[] args){ //a~z 97~122 //A~Z 65-90 //0~9 48~57 //基本汉字：19968 ~ 40869 char c = 'a'; int b = c + 10; System.out.println(b); //c是char类型，参与运算先转为十进制，在参与运算 //107 char c2 = 97; System.out.println(c2); //c2是char，打印c2就是打印他的char类型数据 //a //char类型范围 0~65535 // char c3 = 65536; //报错，超过了char的范围 int c3 = '中'; int c4 = '国'; System.out.println(c3); //20013 System.out.println(c4); //22269 char c5 = 20013; char c6 = 22269; System.out.println(c5); //中 System.out.println(c6); //国 char c7 = '9'; //9 char c8 = 57; //9 char c9 = 9; //打印的结果不是数字9,而是9对应的编码表的符号73 } }

13.1.3 字符串的+运算

与字符串进行 “+” 运算，是进行字符串拼接操作，运算结果还是字符串。
字符串只能进行 + 运算

//字符串的加法运算 public class StringAddDemo{ public static void main(String[] args){ int age = 25; System.out.println("我的年龄是："+age+"岁"); //输出结果：我的年龄是：25岁 } }

13.2 赋值运算符

赋值运算符作用
将表达式或者常量值赋给变量。
赋值运算符分类

符号作用说明=赋值a=10，将10赋值给变量a+=加后赋值a+=b，将a+b的值给a-=减后赋值a-=b，将a-b的值给a*=乘后赋值a*=b，将a×b的值给a/=除后赋值a/=b，将a÷b的商给a%=取余后赋值a%=b，将a÷b的余数给a

注意：扩展的赋值运算符隐含了强制类型转换。

/* 赋值运算符: 扩展赋值运算符隐含了强制类型转换 */ public class FuZhiDemo { public static void main(String[] args) { //1. 基本赋值运算符 = int a = 10; System.out.println(a); //2. 扩展赋值运算符 int b = 20; // b+=5; // b-=5; // b*=5; // b/=5; b%=5; //b = b%5; System.out.println(b);//0 // 3. 扩展赋值运算符隐含了强制类型转换 byte num = 10; num+=5; // 相当于:num = (byte)(num+5); // num = num + 5; //报错 System.out.println(num); } }

13.3 自增自减运算符

1、++ 、 – 可以放在变量的前面，也可以放在变量的后面。
单独进行运算时放在前面或者后面，效果一样。
2、参与其他运算的时候：
a++ ：先将a的值参与其他运算，运算结束后再自身加1。
++a ：先将a自身加1，再将自增后的值参与其他运算。
自减与自增规则相同。
3、最常见用法：单独使用。

13.4 关系运算符

符号作用说明==等于a == b，判断如果a等于b，则为true，否则为false!=不等于a!=b，判断如果a不等于b，则为true，否则为false>大于a>b，如果a大于b，则为true，否则为false>=大于等于a>=b，如果a大于等于b，则为true，否则为false十进制:
第0位的权值为16的0次方，第1位的权值为16的1次方，第2位的权值为16的2次方……

16. 原码、反码、补码

16.1 概述

在计算机内，有符号数有3种表示法：原码、反码和补码,所有数据的运算都是采用补码进行的

16.2 原码

写出二进制,正数符号位为0,负数符号位为1

16.3 反码

正数的反码是本身,负数的反码是在其原码的基础上, 符号位不变,其余各个位取反

16.4 补码

正数的补码就是其本身,负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)

17. 流程控制语句

流程控制语句分为哪几类
顺序结构、选择(分支)结构、循环结构

17.1 顺序结构

按照代码书写顺序，从上往下执行。

17.2 选择结构（if switch）

17.2.1 if结构

if语句格式1

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

执行流程：
1、首先计算关系表达式的值。
2、表达式的值为 true 时执行语句体，为 false 时不执行语句体。
3、往下执行 if结构后面的语句内容。

if语句格式2

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

执行流程：
1、首先计算关系表达式的值。
2、表达式的值为 true 时执行语句体1，为 false 时执行语句体2。
3、继续执行 if-else 结构后面的语句内容。

if语句格式3

if(关系表达式1){ 语句体1； }else if(关系表达式2){ 语句体2； }else{ 语句体3； } //【注意】 该格式中可以有多个else if结构，可以没有else结构。

执行流程：
1、首先计算关系表达式1的值。
2、如果为 true 则执行语句体1，为 false 时计算关系表达式2的值。
3、如果为 true 则执行语句体2，为 false 时计算关系表达式3的值，以此类推。
4、所有关系表达式都为false时，执行else里的语句体n+1。

//案例：键盘录入一个1~7的整数，输出对应的星期一到星期日。 //导包 import java.util.Scanner; public class IfTest{ public static void main(String[] args){ //创建Scanner对象 Scanner sc = new Scanner(System.in); System.out.println("请输入一个整数(1~7)："); //接收键盘录入的整数 int week = sc.nextInt(); //使用if-elseif结构判断 if(week==1){ System.out.println("星期一"); }else if(week==2){ System.out.println("星期二"); }else if(week==3){ System.out.println("星期三"); }else if(week==4){ System.out.println("星期四"); }else if(week==5){ System.out.println("星期五"); }else if(week==6){ System.out.println("星期六"); }else if(week==7){ System.out.println("星期日"); }else{ System.out.println("您输入的数字无效！"); } } }

17.2.2 switch结构

switch语句格式

switch(表达式){ //整数 byte short int //char 字符串 //枚举 case 值1： 语句体1； break; case 值2： 语句体2； break; ... default 语句体n+1； break; }

执行流程：
1、先计算括号中表达式的值。
2、将结果依次和case后面的值比较，匹配上的就执行case对应的语句体，遇到break就结束switch结构。
3、当所有的case值都不匹配时，执行default后面的语句体n+1， default省略break，效果一样。

/* 需求: 键盘输入1 2 3, 输出对应的 "冠军" ,"亚军", "季军" */ public class SwitchDemo { public static void main(String[] args) { //获取键盘录入 Scanner sc = new Scanner(System.in); System.out.println("请输入一个整数(1~3):"); int num = sc.nextInt(); switch(num){ case 1: System.out.println("冠军"); break; case 2: System.out.println("亚军"); break; case 3: System.out.println("季军"); break; default: System.out.println("无"); } } }

switch的注意事项：
1、switch中表达式的值：byte short char int , 枚举， 字符串
2、case 后面的值不能重复，不能是变量，只能是常量
3、case的值都不匹配的时候，执行default的内容，default可以省略(不建议)，default可以改变位置(不建议)
4、break的作用是结束switch语句
5、break可以省略，但是会有case穿透现象
case穿透现象：不用再判断case的值，直接执行下面的语句，直到遇到break或者程序结束。

case穿透案例:

/* 春夏秋冬 需求： 一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份， 请用程序实现判断该月份属于哪个季节，并输出。 春：3、4、5 夏：6、7、8 秋：9、10、11 冬：12、1、2 */ import java.util.Scanner; public class SwitchDemo { public static void main(String[] args) { //键盘录入月份数据，使用变量接收 Scanner sc = new Scanner(System.in); System.out.println("请输入一个月份："); int month = sc.nextInt(); //case穿透 switch(month) { case 3: case 4: case 5: System.out.println("春季"); break; case 6: case 7: case 8: System.out.println("夏季"); break; case 9: case 10: case 11: System.out.println("秋季"); break; case 12: case 1: case 2: System.out.println("冬季"); break; default: System.out.println("你输入的月份有误"); } } }

17.3 循环结构

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候结束循环，否则循环将一直执行下去，形成死循环。

17.3.1 for循环

for循环格式

for (初始化语句; 条件判断语句; 条件控制语句) { 循环体语句; } //案例：for循环打印5次HelloWorld for(int i=1; i for(int i=1; i continue; //遇到continue开始下次循环：打印奇数 // break; //遇到break结束整个循环 } } System.out.println(i); } } /* 模拟一个用户系统 控制台显示一个用户菜单： 输入数字选择您要的操作： 1.新增用户 2.修改用户 3.删除用户 4.查看信息 5.退出系统 工作人员输入对应的编号进行操作，当输入5时退出系统。 */ import java.util.Scanner; public class BreakDemo{ public static void main(String[] args){ //创建键盘录入对象 Scanner sc = new Scanner(System.in); //死循环 loop:while(true){ System.out.println("输入数字选择您要的操作："); System.out.println("1.新增用户 2.修改用户 3.删除用户 4.查看信息 5.退出系统"); int num = sc.nextInt(); switch(num){ case 1: System.out.println("新增成功"); break; case 2: System.out.println("修改成功"); break; case 3: System.out.println("删除成功"); break; case 4: System.out.println("当前用户数1000"); break; case 5: System.out.println("欢迎使用本软件"); //结束指定循环：loop break loop; //结束loop标志的的循环 default: System.out.println("您的输入有误,请重新输入！"); } } } }

18. 随机数：Random类

认识Rondom类
Random是java提供的工具类，位于【 java.util 】包下，用于产生随机数。
Random类的使用步骤

1.导包 import java.util.Random; 2.创建对象 Random r = new Random(); 3.产生随机数 int num = r.nextInt(100);//获取0~99的随机数 注意:r.nextInt(100); 获取0~99的随机数 r.nextInt(200); 获取0~199的随机数

说明：
nextInt( 数值 )：代表随机生成并返回一个整数，如果括号数值为10，表示生成0-9的整数，数值20，表示生成0~19的整数

产生范围65~90之间的整数 int num = r.nextInt(26)+65; 0~25 + 65 产生范围97~122之间的整数 int num = r.nextInt(26)+97; 0~25 + 97 /* 需求:随机生成一个1~100之间的整数. */ //1.导包 import java.util.Random; public class RandomDemo{ public static void main(String[] args){ //2.创建Random对象 Random r = new Random(); //3.调用方法产生随机数 int num = r.nextInt(100)+1; System.out.println(num); } }

19. 数组

19.1 数组的作用和特点

作用：数组可用于存储同一类型的多个数据，是一个java的数据容器。 特点：数组长度固定，所存数据类型一致。

19.2 数组的定义格式

//【格式1】（掌握） 数据类型[] 数组名 //示例 int[] arr boolean[] arr double[] arr //【格式2】（了解） 数据类型 数组名[] //示例 double arr[]

什么是数组初始化
java中变量使用前必须完成初始化，数组也一样，需要完成初始化才能使用。
数组初始化就是为数组分配内存空间，并为数组中每个元素赋值。
数组的初始化分为:
动态初始化
静态初始化

19.3 数组的动态初始化

什么是动态初始化
只给定数组的长度，由系统给出默认初始化值。
动态初始化的格式

数据类型[] 数组名 = new 数据类型[数组长度]; double[] arr = new double[50];

格式说明

int[] arr = new int[5]; 等号左边： int:数组的数据类型 []:代表这是一个数组 arr:代表数组的名称 等号右边： new:为数组开辟内存空间 int:数组的数据类型 []:代表这是一个数组 5:代表数组的长度

19.4 数组元素访问

数组变量存储的是什么
数组在堆内存中的地址值
什么是索引
数组索引：数组元素的编号，从0开始，最大值为数组长度-1。
可以通过索引操作数组元素。
数组元素访问的格式

数组名[索引] public class ArrayDemo { public static void main(String[] args) { //定义并初始化长度为3的int数组 int[] arr = new int[3]; //输出数组名，得到一个地址值 System.out.println(arr); //[I@880ec60 //输出数组中的元素 System.out.println(arr[0]); //默认值0 System.out.println(arr[1]); //默认值0 System.out.println(arr[2]); //默认值0 } }

19.5 电脑内存分配（指运行内存，非硬盘）

19.6 JVM的内存分配

各个内存区的作用

区域名称作用栈内存（Stack）方法运行时使用的内存，存放方法中的变量和参数堆内存（Heap）存储对象或数组，new出来的数据，都存储在堆内存堆内存（Heap）存储对象或数组，new出来的数据，都存储在堆内存寄存器给CPU使用，和我们开发无关本地方法栈JVM在使用操作系统功能的时候使用，和我们开发无关方法区存储已加载的class文件信息栈内存：栈中存放局部变量，方法执行完毕，内存释放。 堆内存：堆中存放的是new出来的数据( 数组，对象等 )。数据使用完毕后，等待垃圾回收器回收。 new出来的数据, 都有一个对应的地址

19.7 数组的内存图

数组元素的默认初始化值

整数类型 0 浮点类型 0.0 字符类型 空字符 ' ' 布尔类型 false 引用类型 null 19.7.1 一个数组的内存图

19.7.2 多个数组的内存图

19.7.3 多个数组指向相同的内存地址

其中任意一个数组改变了堆中元素的值，其他的数组都会受到影响

19.8 数组的静态初始化

什么是静态初始化
在创建数组时，直接确定元素的值。
静态初始化的格式

数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3...} //示例 int[] arr = new int[]{1,2,3};

静态初始化简化格式

数据类型[] 数组名 = {元素1, 元素2， 元素3...}； //示例 int[] arr = {1,2,3};

19.9 数组的遍历

获取数组长度
数组名.length
遍历数组

//for循环进行数组遍历 public class ArrayDemo2 { public static void main(String[] args) { //定义数组 int[] arr = {11, 22, 33, 44, 55}; //使用for循环遍历并打印 for(int i=0; i public static void main(String[] args) { //定义数组 int[] arr = {45,12,98,73,60}; //------------求数组最大值------------ //定义变量存放数组最大值，并假设第一个元素为最大值 int max = arr[0]; //从第二个元素开始，依次和max变量比较 for(int i=1; i max = arr[i]; } } //循环结束后max存放的就是最大的值 System.out.println("最大值为："+ max); //------------求数组最小值------------ //假设第一个元素是最小的 int min = arr[0]; //从第二个元素开始，依次和min变量比较 for(int i=1; i min = arr[i]; } } //循环结束后，打印最小值 System.out.println("最小值为：" + min); } }

19.10 多维数组

数组元素类型[] 数组名; int[][] arr = new int[][] { arr1 ,arr2,arr3 }; int[][] arr = new int[][] { {1,2,3} , {4,5}, {6} };

一维数组:数组中的每一个元素都是一个值(基本类型和引用类型的值).
二维数组:数组中的每一个元素又是一个一维数组.
三维数组:数组中的每一个元素又是一个二维数组.

二维数组的初始化操作: 静态初始化: int[][] arr = new int[][] { {1,2,3} , {4,5}, {6} }; 动态初始化: int[][] arr = new int[3][5] ;创建一个长度为3的二维数组,每一个元素(一维数组)的长度为5. int[][] arr = new int[0][5] ------------------------------------- 针对于N维数组,需要N个循环嵌套.

20. 方法

20.1 方法的概述

什么是方法
方法是将具有独立功能的代码组成一个整体，使其成为具有特殊功能的代码块。
方法的两个注意
1、方法必须先定义才能使用。（方法定义）
2、方法定义后不会自动运行，需要手动调用才能执行方法的功能。（方法调用）

20.2 方法的定义和调用

20.2.1方法的定义格式1：无参数无返回值 public static void 方法名(){ 方法体代码; //需要在方法内完成的代码 } //调用格式 方法名（） /* 需求: 1. 定义一个方法,方法名为: printHelloWorld 2. 在方法中使用循环打印5次hello world. 3. 在main方法中调用执行 printHelloWorld 方法. */ public class MethodDemo { public static void main(String[] args){ printHelloWorld(); } public static void printHelloWorld(){ for(int i=1;i 方法体代码; return 返回值; } 格式说明： public static：public和static都是关键字，具有特殊的含义。（先这样写着，后续讲解） 返回值类型：方法有返回值时写返回值类型（基本数据类型、引用数据类型），没有返回值时写void。 方法名：用于方法调用时使用。 ( )：括号里面写参数列表，多个参数使用逗号隔开，没有参数时直接写 ( ) 即可。 参数类型：限定传入方法的参数的数据类型。（基本数据类型、引用数据类型） 参数名：用于接收传入方法的数据。 { }：大括号和里面的代码称为方法体。 return：方法有返回值时需要使用return关键字，返回对应的类型的数据。 没有返回值（void）时不用写return语句。 定义方法的两个明确： 1、明确返回值类型：确定方法是否需要返回值，以及返回值的类型。 2、明确参数：明确参数的类型和个数。 调用方法注意： 1、void类型的方法，直接调用即可。 2、非void类型的方法，推荐使用变量接收调用。 3、方法有参数时，调用时需要传参。

20.3 方法重载

20.3.1 什么是方法重载

同一个类中，出现了多个同名的方法，叫做方法重载。

20.3.2 构成方法重载的条件 1. 多个方法在同一个类中。 2. 多个方法名称相同。 3. 多个方法的参数列表不同（个数或者类型不同）。 注意： 方法重载与返回值和参数名称无关。 简单总结： 同一类中，方法名称相同，参数列表不同，即构成方法重载。 20.3.3 方法重载的作用

方便程序员对参数不同，但是功能相同或相似的方法进行统一的命名和调用。

20.3.4 调用重载的方法

调用时，虚拟机会根据参数列表的不同来区分调用对应的重载方法。

20.4 方法参数传递

20.4.1 方法参数传递基本类型

结论：
方法参数为基本数据类型时，参数为值传递，形式参数的改变不会影响实际参数
代码：

/* 参数传递为基本数据类型 */ public class MethodDemo4 { public static void main(String[] args) { int num = 5; add(num); System.out.println(num); } //方法形参为基本数据类型 public static void add(int num){ num+=10; //num = 15; } }

20.4.2 方法参数传递引用类型

什么是引用类型数据？
在堆内存中创建，并产生了一个地址值的数据。（数组、对象，接口）
结论：
方法参数为引用数据类型时，参数为地址传递，形式参数的改变会直接影响实际参数。
代码：

/* 参数传递为引用类型 */ public class MethodDemo5 { public static void main(String[] args) { int[] arr = {10,20,30}; System.out.println("调用前："+arr[0]); //10 change(arr); System.out.println("调用后："+arr[0]); //100 } //方法形参为引用类型 public static void change(int[] arr) { arr[0] = 100; } }