1 开发前⾔

---

1.1 Java语⾔概述

认识Linux操作系统         Linux起源于 1991 年， 1995 年随着互联⽹的发展⽽流⾏开来；它是⼀个开源的操作系统，是⼀个类 Unix 操作系统；⽬前， Linux 是主流的服务器操作系统，⼴泛应⽤于互联⽹、云计算、智能⼿机（ Android ）等 领域；由于 Java 主要⽤于服务器端的开发，因此 Java 应⽤的部署环境很多为 Linux 。

1. Java发展历史

        Java之⽗：詹姆斯 · ⾼斯林。         1991年，在 Sun 公司 (Stanford University Network) ⼯作期间，⾼斯林和⼀群技术⼈员创建了⼀个名为 Oak 的项⽬，旨在开发运⾏于虚拟机的编程语⾔，同时允许程序在电视机机顶盒等多平台上运⾏。后来，这项 ⼯作就演变为 Java 。随着互联⽹的普及，尤其是⽹景开发的⽹⻚浏览器的⾯世， Java 成为全球流⾏的开发 语⾔。因此被⼈称作 Java 之⽗。 Java 百度百科：

• 1991年Sun公司为了抢占单⽚机智能化市场先机，成⽴了Green项⽬⼩组，该⼩组在解决单⽚机系统编 程问题时，对C++进⾏了改造，开发了⼀种称为Oak的⾯向对象语⾔。
• 1995年，随着互联⽹的蓬勃发展，Sun公司发现Oak很适合在⽹络上传输，继⽽推出了可以嵌⼊⽹⻚并且可以随同⽹⻚在⽹络上传输的Applet，并将Oak更名为Java。
• 1996年JDK1.0⾯世。
• 1998年J2EE发布。
• 1999年J2ME、J2SE、J2EE正式发布，标志着Java应⽤开始普及。
• 2004年J2SE 1.5发布，更名为Java SE 5.0，代号为“Tiger”，是Java语⾔发展史上的⼜⼀⾥程碑。包含了 从1996年发布1.0版本以来的最重⼤的更新，其中包括泛型⽀持、基本类型的⾃动装箱、改进的循环、枚举类型、格式化I/O及可变参数。
• 2009年，Oracle甲⻣⽂公司收购Sun公司。
• 2011年推出Java 7.0
• 2014年发布Java 8.0
• 2017年发布Java 9.0
• 2018年3⽉发布Java 10.0
• 2018年9⽉发布Java 11.0

Java语⾔能做什么         Java语⾔主要应⽤在互联⽹程序的开发领域。常⻅的互联⽹程序⽐如天猫、京东、物流系统、⽹银系 统等，以及服务器后台处理⼤数据的存储、查询、数据挖掘等也有很多应⽤。

1.2 计算机基础知识

⼆进制         计算机中的数据不同于⼈们⽣活中的数据，⼈们⽣活采⽤⼗进制数，⽽计算机中全部采⽤⼆进制数表 示，它只包含 0 、 1 两个数，逢⼆进⼀， 1+1=10 。每⼀个 0 或者每⼀个 1 ，叫做⼀个 bit( ⽐特 ) 。 下⾯了解⼀下⼗进制和⼆进制数据之间的转换计算。

• ⼗进制数据转成⼆进制数据：使⽤除以2获取余数的⽅式

• ⼆进制数据转成⼗进制数据： 使⽤ 8421 编码的⽅式

 ⼩贴⼠：⼆进制数系统中，每个0或1就是⼀个位，叫做bit(⽐特)。

字节         字节是我们常⻅的计算机中最⼩存储单元。计算机存储任何的数据，都是以字节的形式存储，右键点 击⽂件属性， 我们可以查看⽂件的字节⼤⼩。 8 个 bit （⼆进制位） 0000-0000 表示为 1 个字节，写成 1 byte 或者 1 B 。

• 8 bit = 1 B
• 1024 B =1 KB
• 1024 KB =1 MB
• 1024 MB =1 GB
• 1024 GB = 1 TB
• 1024 TB = 1 PB
• 1024 PB = 1 EB

