1.2 Java 语言平台版本Java 是一种高级编程语言，而且是面向对象的编程语言。Java 语言是美国 Sun 公司(Stanford University Network)，在 1995 年推出的高级的编程语言。Java 语言共同创始人之一：詹姆斯·高斯林 (James Gosling)，被称为 Java之父。Java 语言的版本：1.0-1.4，5.0…8.0…16.0，本文笔记用的 jdk 版本为 8.0。
JavaSE(Java Platform Standard Edition)标准版
是为开发普通桌面和商务应用程序提供的解决方案
该技术体系是其他，可以完成一些桌面应用程序的开发两者的基础
JavaME(Java Platform Micro Edition)小型版
是为开发电子消费产品和嵌入式设备提供的解决方案，已经被安卓 IOS
JavaEE(Java Platform Enterprise Edition)企业版
1.3 Java 语言的特点是为开发企业环境下的应用程序提供的一套解决方案
| 简单性 | 面向对象 | 分布式 |
|---|---|---|
| 跨平台性 | 多线程 | 动态性 |
| 健壮性 | 安全性 |
1.5 JDK、JRE、JVM 的组成和作用(1) JVM: Java 虚拟机，是专门用来运行 Java 程序的。
(2) 平台：指的就是操作系统，比如 Windows、linux、MacOS 等。
(3) 跨平台: 我们编写的一个 Java 程序，可以做多个操作系统上运行一次编译，到处运行。
1.JVM: Java 虚拟机，是专门用来运行 Java 程序的，但是不能单独安装。
2.JRE: Java 运行环境，包含 JVM(Java 虚拟机，是专门用来运行 Java 程序的)和核心类库。
3.JDK: Java 开发工具包，包含 JRE 和开发工具。
三者关系： JDK > JRE > JVM
注意事项：
1.注意操作系统是 Windows、linux、MacOS
2.注意操作系统的位数是 32 位还是 64 位
3.安装 java 相关软件的时候: 安装路径中不允许出现中文和空格(任何开发软件都最好不要安装在中文路径下)
默认路径安装一直下一步就行,唯一注意的是8版本安装会安装jdk与jre如果自定义路径需要分别创建文件夹保存
打开命令行窗口的方式：
- win + r 打开运行窗口，输入cmd，回车。
常用dos命令
| 操作 | 说明 |
|---|---|
| 盘符名称: | E:回车，表示切换到E盘。 |
| dir | 查看当前路径下的内容。 |
| cd | 目录 进入单级目录。cd JavaSE |
| cd… | 回退到上一级目录。 |
| cd 目录1目录2… | 进入多级目录。cd JavaSEbaiyunshan |
| cd | 回退到盘符目录。 |
| cls | 清屏。 |
| exit | 退出命令提示符窗口。 |
首先右键【此电脑】—> 选择【属性】—> 点击左侧的【高级系统设置】—> 点击【环境变量】—> 在下方的【系统变量】中点击【新建】
新建变量名为【JAVA_HOME】，变量值我们点击【浏览目录】，选择jdk的安装路径jdk文件夹
然后点击【确定】
找到path路径中写 %JAVA_HOME%bin; ，放在最前面，不要忘了加英文的分号
jdk环境配置
JAVA_HOME:用于配置jdk安装路径，用于提供第三方软件支持
CLASSPATH:jdk1.5以后默认配置，无需配置（如果配置不要配错），配置源代码编译后生成位置
PATH:使bin下工具可以在任意路径下使用
注意：在修改环境变量之后需要重新打开cmd窗口
2.4 测试开发环境通过javac和java命令验证
注意 ：如果提示 < javac不是内部或者外部命令>，原因是path配置错误, 重新按照上一步的步骤进行配置即可！
避免C:WINDOWSsystem32出现所有名字以java开头的文件，有，删之；
注意 ：jdk不要安装在带中文的路径下,最好也是不包含空格字符的英文路径;
3.2 编写HelloWorld程序1.源代码：
程序员写的程序；
程序员在自己可以看得懂得程序；
程序：字母、数字、其他符号；
源程序是程序员编写的，程序员自己可以看得懂得程序，本质就是一个文本文件，但是扩展名不是 .txt，而是 .java。
2.生成JVM可以执行的字节码(.class)文件
JVM：叫做 Java 虚拟机，是专门用来运行 Java 程序的。但是 JVM 是一个二货，只能识别 0 和 1，而存储 0 和 1 的文件叫做 字节码文件(.class文件)
如何把源文件(程序)翻译成JVM能够执行的字节码文件(程序)呢? 使用 javac 命令(编译命令)， 使用格式：javac 文件名.java 例如：编译HelloWorld.java 源文件: javac HelloWorld.java，生成一个字节码文件：HelloWorld.class
3. 把字节码文件交给JVM执行
不管是源文件(程序)还是字节码文件(程序)都存储在硬盘中? 不会自动执行，如何把字节码文件交给 JVM 执行呢? 使用 java 命令(运行命令)。 使用格式: java 文件名 例子：java HelloWorld
1.编写源文件。 创建一个名称为 HelloWorld.txt 的文本文件，把扩展名修改为 .java，打开 HelloWorld.java 源文件，输入以下内容，并保存(ctrl+s)。
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
2.编译: javac命令。 根据 .java源文件 生产对应的 .class文件(字节码文件)。 使用 javac 命令的格式：javac 文件名.java。javac HelloWorld.java。
注意：
保证当前路径下 javac命令 可以使用。
保证当前路径下有要进行编译的 源(.java)文件。
使用编译javac命令时，文件名后面必须写 扩展名.java。
3.3HelloWorld常见问题3.运行: java命令。 把 字节码(.class)文件 交给 jvm 执行。使用 java 命令的格式：java 文件名，java HelloWorld，同样要注意：
保证当前路径下 java 命令 可以使用。
保证当前路径下有要进行运行的 字节码(.class)文件。
使用运行 java 命令 时，文件名后面不能写 扩展名.class。
四、java基本语法 4.1 注释 4.1.1 概念1.大小写问题。Java语言对大小写敏感（区分大小写）
2.非法字符问题。Java中的符号都是英文格式的
3.在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件
4.编译命令后的java文件名需要带文件后缀.java
5.运行命令后的class文件名（类名）不带文件后缀.class
4.1.2 特点在代码书写过程中添加书写的解释与说明的文字.
4.1.3 分类在代码中添加注释可提高代码的可读性。注释中包含了程序的信息，可以帮助程序员更好地阅读和理解程序。在 Java 源程序文件 的任意位置都可以添加注释，且 Java 编译器不编译代码中的注释，也就是说代码中的注释对程序不产生任何影响。所以开发者不仅可以在注释中编写代码的说明文字、设计者的个人信息，还可以使用注释来屏蔽某些不希望执行的代码。
- 单行注释
单行注释的格式是使用//，从//开始至本行结尾的文字将作为注释文字
// 这是单行注释文字
- 多行注释
多行注释的格式是使用将一段较长的注释括起来
// 注意：多行注释不能嵌套使用。
- 文档注释
文档注释以结束,当文档注释出现在声明(如类的声明、类的成员变量声明、类的成员方法声明等)之前时，会被 Javadoc 文档工具 读取作为 Javadoc 文档内容。文档注释的格式与多行注释的格式相同。对于初学者而言，文档注释并不是很重要，了解即可。
说明：一定要养成良好的编码习惯。软件编码规范中提到 可读性第一，效率第二，所以程序员必须要在程序中添加适量的注释来提高程序的可读性和可维护性。建议程序中的注释总量要占程序代码总量的 20%~50%。
4.2 关键字 4.2.1 概念4.2.2 特点关键字是指被在java中已经被赋予了特殊含义的单词
4.2.3 关键字列表关键字的字母全部小写
单个单词
常用的代码编辑器对关键字都有高亮显示
4.3 标识符 4.3.1 概念常用的关键字51关键字+2个保留字
2个保留字conest goto
4.3.2 命名规则标识符可以简单地理解为一个名字，用来标识类名、变量名、方法名、数组名等的有效字符序列。
也可以理解为在java代码书写期间所有由我们命名的都可以称之为标识符
4.3.3 命名规范由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字。
不能使用java中的关键字作为标识符。
标识符对大小写敏感（区分大小写）。
见名知意:根据名字知道标识符对应功能
驼峰命名法：如果标识符由多个单词组成除首个单词首字母外其余单词首字母大写 passWord
随着java的发展,java程序员在遵循已有规范的基础上对于不同标识符定义了默认的规范(江湖规矩)
4.4 常量 4.4.1 概念类名：通常使用名词，第一个单词字母必须大写，后续单词首字母大写。(大驼峰式)
方法名：通常使用动词，第一个单词首字母小写，后续单词首字母大写。(小驼峰式)
包名:通常采用公司倒置的域名,例如:con.baidu.部门名.功能名
变量：第一个单词首字母小写，后续单词首字母大写。(小驼峰式)
常量：所有字母均大写。
单词的拼接：通常使用 userLastName 方式拼接单词，而不是 user_last_name。
4.4.2 分类 4.4.2.1按照数据类型分在程序执行过程中不允许改变的量,称之为常量.
字符串常量
用双引号括起来的多个字符（可以包含0个、一个或多个），例如"a"、“abc”、"中国"等
整数常量
整数，例如：-10、0、88等
小数常量
小数，例如：-5.5、1.0、88.88等
字符常量
用单引号括起来的一个字符，例如：‘a’、‘5’、‘B’、'中’等
布尔常量
布尔值，表示真假，只有两个值true和false
空值常量
4.4.2.2按照书写方式分一个特殊的值，空值，值为null
默认常量
在程序书写过程中无需定义可直接使用的常量,上面的常量都可以看做默认常量
自定义常量
4.5 数据类型 4.5.1 概念通过代码定义使用关键字final定义的常量
4.5.2 分类Java是一个强类型语言，对每一种数据都规定了范围.在代码书写存储数据时必须指定其数据类型
4.5.3 取值范围java数据类型分为两大类:基本数据类型与引用数据类
基本数据类型分为四类八种
引用类型主要是面向对象中的类
4.6 变量 4.6.1 概念java中对于取值范围的实际范围只需要知道常用范围即可
整数类型取值范围:-2位数次方-1 ~ 2位数次方-1 -1(位数为内存占用*8)
字符类型取值范围0~65535 (就是0~231)
4.6.2 变量定义的格式在程序运行过程中可以改变的量,称之为变量.类似于数学中的x,根据运算计算结果,在java中可以使用使用声明变量的形式进行保存.
- 格式一
将变量的声明赋值一同进行
数据类型 变量名(标识符)=值;
int x=1;
- 格式二
将变量的声明与赋值分开书写
声明: 数据类型 变量名(标识符);
赋值:已经声明的变量名=值;
注意:变量声明时可以不用赋值,但是如果使用变量,那么在使用前必须进行赋值
int x;
x=1;
- 格式三
4.6.3 注意事项同时声明创建多个相同类型变量并进行赋值(也可以只声明不进行赋值)
数据类型 变量名 = 值,变量名 = 值, …;
int a=1,b=2,c=3;
4.7 数据类型转换 4.7.1 概念
- 在同一对花括号中，变量名不能重复。
- 变量在使用之前，必须初始化（赋值）。
- 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。
- 定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。
- 变量实际存储的是数据的地址，修改的也是地址
4.7.2 分类java是强类型语言,在声明变量保存数据时需要声明保存数据的类型,以便于jvm开辟对应的大小数据空间进行数据的存储,但是有时可能会出现声明时使用的数据类型与最终使用的类型不匹配(常出现同种类型整数小数之间),这个时候就需要使用类型转换,将数据类型转换为我们需要的类型
- 自动类型转换(隐式转换)
把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可,无特殊语法格式
示例
double num1 = 5.5; int num2 = (int) num1; // 将double类型的num1强制转换为int类型 System.out.println(num2); // 输出5（小数位直接舍弃）
- 强制类型转换(显式转换)
把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。由于数据类型存储数据的上限,这种类型转换可能造成数据的溢出,所以需要额外定义语法进行书写
强制类型转换注意事项
char类型的数据转换为int类型是按照码表中对应的int值进行计算的。比如在ASCII码表中，'a’对应97。
int a = 'a'; System.out.println(a); // 将输出97
整数默认是int类型，byte、short和char类型数据参与运算均会自动转换为int类型。
byte b1 = 10; byte b2 = 20; byte b3 = b1 + b2; // 第三行代码会报错，b1和b2会自动转换为int类型，计算结果为int，int赋值给byte需要强制类型转换。 // 修改为: int num = b1 + b2; // 或者： byte b3 = (byte) (b1 + b2);
4.8 运算符 4.8.1 概念boolean类型不能与其他基本数据类型相互转换。
- 运算符
对常量或者变量进行操作的符号
- 表达式
4.8.2 分类 4.8.2.1 算术运算符用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。 不同运算符连接的表达式体现的是不同类型的表达式。
| 符号 | 作用 | 说明 |
|---|---|---|
| + | 加 | 将数据类型变量相加,如果是字符串变为连接符 |
| - | 减 | 将数据类型变量相减 |
| * | 乘 | 将数据类型变量相乘 |
| / | 除 | 将数据类型变量相除 |
| % | 取余 | 获取的是两个数据做除法的余数 |
注意事项
/和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
示例
int a = 10; int b = 3; System.out.println(a / b); // 输出结果3 System.out.println(a % b); // 输出结果1
- 字符的"+"操作
char类型参与算术运算
使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值
- ‘a’ – 97 a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加
- ‘A’ – 65 A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加
- ‘0’ – 48 0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加
// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少 char ch1 = 'a'; System.out.println(ch1 + 1); // 输出98，97 + 1 = 98 char ch2 = 'A'; System.out.println(ch2 + 1); // 输出66，65 + 1 = 66 char ch3 = '0'; System.out.println(ch3 + 1); // 输出49，48 + 1 = 49
- 算术表达式
算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。
提升规则
byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。 整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型 等级顺序：byte,short,char --> int --> long --> float --> double
示例
byte b1 = 10; byte b2 = 20; // byte b3 = b1 + b2; // 该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度 int i3 = b1 + b2; // 应该使用int接收 byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型 ------------------------------- int num1 = 10; double num2 = 20.0; double num3 = num1 + num2; // 使用double接收，因为num1会自动提升为double类型
正是由于上述原因，所以在程序开发中我们很少使用byte或者short类型定义整数。也很少会使用char类型定义字符，而使用字符串类型，更不会使用char类型做算术运算。
- 字符串的"+"操作
当“+”操作中出现字符串时，这个”+”是字符串连接符，而不是算术运算。
System.out.println("Amour恋空"+ 666); // 输出：Amour恋空666
在”+”操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行“+”操作时，从左到右逐个执行。
System.out.println(1 + 99 + "Amour恋空"); // 输出：100Amour恋空 System.out.println(1 + 2 + "Amour恋空" + 3 + 4); // 输出：3Amour恋空34 // 可以使用小括号改变运算的优先级 System.out.println(1 + 2 + "yunhe" + (3 + 4)); // 输出：3Amour恋空74.8.2.2 赋值运算符
| 符号 | 作用 | 示例 | 等价 |
|---|---|---|---|
| += | 相加结果赋予左侧 | a += b; | 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 = a & b; |
| |= | 或结果赋予左侧 | a |= b; | a = a |
| ^= | 异或结果赋予左侧 | a ^= b; | a = a ^ b; |
| <<= | 左移结果赋予左侧 | a <<= b; | a = a << b; |
| >>= | 右移结果赋予左侧 | a >>= b; | a = a >> b; |
| >>>= | 无符号右移结果赋予左侧 | a >>>= b; | a = a >>> b; |
注意
扩展的赋值运算符隐含了强制类型转换。
示例
short s = 10; s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度 s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);4.8.2.3 自增自减运算符
自增、自减运算符是单目运算符，可以放在变量之前，也可以放在变量之后。自增、自减运算符的作用是使变量的值加1或减1。
| 符号 | 作用 | 说明 |
|---|---|---|
| ++ | 自增 | 变量的值加1 |
| – | 自减 | 变量的值减1 |
注意事项
++和-- 既可以放在变量的后边，也可以放在变量的前边。
单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。
参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–。
参与操作的时候，如果放在变量的前边，先拿变量做++或者–，后拿变量参与操作。
最常见的用法：单独使用。
在运算中使用如下:
示例
int i = 10;
i++; // 单独使用
System.out.println("i:" + i); // i:11
int j = 10;
++j; // 单独使用
System.out.println("j:" + j); // j:11
int x = 10;
int y = x++; // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x:" + x + ", y:" + y); // x:11，y:10
int m = 10;
int n = ++m; // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
System.out.println("m:" + m + ", m:" + m); // m:11，m:11
4.8.2.4 关系运算符
关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。
| 符号 | 说明 |
|---|---|
| == | a==b，判断a和b的值是否相等，成立为true，不成立为false |
| != | a!=b，判断a和b的值是否不相等，成立为true，不成立为false |
| > | a>b，判断a是否大于b，成立为true，不成立为false |
| >= | a>=b，判断a是否大于等于b，成立为true，不成立为false |
| < | a |
| <= | a<=b，判断a是否小于等于b，成立为true，不成立为false |
注意事项
关系运算符的结果都是boolean类型，要么是true，要么是false。
千万不要把"=="误写成"="，"=="是判断是否相等的关系，"="是赋值。
int a = 10; int b = 20; System.out.println(a == b); // false System.out.println(a != b); // true System.out.println(a > b); // false System.out.println(a >= b); // false System.out.println(a < b); // true System.out.println(a <= b); // true // 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量 boolean flag = a > b; System.out.println(flag); // 输出false4.8.2.5 逻辑运算符
逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false。
| 符号 | 作用 | 说明 |
|---|---|---|
| & | 逻辑与 | a&b，a和b都是true，结果为true，否则为false |
| | | 逻辑或 | a|b，a和b都是false，结果为false，否则为true |
| ^ | 逻辑异或 | a^b，a和b结果不同为true，相同为false |
| ! | 逻辑非 | !a，结果和a的结果正好相反 |
示例
//定义变量
int i = 10;
int j = 20;
int k = 30;
//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((i > j) & (i > k)); //false & false,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
System.out.println((i < j) & (i < k)); //true & true,输出true
System.out.println("--------");
//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((i > j) | (i > k)); //false | false,输出false
System.out.println((i < j) | (i > k)); //true | false,输出true
System.out.println((i > j) | (i < k)); //false | true,输出true
System.out.println((i < j) | (i < k)); //true | true,输出true
System.out.println("--------");
//^ “异或”，相同为false，不同为true
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
System.out.println("--------");
//! “非”，取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false，,输出true
- 短路逻辑运算符
| 符号 | 作用 | 说明 |
|---|---|---|
| && | 短路与 | 作用和&相同，但是有短路效果 |
| || | 短路或 | 作用和|相同，但是有短路效果 |
在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。
逻辑与&，无论左边真假，右边都要执行。
短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。(存假便为假)
逻辑或|，无论左边真假，右边都要执行。
短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。(存真便为真)
int x = 3; int y = 4; System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算 System.out.println(x); // 4 System.out.println(y); // 5 System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算 System.out.println(x); // 4 System.out.println(y); // 44.8.2.6 位运算符
用于按位进行数据计算的运算符（与逻辑运算符相似）
| 符号 | 说明 |
|---|---|
| & | a&b， 将a与b的值按位进行与运算 |
| | | a|b， 将a与b的值按位进行或运算 |
| ~ | ~a， 将a值按位进行取反运算 |
| ^ | a^b， 将a与b的值按位进行异或运算 |
//位运算符
//将十进制数据转换为二进制之后 逐位进行对应的运算
public class Test5 {
public static void main(String[] args) {
//结果的二进制会自动再转换为十进制输出
// 6->0110
// 3->0011
//0代表false 1代表true
//6&3 0010->2
System.out.println(6&3);
//6|3 0111->7
System.out.println(6|3);
//6^3 0101->5
System.out.println(6^3);
//~6 实际计算机存储数据为63位 1位符号位
System.out.println(~6);
//右移
System.out.println(6>>2);
//左移
System.out.println(6<<2);
}
}
4.8.2.7 三目运算符
也称之为三元表达式,通过语法书写可以进行简单的逻辑判断
- 书写格式
关系表达式 ? 表达式1 : 表达式2;
问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。
示例
int a = 10; int b = 20; int c = a > b ? a : b; // 判断 a>b 是否为真，如果为真取a的值，如果为假，取b的值
图解
Java 中的表达式就是使用运算符连接起来并且符合 Java 规则的式子。运算符的优先级决定了表达式中运算的先后顺序。通常优先级由高到低的顺序依次是：自增和自减运算、算术运算、位运算、逻辑运算、赋值运算。如果两个运算有相同的优先级，会以从左到右的方式进行运算。下表显示 Java 中的运算符的优先级。
| 优先级 | 描 述 | 运 算 符 | 说 明 |
|---|---|---|---|
| 1 | 圆括号 | () | 优先计算圆括号里代码 |
| 2 | 自增，自减，逻辑非，正号，负号，取反 | ++ – ！ + - ~ | 优先计算导致变量自身改变的运算符 |
| 3 | 乘，除，取余 | * / % | 算术优先乘除法，同级从左到右 |
| 4 | 加，减 | + - | 乘除之后计算加减法，同级从左到右 |
| 5 | 左移位，右移位，无符号右移位 | << >> >>> | 同级从左到右 |
| 6 | 小于，小于等于，大于，大于等于，判断继承关系 | < <= > >= instanceof | 同级从左到右 |
| 7 | 等于，不等于 | == != | 同级从左到右 |
| 8 | 与 | & | 同级从左到右 |
| 9 | 异或 | ^ | 同级从左到右 |
| 10 | 或 | | | 同级从左到右 |
| 11 | 逻辑与 | && | 同级从左到右 |
| 12 | 逻辑或 | || | 同级从左到右 |
| 13 | 赋值 | = += -= *= /= %= <<= >>= &= ^= |= >>>= | 最后赋值 |
在初期学习中,由于没有前后台的 数据交互,所以我们只能声明变量的形式进行数据操作,但是变量值固定不能做到随时输入,所以可以使用java API提供的Scanner工具类来实现数据的输入操作
- 使用步骤
1.导包
Scanner 类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。
import java.util.Scanner;
2.创建Scanner对象
Scanner sc = new Scanner(System.in);// 创建Scanner对象，sc表示变量名，其他均不可变
3.调用方法接收数据
int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回。 //也可以调用nextLine();方法获取输入的字符串 //但是注意 nextLine()不能与nextInt()连用
示例
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
int x = sc.nextInt();
//输出数据
System.out.println("x:" + x);
}
}
4.10 流程控制语句
4.10.1 顺序流程控制语句通过特定的语法,像控制运算符优先级一样,控制java代码语句的执行顺序的方式
顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
- 顺序结构执行流程图
也叫做分支流程控制语句.在程序执行过程中根据表达式判断的结果选择执行对应的分支(类似于三目运算符)
- if分支语句
语法一
//if单分支语法
if (关系表达式) {
语句体;
}
执行流程
①首先计算关系表达式的值
②如果关系表达式的值为true就执行语句体
③如果关系表达式的值为false就不执行语句体
④继续执行后面的语句内容
示例
public class IfDemo {
public static void main(String[] args) {
System.out.println("开始");
//定义两个变量
int a = 10;
int b = 20;
//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
if(a == b) {
System.out.println("a等于b");
}
//需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
int c = 10;
if(a == c) {
System.out.println("a等于c");
}
System.out.println("结束");
}
}
语法二
//if双分支语法
if (关系表达式) {
语句体1;
} else {
语句体2;
}
执行流程
①首先计算关系表达式的值
②如果关系表达式的值为true就执行语句体1
③如果关系表达式的值为false就执行语句体2
④继续执行后面的语句内容
示例
public class IfDemo02 {
public static void main(String[] args) {
System.out.println("开始");
//定义两个变量
int a = 10;
int b = 20;
b = 5;
//需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于b
if(a > b) {
System.out.println("a的值大于b");
} else {
System.out.println("a的值不大于b");
}
System.out.println("结束");
}
}
语法三
//if多分支语法
if (关系表达式1) {
语句体1;
} else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
执行流程
①首先计算关系表达式1的值
②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
④…
⑤如果没有任何关系表达式为true，就执行语句体n+1。
示例
import java.util.Scanner;
public class IfDemo03 {
//键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
public static void main(String[] args) {
System.out.println("开始");
// 需求：键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个星期数(1-7)：");
int week = sc.nextInt();
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 {
System.out.println("星期日");
}
System.out.println("结束");
}
}
三目运算符与if语句区别
1、语法上的区别
三目运算符是运算符，分支语句是流程控制语句
2、返回结果的区别
三目运算符执行结束后必须创建变量保存结果，分支语句可以直接执行代码块
3、使用的区别
进行简单判断且返回常量数据时，使用三目运算符
进行复杂条件判断时，使用分支语句
- switch分支语句
语法
switch (表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
...
default:
语句体n+1;
break;
}
执行流程
①首先计算出表达式的值
②其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结 束。
③最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
注意：switch中表达式的结果可以为byte short int char String 枚举
示例1
public class SwitchDemo01{
//键盘录入一个月份输出季节
public static void main(String[] args) {
//键盘录入月份数据，使用变量接收
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个月份：");
int month = sc.nextInt();
//case穿透
switch(month) {
case 1:
case 2:
case 12:
System.out.println("冬季");
break;
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;
default:
System.out.println("你输入的月份有误");
}
}
}
注意：如果switch中得case，没有对应break的话，则会出现case穿透的现象。
示例2
public class SwitchDemo02{
public static void main(String[] args) {
//根据输入年月日输入当年已过天数
Scanner scanner=new Scanner(System.in);
System.out.println("请输入年份");
int year=scanner.nextInt();
System.out.println("请输入月份");
int month=scanner.nextInt();
System.out.println("请输入日期");
int day=scanner.nextInt();
//思考：2021年 5月9日已过天数
//1月份天数+2月+3月+4月+9日期
//声明变量保存已过天数
int sumDay=0;
//根据年份计算二月天数
//二月天数
int twoDay=28;
if(year%4==0){
twoDay=29;
}
switch (month-1) {
case 11:
sumDay+=30;
case 10:
sumDay+=31;
case 9:
sumDay+=30;
case 8:
sumDay+=31;
case 7:
sumDay+=31;
case 6:
sumDay+=30;
case 5:
sumDay+=31;
case 4:
sumDay+=30;
case 3:
sumDay+=31;
case 2:
sumDay+=twoDay;
case 1:
sumDay+=31;
default:
sumDay+=day;
}
System.out.println("已过"+sumDay+"天");
}
}
4.10.3 循环流程控制语句
- while循环
语法
初始化语句;
while (条件判断语句) {
循环体语句;
条件控制语句;
}
执行流程
①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续
示例1
public class WhileDemo {
public static void main(String[] args) {
//需求：在控制台输出5次"HelloWorld"
//while循环实现
int j = 1;
while(j<=5) {
System.out.println("HelloWorld");
j++;
}
}
}
示例2
世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
public class WhileTest {
public static void main(String[] args) {
//定义一个计数器，初始值为0
int count = 0;
//定义纸张厚度
double paper = 0.1;
//定义珠穆朗玛峰的高度
int zf = 8844430;
//因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
//折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
while(paper <= zf) {
//循环的执行过程中每次纸张折叠，纸张的厚度要加倍
paper *= 2;
//在循环中执行累加，对应折叠了多少次
count++;
}
//打印计数器的值
System.out.println("需要折叠：" + count + "次");
}
}
- do…while循环
语法
初始化语句;
do {
循环体语句;
条件控制语句;
}while(条件判断语句);
执行流程
① 执行初始化语句
② 执行循环体语句
③ 执行条件控制语句
④ 执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
⑤ 回到②继续
示例
public class DoWhileDemo {
public static void main(String[] args) {
//需求：在控制台输出5次"HelloWorld"
//for循环实现
for(int i=1; i<=5; i++) {
System.out.println("HelloWorld");
}
System.out.println("--------");
//do...while循环实现
int j = 1;
do {
System.out.println("HelloWorld");
j++;
}while(j<=5);
}
}
- for循环
语法
for (1初始化语句;2条件判断语句;4条件控制语句) {
3循环体语句;
}
* 初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
* 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
* 循环体语句： 用于表示循环反复执行的内容，简单说就是循环反复执行的事情
* 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
for循环可以看做是while一定结构的简化书写
执行流程
①执行初始化语句
②执行条件判断语句，看其结果是true还是false
如果是false，循环结束
如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续
示例1
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);
}
}
}
示例2
public class ForTest02 {
public static void main(String[] args) {
//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
int sum = 0;
//从1开始到5结束的数据，使用循环结构完成
for(int i=1; i<=5; i++) {
//将反复进行的事情写入循环结构内部
// 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
sum += i;
}
//当循环执行完毕时，将最终数据打印出来
System.out.println("1-5之间的数据和是：" + sum);
}
}
示例3
public class ForTest03 {
public static void main(String[] args) {
//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
int sum = 0;
//对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
for(int i=1; i<=100; i++) {
//对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
if(i%2 == 0) {
sum += i;
}
}
//当循环执行完毕时，将最终数据打印出来
System.out.println("1-100之间的偶数和是：" + sum);
}
}
示例4
public class ForTest04 {
public static void main(String[] args) {
//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
for(int i=100; i<1000; i++) {
//在计算之前获取三位数中每个位上的值
int ge = i%10;
int shi = i/10%10;
int bai = i/10/10%10;
//判定条件是将三位数中的每个数值取出来，计算立方和后与原始数字比较是否相等
if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
//输出满足条件的数字就是水仙花数
System.out.println(i);
}
}
}
}
while和do…while区别
- 语法不同
while与do…while- 执行流程不同
while先判断循环条件后进行循环体执行，do…while先执行循环体后进行条件判断- 循环体执行次数不同
while循环体可能由于条件不满足一次都不执行，do…while循环体至少执行一次- 使用场景不同
while就是根据条件决定循环体执行，跟循环条件无关必须至少执行
for循环和while的区别
- 变量作用域不同
for循环声明的变量再有当前循环可用，while在外声明可以直接使用- 使用场景不同
已知次数的循环使用for循环，未知次数的循环使用while循环
死循环
4.10.4 流程跳转语句
- for( ; ; ){}
- while(true){}
- do {} while(true)
跳转控制语句（break）
跳出循环，结束循环
跳转控制语句（continue）
跳过本次循环，继续下次循环
结束跳转语句（return）
结束当前方法返回数据
//流程跳转语句
//使用关键字操作流程语句的跳转 完成对应的功能
public class Test {
public static void main(String[] args) {
//return 方法级别的结束
//会将当前方法后续代码全部结束 直接方法结束
for(int i=1;i<=100;i++){
if(i==5){
return;
//System.out.println(11111);
//return结束级别比break更高
}
System.out.print(i+" ");
}
System.out.println();
System.out.println("~~~~~~~~~~~~~~~~~");
//continue跳过本次循环中continue后续的代码
//继续进行下次循环
for(int i=1;i<=100;i++){
if(i==5){
continue;
}
System.out.print(i+" ");
}
System.out.println();
System.out.println("~~~~~~~~~~~~~~~~~~~~~");
//break 结束当前代码块后续代码(结束当前循环)
//当前代码块中 break之后的代码不会执行
for(int i=1;i<=100;i++){
if(i==5){
break;
//在break同级代码中之后不能书写其他代码
//因为break只要执行就会结束
//System.out.println(111);
}
System.out.print(i+" ");
}
System.out.println();
}
}
4.10.5 嵌套循环
在循环中进行循环流程控制语句以及选择流程控制语句的嵌套,实现复杂执行逻辑功能
示例1
public static void main(String[] args) {
//外循环控制小时的范围，内循环控制分钟的范围
for (int hour = 0; hour < 24; hour++) {
for (int minute = 0; minute < 60; minute++) {
System.out.println(hour + "时" + minute + "分");
}
System.out.println("--------");
}
}
示例2
public static void main(String[] args){
//打印九九乘法表
for(int i = 1 ; i <= 9;i ++){
for(int j = 1 ; j <= i ; j++){
System.out.print(j + " * " + i + " = " + (i*j) +"t");
}
System.out.println();
}
}
4.11 数据数生成
Random类似Scanner，也是Java提供好的API，内部提供了产生随机数的功能
- 使用步骤
1.导包
Random类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。
import java.util.Random;
2.创建Random对象
固定创建对象语法
Random r = new Random();
3. 调用方法获取随机数
会生成0~传入数据(不包含)之间的整数,例如:传入10 随机生成0~9 之间的数据
如果没有书写数据name会在int类型取值范围内随机生成
int num = r.nextInt(10);
示例1
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
//创建对象
Random r = new Random();
//用循环获取10个随机数
for(int i=0; i<10; i++) {
//获取随机数
int number = r.nextInt(10);
System.out.println("number:" + number);
}
//需求：获取一个1-100之间的随机数
int x = r.nextInt(100) + 1;
System.out.println(x);
}
}
示例2
程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
import java.util.Random;
import java.util.Scanner;
public class RandomTest {
public static void main(String[] args) {
//要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
Random r = new Random();
int number = r.nextInt(100) + 1;
while(true) {
//使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要猜的数字：");
int guessNumber = sc.nextInt();
//比较输入的数字和系统产生的数据，需要使用分支语句。
//这里使用if..else..if..格式，根据不同情况进行猜测结果显示
if(guessNumber > number) {
System.out.println("你猜的数字" + guessNumber + "大了");
} else if(guessNumber < number) {
System.out.println("你猜的数字" + guessNumber + "小了");
} else {
System.out.println("恭喜你猜中了");
break;
}
}
}
}
4.12 数组
4.12.1 概念
4.12.2 特点数组就是存储数据长度固定的容器，存储多个数据的数据类型要一致。
用于存储具有相同数据类型的容器称之为数组
4.12.3 语法只能用于存储相同数据类型的数据
数组中既可以存储基本数据类型数据,还可以存储引用类型数据(数组可以存储任意类型数据)
在创建时必须指定长度与存储数据的类型
数组一旦创建,数组存储的数据类型与长度不允许更改.
-
数组声明
数据类型[] 数组名; //声明一个存储指定[数据类型]的数组,名为[数组名] 数据类型 数组名 []; //声明一个存储指定[数据类型]名为[数组名]的数组
-
数组初始化创建
1.动态创建
数组动态创建也称为数组的动态初始化,就是在创建时只给定数组类型与长度，由系统给出默认初始化值
数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr = new int[3];
等号左边
-
int:数组的数据类型
-
[]:代表这是一个数组
-
arr:代表数组的名称
等号右边
-
new:为数组开辟内存空间
-
int:数组的数据类型
-
[]:代表这是一个数组
-
3:代表数组的长度
2.静态创建
数组静态创建也称为数组的静态初始化在创建数组时，直接将元素确定,由系统计算出数组的长度
简化版语法
数据类型[] 数组名 = {元素1,元素2,...};完整版语法
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};示例
public class ArrayDemo { public static void main(String[] args) { //定义数组 int[] arr = {1, 2, 3}; //输出数组名 System.out.println(arr); //输出数组中的元素 System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); } } -
-
数组访问
语法
数组名[索引];
示例
public class ArrayDemo { public static void main(String[] args) { int[] arr = new int[3]; //输出数组名 System.out.println(arr); //[I@880ec60 //输出数组中的元素 System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); } }
- 单个数组变量指向数组的内存图
- 多个数组变量指向不同数组的内存图
- 多个数组变量指向相同数组内存图
示例
使用数组保存斐波那契额数列
public class ArrayFBNQ {
public static void main(String[] args) {
//**1、使用数组保存斐波那契数列**
//（头两个数为1 之后为前两项数据之和）
//1 1 2 3 5 8 13 21 34 55 89
Scanner sc=new Scanner(System.in);
System.out.println("请输入数列个数");
//获取数列个数
int nextInt = sc.nextInt();
//创建对应长度的数组
int [] arr=new int[nextInt];
//遍历数组存入数据
for(int i=0;i
数组常用排序算法
4.13 二维数组
4.13.1 概念
java中本质不存在多维数组,多维数组的概念就是依据与数组可以存储任意类型数据,二维数组其实就是一个元素为一维数组的数组
4.13.2 语法
- 数组声明
数据类型[][] 变量名;
数据类型 变量名[][];
数据类型[] 变量名[];
//本质就是声明数组存储数组
- 数组初始化创建
动态初始化数据类型[][] 变量名 = new 数据类型[m][n];
//m表示这个二维数组有多少个一维数组
//n表示每一个一维数组的元素个数
静态初始化标准版：
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
示例1
某公司按照季度和月份统计的数据如下：单位(万元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
public class ArrayCase {
public static void main(String[] args) {
// 定义二维数组
int[][] arr = {{22, 66, 44}, {77, 33, 88}, {25, 45, 65}, {11, 66, 99}};
// 求总和
int he = 0;
for (int i = 0; i < arr.length; i++) {
// 求每一季度的总销售额
int sum = 0;
for (int j = 0; j < arr[i].length; j++) {
sum += arr[i][j];
}
// 将每一季度的总销售额累加到总和
he += sum;
System.out.println("第" + (i + 1) + "季度的销售额是：" + sum);
}
System.out.println("总销售额: " + he);
}
}
示例2
1
1 1
1 2 1
1 3 3 1
使用二维数组完成杨辉三角的保存
public class ArrayYHSJ{
public static void main(String[] args) {
//**2、使用二维数组完成杨辉三角的保存**
Scanner sc=new Scanner(System.in);
System.out.println("请输入行数");
int [][] arr=new int [sc.nextInt()][];
for(int i=0;i
4.14 方法
4.14.1 概念
方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
不同的语言还会称之为函数、过程
4.14.2 语法
修饰符 返回值类型 方法名(参数列表){
//代码省略...
return 结果;
}
修饰符 public static固定写法(初期学习)
返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
参数列表： 方法在运算过程中的未知数据，调用者调用方法时传递
return： 将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束
小贴士：return 结果; 这里的"结果"在开发中，我们正确的叫法成为方法的返回值
示例
将打怪物发射炮弹重复的代码，抽取到方法中并使用
public static void fire() {
System.out.println("准备发射5发炮弹");
System.out.println("发射第1发炮弹* * * *");
System.out.println("发射第2发炮弹* * * *");
System.out.println("发射第3发炮弹* * * *");
System.out.println("发射第4发炮弹* * * *");
System.out.println("发射第5发炮弹* * * *");
System.out.println("发射5发炮弹结束");
}
在main方法中调用
public static void main(String[] args) {
System.out.println("游戏开始...");
System.out.println("看到了一个怪物...血牙野猪...");
//调用方法,发射炮弹
fire();
System.out.println("...血牙野猪被打倒...");
}
4.14.3 调用
- 语法
方法名(参数...);
方法必须先创建才可以使用，该过程成为方法定义
方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用
-
方法调用过程图解
-
调用方法三种形式
直接调用：直接写方法名调用
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;
}
输出语句调用：在输出语句中调用方法
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) {
// 错误，不能输出语句调用void类型方法
System.out.println(printHello());
}
public static void printHello() {
System.out.println("Hello");
}
4.14.4 方法的重载
指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。
参数列表：个数不同，数据类型不同，顺序不同。
重载方法调用：JVM通过方法的参数列表，调用不同的方法。
注意事项
重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载
//计算两个数据的和
public static int sum(int a,int b){
return a+b;
}
//方法的重载
//在同一个类中 方法名相同 参数列表不同 称之为发生了方法的重载
//有时在进行方法定义时 同一个功能由于参数传递不同可能需要书写多个方法
//需要定义多个方法名 但是功能相似 这个时候就可以使用方法的重载定义名称相同的不同方法
//参数列表不同——参数个数不同
public static int sum(int a,int b,int c){
return a+b+c;
}
//参数类型不同——参数个数相同 参数类型不同
public static double sum(double a,double b,double c){
return a+b+c;
}
//参数顺序不同——参数个数相同类型相同（两个以上）
//顺序不同不是参数变量顺不同 而是数据类型的顺序不同
public static double sum(int a,double b) {
return a+b;
}
public static double sum(double a,int b) {
return a+b;
}
//方法重载jvm调用过程
//顺序执行 执行对应方法时 会到方法栈中查找对应的方法名
//如果对应方法不存在则报错
//如果存在则进行判断 是否唯一
//如果存在多个同名方法 根据调用方法传入的参数个数进行匹配
//如果个数存在相同 依次根据参数的数据类型进行匹配
//在依次匹配时进行方法的选择
4.14.5 方法的参数传递
-
方法参数传递基本类型
测试代码
public class ArgsDemo01 {
public static void main(String[] args) {
int number = 100;
System.out.println("调用change方法前：" + number);
change(number);
System.out.println("调用change方法后：" + number);
}
public static void change(int number) {
number = 200;
}
}
结论
基本数据类型的参数，形式参数的改变，不影响实际参数
-
方法参数传递引用类型
测试代码
public class ArgsDemo02 {
public static void main(String[] args) {
int[] arr = {10, 20, 30};
System.out.println("调用change方法前：" + arr[1]);
change(arr);
System.out.println("调用change方法后：" + arr[1]);
}
public static void change(int[] arr) {
arr[1] = 200;
}
}
结论
对于引用类型的参数，形式参数的改变，影响实际参数的值