常⽤DOS命令         Java语⾔的初学者，学习⼀些 DOS 命令，会⾮常有帮助。 DOS 是⼀个早期的操作系统，现在已经被 Windows 系统取代，对于我们开发⼈员，⽬前需要在 DOS 中完成⼀些事情，因此就需要掌握⼀些必要的命 令。

• 进⼊DOS操作窗⼝
• 按下Windows+R键盘，打开运⾏窗⼝，输⼊cmd回⻋，进⼊到DOS的操作窗⼝。

 

• 打开DOS命令⾏后，看到⼀个路径 C:Users 就表示我们现在操作的磁盘是C盘。

 

• 常⽤命令

2 Java语⾔开发环境搭建

---

2.1 Java虚拟机 -- JVM

• JVM (Java Virtual Machine)：Java虚拟机，简称 JVM，是运⾏所有Java程序的假想计算机，是Java程序的运⾏环境，是Java 最具吸引⼒的特性之⼀。我们编写的Java代码，都运⾏在 JVM 之上。
• 跨平台：任何软件的运⾏，都必须要运⾏在操作系统之上，⽽我们⽤Java编写的软件可以运⾏在任何 的操作系统上，这个特性称为 Java 语⾔的跨平台特性。该特性是由 JVM 实现的，我们编写的程序运⾏在JVM上，⽽JVM 运⾏在操作系统上。

2.2 Java编译运⾏过程 程序员编写的 Java 源⽂件 (.java) ⾸先要经过编译，⽣成所谓字节码⽂件 (.class) ，然后运⾏在 JVM 上：

Java 官⽅提供了针对不同平台的 JVM 软件，这些 JVM 遵循着相同的标准，只要是标准的 .class ⽂件，就可以在不同的 JVM 上运⾏，⽽且运⾏的效果相同。这样，就实现了所谓 “ ⼀次编程到处使⽤ ” 。

2.3 JDK 和 JRE

• JDK (Java Development Kit)：是 Java 程序开发⼯具包，包含 JRE 和开发⼈员使⽤的⼯具。
• JRE (Java Runtime Environment)：是 Java 程序的运⾏时环境，包含 JVM 和运⾏时所需要的 核⼼类库 。

我们想要运⾏⼀个已有的 Java 程序，那么只需安装 JRE 即可。 我们想要开发⼀个全新的 Java 程 序，那么必须安装 JDK 。

 ⼩贴⼠：三者关系 JDK > JRE > JVM

2.4 JDK9安装图解

需要注意的是， 对于 Windows 版的 JDK 安装程序，除了安装⼀个已经包含有 JRE 的 JDK 之外，还要再安装⼀个独⽴的 JRE （所谓 “ 公共的 JRE” ）并在注册表中对其进⾏注册，其⽬的是对于⼀些需要⽤到 JRE 的应⽤程 序可以通过注册信息⾃动的找到 JRE 。 “ 公共 JRE” 是⼀个可选项，可以选择不安装，毕竟 JDK 中已经包含有了⼀个完整的 JRE （只不过没有在注册S表中注册）；如果选择了该项，在安装完 JDK 之后，安装程序还要提示⽤户选择公共 JRE 的安装⽬录。

 JDK 安装完成后，在 JDK 安装路径下可以看到如下内容：

• bin⽬录：⽤于存放JDK⼯具命令，⽐如⽤于编译 Java 程序的 javac 命令、⽤于启动 JVM 运⾏ Java 程序的 java 命令、⽤于⽣成⽂档的 javadoc 命令和⽤于打包的 jar 命令等等；
• jre⽬录：⽤于存放 JDK 所包含的 JRE ，其中包含有 JVM 和核⼼类库；
• lib⽬录：⽤于存放 JDK ⼯具命令所对应的⼯具包（Tool APIs）；
• demo⽬录：⽤于存放⼀些示例程序；
• src.zip⽂件：⽤于存放核⼼类库的 Java 源代码。

2.5 JAVA_HOME环境变量的配置   配置环境变量作⽤ 开发 Java 程序，需要使⽤ JDK 中提供的⼯具，⼯具在 JDK9 安装⽬录的 bin ⽬录下。   在 DOS 命令⾏下使⽤这些⼯具，就要先进⼊到 JDK 的 bin ⽬录下，这个过程就会⾮常的麻烦。 不进⼊ JDK 的 bin ⽬录，这些⼯具就不能使⽤，会报错。 为了开发⽅便，我们想在 任意的⽬录下都可以使⽤ JDK 的开发⼯具 ，则必须要配置环境变量，配置环境变量的意义在于告诉操作系统，我们使⽤的 JDK 开发⼯具在哪个⽬录下。 配置环境变量步骤

1. 此电脑⿏标右键 --> 选择 属性

 2. 选择 ⾼级系统设置 --> 选择 环境变量

 

3. 点击下⽅系统变量的 新建 ，创建新的环境变量，变量名输⼊ JAVA_HOME ，变量值输⼊ JDK9 的安装⽬录 C:Program FilesJavajdk-9.0.4 4. 选中 Path 环境变量， 双击 或者 点击编辑 5. 点击 新建 ，键⼊ %JAVA_HOME%bin ，必须是英⽂格式。点击确定。

 6. 环境变量配置完成，重新开启DOS命令⾏，在任意⽬录下输⼊ javac 命令。

3 HelloWorld⼊⻔程序

---

3.1 程序开发步骤说明   开发环境已经搭建完毕，可以开发我们第⼀个 Java 程序了。 Java 程序开发三步骤： 编写、编译、运⾏ 。

 

3.2 编写Java源程序 1. 在 D:day01 ⽬录下新建⽂本⽂件，完整的⽂件名修改为 HelloWorld.java ，其中⽂件名     为 HelloWorld ，后 缀名必须为 .java 。 2. ⽤记事本打开

使⽤ notepad++ 、 Sublime 等记事本软件。

3. 在⽂件中键⼊⽂本并保存，代码如下：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

⽂件名必须是 HelloWorld ，保证⽂件名和类的名字是⼀致的，注意⼤⼩写。 每个字⺟和符号必须与示例代码⼀模⼀样。

第⼀个 HelloWord 源程序就编写完成了，但是这个⽂件是程序员编写的， JVM 是看不懂的，也就不能运⾏，因此我们必须将编写好的 Java 源⽂件 编译成 JVM 可以看懂的 字节码⽂件 。 3.3 编译 Java 源⽂件 在 DOS 命令⾏中， 进⼊ Java 源⽂件的⽬录 ，使⽤ javac 命令进⾏编译。 命令：

javac HelloWorld.java 

编译成功后，命令⾏没有任何提示。打开 D:day01 ⽬录，发现产⽣了⼀个新的⽂件 HelloWorld.class ，该⽂件 就是编译后的⽂件，是 Java 的可运⾏⽂件，称为 字节码⽂件 ，有了字节码⽂件，就可以运⾏程序了。

Java 源⽂件的编译⼯具 javac.exe ，在 JDK 安装⽬录的 bin ⽬录下。但是由于配置了环境变量，可以 在任意⽬录下使⽤。

3.4 运⾏ Java 程序 在 DOS 命令⾏中， 进⼊ Java 源⽂件的⽬录 ，使⽤ java 命令进⾏运⾏。 命令 :

java HelloWorld

java HelloWord 不要写 不要写 不要写 .class

Java 程序 .class ⽂件 的运⾏⼯具 java.exe ，在 JDK 安装⽬录的 bin ⽬录下。但是由于配置了环境变量，可以在任意⽬录下使⽤。

3.5 ⼊⻔程序说明 编译和运⾏是两回事

• 编译：是指将我们编写的 Java 源⽂件翻译成 JVM 认识的 class ⽂件，在这个过程中， javac 编译器会检查我们所写的程序是否有错误，有错误就会提示出来，如果没有错误就会编译成功。
• 运⾏：是指将 class⽂件 交给 JVM 去运⾏，此时 JVM 就会去执⾏我们编写的程序了。

关于main⽅法

• main⽅法：称为主⽅法。写法是固定格式不可以更改。main⽅法是程序的⼊⼝点或起始点，⽆论我们编写多 少程序，JVM 在运⾏的时候，都会从 main ⽅法这⾥开始执⾏。

3.6 添加注释 comment

• 注释：就是对代码的解释和说明。其⽬的是让⼈们能够更加轻松地了解代码。为代码添加注释，是⼗分必须 要的，它不影响程序的编译和运⾏。
• Java中有单⾏注释和多⾏注释

1. 单⾏注释以 //开头 换⾏结束
2. 多⾏注释以 结束

3.7 关键字 keywords

• 关键字：是指在程序中，Java已经定义好的单词，具有特殊含义。

1. HelloWorld案例中，出现的关键字有 public 、 class 、 static 、 void 等，这些单词已经被 Java定义好，全部都是⼩写字⺟，notepad++中颜⾊特殊。
2. 关键字⽐较多，不能死记硬背，学到哪⾥记到哪⾥即可。

3.8 标识符

• 标识符：是指在程序中，我们⾃⼰定义内容。⽐如类的名字、⽅法的名字和变量的名字等等，都是标识符。

1. HelloWorld案例中，出现的标识符有类名字 HelloWorld 。

• 命名规则： 硬性要求

1. 标识符可以包含 英⽂字⺟26个(区分⼤⼩写) 、 0-9数字 、 $(美元符号) 和 _(下划线) 。
2. 标识符不能以数字开头。
3. 标识符不能是关键字。

• 命名规范： 软性建议

1. 类名规范：⾸字⺟⼤写，后⾯每个单词⾸字⺟⼤写(⼤驼峰式)。
2. ⽅法名规范：⾸字⺟⼩写，后⾯每个单词⾸字⺟⼤写(⼩驼峰式)。
3. 变量名规范：全部⼩写。

4 字⾯量（直接量）

---

4.1 概述 字⾯量，也叫直接量：是指在 Java 程序中固定不变的数据。

4.2 分类

4.3 练习

需求:输出各种类型的常量。

public class ConstantDemo {
    public static void main(String[] args) {
        //输出整数字⾯量
        System.out.println(123);
        //输出⼩数字⾯量
        System.out.println(0.125);
        //输出字符字⾯量
        System.out.println('A');
        //输出布尔字⾯量
        System.out.println(true);
        //输出字符串字⾯量
        System.out.println("你好Java");
    }
}

5 变量和数据类型

---

5.1 变量概述

• 变量：变量就是指代在内存中开辟的存储空间，⽤于存放运算过程中需要⽤到的数据。

数学中，可以使⽤字⺟代替数字运算，例如 x=1+5 或者 6=x+5 。 程序中，可以使⽤字⺟保存数字的⽅式进⾏运算，提⾼计算能⼒，可以解决更多的问题。⽐如 x 保存5 ， x 也可 以保存 6 ，这样 x 保存的数据是可以改变的，也就是我们所讲解的变量。

 Java中要求⼀个变量每次只能保存⼀个数据，必须要明确保存的数据类型。

5.2 数据类型 数据类型分类 Java 的数据类型分为两⼤类：

• 基本数据类型：包括 整数 、 浮点数 、 字符 、 布尔 。
• 引⽤数据类型：包括 类 、 数组 、 接⼝ 。

基本数据类型   四类⼋种基本数据类型：

 Java中的默认类型：整数类型是 int 、浮点类型是 double 。

5.3 变量的定义/声明 变量定义的格式包括三个要素： 数据类型 、 变量名 、 数据值 。

格式

数据类型 变量名 = 数据值; 

练习 定义所有基本数据类型的变量，代码如下：

public class Variable {
 public static void main(String[] args) {
 //定义字节型变量
 byte b = 100;
 System.out.println(b);
 //定义短整型变量
 short s = 1000;
 System.out.println(s);
 //定义整型变量
 int i = 123456;
 System.out.println(i);
//定义⻓整型变量
 long l = 12345678900L;
 System.out.println(l);
 //定义单精度浮点型变量
 float f = 5.5F;
 System.out.println(f);
 //定义双精度浮点型变量
 double d = 8.5;
 System.out.println(d);
 //定义布尔型变量
 boolean bool = false;
 System.out.println(bool);
 //定义字符型变量
 char c = 'A';
 System.out.println(c);
 } 
}

long 类型：建议数据后加 L 表示。 float 类型 : 建议数据后加 F 表示。

5.4 注意事项

• 变量名称：在同⼀个⼤括号范围内，变量的名字不可以相同。
• 变量赋值：定义的变量，初始化后才能使⽤。

5.5 类型详解 int 类型 int 是最常⽤的整数类型。⼀个 int 类型的变量占⽤ 4 个字节（ 32 位），最⼤表示范围为： -2 31~2 31-1 ， 即 -2147483648~2147483647 。 整数的直接量的类型默认为 int 类型。 问题⼀：整数直接量超出了整数的范围 如果直接写出的整数超过了 int 的表达范围，将会出现编译错误。 请看如下代码：

int d = 10000000000;

以上代码中， 10000000000 不属于 int 类型的直接量，因为 Java 认为所有直接写出的整数都是 int 类型，⽽这 个数值超过了 int 的表达范围。 除了通常的⼗进制书写形式，整数直接量也经常写 16 进制的形式（以 0X 或 0x 开头）或 8 进制的形式（以 0 开头）。 问题⼆：整数运算的溢出 两个整数进⾏运算时，其结果可能会超过整数的范围⽽溢出，请看如下代码：

int a = 2147483647;
int b = -2147483648; a = a + 1; b = b - 1;
System.out.println("a=" + a);
System.out.println("b=" + b)

上述代码运⾏后的输出结果为：

a=-2147483648
b=2147483647

变量 a 最初的值为 2147483647 ，是 int 类型的最⼤值，加 1 以后出现了溢出现象， a 的值变成了 int 类型的最⼩值。⽽ b 变量最初赋的值为 -2147483648 ，是 int 类型的最⼩值，减 1 以后出现了溢出现象， b 的值变成了 int 类 型的最⼤值。这显然不符合加法和减法的规则，所以，在今后使⽤的时候要注意类似的问题。 float 、 double 类型 浮点数，就是⼩数，包括： float 和 double 。 double 类型的精度值是 float 类型的两倍，这正是其名称（双精度）的来由。 问题⼀：取值范围 float 和 double 的范围是由指数的位数来决定的。 float 的指数位有 8 位，⽽ double 的指数位有 11 位，分布如下： float ： 1bit （符号位） 8bits （指数位） 23bits （尾数位） double ： 1bit （符号位） 11bits （指数位） 52bits （尾数位） 于是， float 的指数范围为 -128 +127 ，⽽ double 的指数范围为 -1024 +1023 ，并且指数位是按补码的形式来划分的。 其中负指数决定了浮点数所能表达的绝对值最⼩的⾮零数；⽽正指数决定了浮点数所能表达的绝对值最⼤ 的数，也即决定了浮点数的取值范围。 float 的范围为 -2^128 ~ +2^128 ，也即 -3.40E+38 ~ +3.40E+38 ； double 的范围为 -2^1024 ~ +2^1024 ，也即 -1.79E+308 ~ +1.79E+308 。

问题⼆：浮点数存在舍⼊误差问题 由于浮点数内部⽤⼆进制的⽅式来表示⼗进制，会存在舍⼊误差。⼆进制系统中⽆法精确的表示 1/10 ，就好像⼗进制系统中⽆法精确的表示 1/3 ⼀样。对于⼀些要求精确运算的场合会导致代码的缺陷。请看如下代 码：

double money = 3.0;
double price = 2.9;
System.out.println(money - price);

上述代码的输出结果为： 

0.10000000000000009

查看上述结果，并没有如我们想象的为 0.1 。如果需要精确的运算可以考虑放弃使⽤ double 或 float ⽽采⽤ BigDecimal 类来实现。关于这⼀点，将在后续的章节中介绍。 char 类型 字符类型事实上是⼀个 16 位⽆符号整数，这个值是对应字符的编码， Java 字符类型采⽤ Unicode 字符集编码。 Unicode 是世界通⽤的定⻓字符集，所有的字符都是 16 位。 字符直接量可以采⽤诸如： ' 中 ' 的形式，也可以采⽤其对应的 16 进制的表示形式，例如： 'u4e2d' 。 问题⼀：使⽤转义字符 对于不⽅便输出的字符采⽤转义字符表示，例如：

 

6 数据类型转换

---

Java 程序中要求参与的计算的数据，必须要保证数据类型的⼀致性，如果数据类型不⼀致将发⽣类型的转 换。 6.1 ⾃动转换 ⼀个 int 类型变量和⼀个 byte 类型变量进⾏加法运算， 结果会是什么数据类型 ?

int i = 1;
byte b = 2;

运算结果，变量的类型将是 int 类型，这就是出现了数据类型的⾃动类型转换现象。

• ⾃动转换：将 取值范围⼩的类型 ⾃动提升为 取值范围⼤的类型 。

public static void main(String[] args) {
 int i = 1;
 byte b = 2;
 // bytex=b+i; // 报错
 // int类型和byte类型运算，结果是int类型
 int j = b + i;
 System.out.println(j);
}

转换原理图解 byte 类型内存占有 1 个字节，在和 int 类型运算时会提升为 int 类型 ，⾃动补充 3 个字节，因此计算后的结果还是 int 类型。 同样道理，当⼀个 int 类型变量和⼀个 double 变量运算时， int 类型将会⾃动提升为 double 类型进⾏运算。

public static void main(String[] args) {
 int i = 1;
 double d = 2.5;
 // int类型和double类型运算，结果是double类型
 // int类型会提升为double类型
 double e = d + i;
 System.out.println(e);
}

转换规则 范围⼩的类型向范围⼤的类型提升， byte 、 short 、 char 运算时直接提升为 int 。  6.2 强制转换 将 1.5 赋值到 int 类型变量会发⽣什么 ? 产⽣编译失败，肯定⽆法赋值。

int i = 1.5; // 错误

double 类型内存 8 个字节， int 类型内存 4 个字节。 1.5 是 double 类型，取值范围⼤于 int 。可以理 解为 double 是 8 升的⽔壶， int 是 4 升的⽔壶，不能把⼤⽔壶中的⽔直接放进⼩⽔壶去。 想要赋值成功，只有通过强制类型转换，将 double 类型强制转换成 int 类型才能赋值。

• 强制类型转换：将 取值范围⼤的类型 强制转换成 取值范围⼩的类型 。

⽐较⽽⾔，⾃动转换是 Java ⾃动执⾏的，⽽强制转换需要我们⾃⼰⼿动执⾏。 转换格式：

数据类型 变量名 = (数据类型) 被转数据值;

1.5 赋值到 int 类型，代码修改为：

// double类型数据强制转成int类型，直接去掉⼩数点。
int i = (int) 1.5;

同样道理，当⼀个 short 类型与 1 相加，我们知道会类型提升，但是还想给结果赋值给 short 类型变量， 就需要强制转换。

public static void main(String[] args) {
 // short类型变量，内存中2个字节
 short s = 1;
 
 s = s + 1; // 编译失败
 s = (short) (s+1); // 编译成功
}

转换原理图解 强烈注意

• 浮点转成整数，直接取消⼩数点，可能造成数据损失精度。
• int 强制转成 short 砍掉2个字节，可能造成数据丢失。

// 定义s为short范围内最⼤值
short s = 32767;
// 运算后，强制转换，砍掉2个字节后会出现不确定的结果
s = (short)(s + 10);

6.3 ASCII编码表

public static void main(String[] args) {
 // 字符类型变量
 char c = 'a';
 int i = 1;
 // 字符类型和int类型计算
 System.out.println(c + i); // 输出结果是98
}

在计算机的内部都是⼆进制的 0 、 1 数据，如何让计算机可以直接识别⼈类⽂字的问题呢？就产⽣出了编码表的概念。

• 编码表：就是将⼈类的⽂字和⼀个⼗进制数进⾏对应起来组成⼀张表格。

⼈们就规定： 将所有的英⽂字⺟、数字、符号都和⼗进制进⾏了对应，因此产⽣了世界上第⼀张 ASCII (American Standard Code for Information Interchange 美国标准信息交换码 ) 。

⼩贴⼠： 在 char 类型和 int 类型计算的过程中， char 类型的字符先查询编码表，得到 97 ，再和 1 求和，结果为98 。 char 类型提升为了 int 类型。 char 类型内存 2 个字节， int 类型内存 4 个字节。

7 运算符

---

7.1 算术运算符

Java 中，整数使⽤以上运算符，⽆论怎么计算，也不会得到⼩数。

public static void main(String[] args) {
 int i = 1234;
 System.out.println(i/1000*1000); // 计算结果是1000
}

• ++ 运算，变量⾃⼰增⻓1。反之， -- 运算，变量⾃⼰减少1，⽤法与 ++ ⼀致。

独⽴运算：

• 变量在独⽴运算时， 前++ 和 后++ 没有区别 。
• 变量 前++ ：例如 ++i 。
• 变量 后++ ：例如 i++ 。

混合运算：

• 和其他变量放在⼀起， 前++ 和 后++ 就产⽣了不同。
• 变量 前++ ：变量a⾃⼰加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是 2。

public static void main(String[] args) {
 int a = 1;
 int b = ++a;
 System.out.println(a); // 计算结果是2
 System.out.println(b); // 计算结果是2 
}

• 变量 后++ ：变量a先把⾃⼰的值1，赋值给变量b，此时变量b的值就是1，变量a⾃⼰再加

1 。 a 的结果是 2 ， b 的结果是 1 。

public static void main(String[] args) {
 int a = 1;
 int b = a++;
 System.out.println(a); // 计算结果是2
 System.out.println(b); // 计算结果是1 
}

• + 符号在字符串中的操作：
• + 符号在遇到字符串的时候，表示连接、拼接的含义。
• "a"+"b"的结果是“ab”，连接含义

 7.2 赋值运算符

•  赋值运算符，就是将符号右边的值，赋给左边的变量。

  public static void main(String[] args) {
   int i = 5;
   i += 5; // 计算⽅式 i=i+5 变量i先加5，再赋值变量i
   System.out.println(i); // 输出结果是10
  }

  7.3 ⽐较运算符 

•  ⽐较运算符，是两个数据之间进⾏⽐较的运算，运算结果都是布尔值 true 或者 false 。

public static void main(String[] args) {
 System.out.println(1 == 1); // true
 System.out.println(1 < 2); // true
 System.out.println(3 > 4); // false
 System.out.println(3 <= 4); // true
 System.out.println(3 >= 4); // false
 System.out.println(3 != 4); // true
}

 7.4 逻辑运算符

• 逻辑运算符，是⽤来连接两个布尔类型结果的运算符，运算结果都是布尔值 true 或者 false 

7.5 三元运算符

• 三元运算符格式：

数据类型 变量名 = 布尔类型表达式 ? 结果1 : 结果2

• 三元运算符计算⽅式：

1. 布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
2. 布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。

public static void main(String[] args) {
 int i = (1 == 2 ? 100 : 200);
 System.out.println(i); // 200
 int j = (3 <= 4 ? 500 : 600);
 System.out.println(j); // 500
}

8 ⽅法⼊⻔

---

8.1 概述 我们在学习运算符的时候，都为每个运算符单独的创建⼀个新的类和 main ⽅法，我们会发现这样编写代码 ⾮常的繁琐，⽽且 重复的代码过多。能否避免这些重复的代码呢，就需要使⽤⽅法来实现。

• ⽅法：就是将⼀个功能抽取出来，把代码单独定义在⼀个⼤括号内，形成⼀个单独的功能。当我们需要这个功能的时候，就可以去调⽤。这样即实现了代码的复⽤性，也解决了代码冗余的现象。

8.2 ⽅法的定义

• 定义格式：

修饰符 返回值类型 ⽅法名 (参数列表) {
 代码...
 return ;
}

• 定义格式解释：

1. 修饰符：⽬前固定写法 public static 。
2. 返回值类型：⽬前固定写法 void ，其他返回值类型在后⾯的课程讲解。
3. ⽅法名：为我们定义的⽅法起名，满⾜标识符的规范，⽤来调⽤⽅法。
4. 参数列表：⽬前⽆参数， 带有参数的⽅法在后⾯的课程讲解。
5. return：⽅法结束。因为返回值类型是void，⽅法⼤括号内的return可以不写。

•  举例：

public static void methodName() {
 System.out.println("这是⼀个⽅法");
}

8.3 ⽅法的调⽤ ⽅法在定义完毕后，⽅法不会⾃⼰运⾏，必须被调⽤才能执⾏，我们可以在主⽅法 main 中来调⽤我们⾃⼰定义好的⽅法。在主⽅法中，直接写要调⽤的⽅法名字就可以调⽤了。

public static void main(String[] args) {
 //调⽤定义的⽅法method
 method();
}
//定义⽅法，被main⽅法调⽤
public static void method() {
 System.out.println("⾃⼰定义的⽅法，需要被main调⽤运⾏");
}

8.4 调⽤练习 将三元运算符代码抽取到⾃定义的⽅法中，并调⽤。

public static void main(String[] args) {
 //调⽤定义的⽅法operator
 operator();
}
//定义⽅法，⽅法中定义三元运算符
public static void operator() {
 int i = 0;
 i = (1 == 2 ? 100 : 200);
 System.out.println(i);
 int j = 0 ;
 j = (3 <= 4 ? 500 : 600);
 System.out.println(j);
}

8.5 注意事项

• ⽅法定义注意事项：

1. ⽅法必须定义在⼀类中⽅法外
2. ⽅法不能定义在另⼀个⽅法的⾥⾯

public class Demo {
 public static void main(String[] args) {
 //错误写法，⼀个⽅法不能定义在另⼀⽅法内部
 public static void method() {}
 }
}

public class Demo {
 public static void main(String[] args) {
 }
 //正确写法，类中，main⽅法外⾯可以定义⽅法
 public static void method() {}
}

9 JShell脚本⼯具

---

JShell 脚本⼯具是 JDK9 的新特性 什么时候会⽤到 JShell ⼯具呢，当我们编写的代码⾮常少的时候，⽽⼜不愿意编写类， main ⽅法，也不愿意去编译和运⾏，这个时候可以使⽤ JShell ⼯具。 启动 JShell ⼯具，在 DOS 命令⾏直接输⼊ JShell 命令。  接下来可以编写 Java 代码，⽆需写类和⽅法，直接写⽅法中的代码即可，同时⽆需编译和运⾏，直接回⻋即可

⼩贴⼠： JShell ⼯具，只适合⽚段代码的测试，开发更多内容，建议编写在⽅法中。

10 扩展知识点

---

10.1 +=符号的扩展 下⾯的程序有问题吗 ?

public static void main(String[] args) {
 short s = 1;
 s += 1;
 System.out.println(s);
}

分析： s += 1 逻辑上看作是 s = s + 1 计算结果被提升为 int 类型，再向 short 类型赋值时发⽣错误，因 为不能将取值范围⼤的类型赋值到取值范围⼩的类型。但是， s = s + 1 进⾏两次运算 ， += 是⼀个运 算符，只运算⼀次，并带有强制转换的特点，也就是说 s += 1 就是 s = (short) (s + 1) ，因此程序 没有问题编译通过，运⾏结果是 2 。 10.2 字⾯量和变量的运算

下⾯的程序有问题吗?

public static void main(String[] args) {
 byte b1 = 1;
 byte b2 = 2;
 byte b3 = 1 + 2;
 byte b4 = b1 + b2;
 System.out.println(b3);
 System.out.println(b4);
}

分析： b3 = 1 + 2 ， 1 和 2 是字⾯量，为固定不变的数据，在编译的时候 ( 编译器 javac ) ，已经确定了 1+2 的结果并没有超过 byte 类型的取值范围，可以赋值给变量 b3 ，因此 b3 = 1 + 2 是正确的。 反之， b4 = b2 + b3 ， b2 和 b3 是变量，变量的值是可能变化的，在编译的时候，编译器 javac 不确定 b2+b3 的结果是什么，因此会将结果以 int 类型进⾏处理，所以 int 类型不能赋值给 byte 类型，因此编译失 败。 在 jshell 中体现 :