文章目录
前言
第一章“初始 Java”
?1.1 程序的概括及Java语言介绍
?1.2 配置JDK
?1.3 Java程序编写方法
?1.4 Java开发环境介绍
第二章“变量与数据类型”
?2.1 变量 常量
?2.2 数据类型
?2.3 控制台的输入和输出
?2.4 调试
第三章“运算符与表达式”
?3.1 运算符（一）
?3.2 运算符（二）
?3.3 运算符优先级和表达式
?3.4 数据类型转换
第四章“条件结构”
?4.1 条件结构
?4.2 多重条件结构
?4.3 嵌套条件结构
?4.4 switch 结构
第五章“循环结构”
?5.1 while 循环结构
?5.2 深入理解 while 循环
?5.3 do-while循环
?5.4 深入理解 do-while 循环
第六章“循环结构进阶”
?6.1 for 循环
?6.2 深入理解 for 循环（一）
?6.3 深入理解 for 循环（二）
?6.4 跳转语句
第七章“类和对象”
?7.1 理解类和对象
?7.2 Java中的类和对象
?7.3 对象的创建与使用
?7.4 面对对象编程
第八章“方法”
?8.1 方法概括
?8.2 无参数无返回值的方法
?8.3 有参数无返回值的方法
?8.4 成员变量和局部变量
第九章“方法与参数类型”
?9.1 有参数有返回值的方法
?9.2 参数的数据类型
?9.3 深入理解方法
?9.4 方法使用
第十章“数组”
?10.1 数组概括
?10.2 一维数组
?10.3 数组的应用（一）
?10.4 数组的应用（二）
后记
第一章“初始 Java”
顶部
?1.1 程序的概括及Java语言介绍
生活中的程序
程序一词来源于生活，在生活中，我们经常会听到“ 按照程序办事”，此处的“程序”通常指为进行某项活动或
事件所规定的方式和过程。以现实生活中的“ 乘坐火车”为例，乘坐火车的程序如图
计算机程序
程序是为了让计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合。
什么是Java语言
Java语言是美国Sun公司(Stanford University Network)，在1995年推出的高级的编程语言。所谓编程语言,是
计算机的语言,人们可以使用编程语言对计算机下达命令,让计算机完成人们需要的功能。
Java语言发展历史
●1995年Sun公司发布Java1 .0版本
●1997年发布Java 1.1版本
●1998年发布Java 1.2版本
●2000年发布Java 1.3版本
●2002年发布Java 1.4版本
●2004年发布Java 1.5版本
●2006年发布Java 1.6版本
●2009年Oracle甲骨文公司收购Sun公司，并于2011发布Java 1.7版本
●2014年发布Java 1.8版本
●201 7年发布Java 9.0版本
Java语言能做什么
Java语言主要应用在互联网程序的开发领域。常见的互联网程序比如天猫、京东、物流系统、网银系统等，以吸服
务器后台处理大数据的存储、查询、数据挖掘等也有很多应用。
二进制
计算机中的数据不同于人们生活中的数据，人们生活采用十进制数,而计算机中全部采用二进制数表示，它只包含
0、1两个数,逢二进一, 1+1=10。 每- -个0或者每一 一个1, 叫做一 个bit (比特)。
下面了解一下十进制和二二进制数据之间的转换计算。
●十进制数据转成二进制数据:使用除以2获取余数的方式
●二进制数据转成十进制数据:使用8421编码的方式
注:二进制数系统中，每个0或1就是一个位， 叫做bit (比特)。
字节
字节是我们常见的计算机中最小存储单元。计算机存储任何的数据，都是以字节的形式存储,右键点击文件属性,
我们可以查看文件的字节大小。
8个bit (二进制位) 0000-0000表示为1个字节， 写成1 byte或者1 B.
●8bit=1 B
●1024B=1 KB
●1024 KB=1 MB
●1024MB=1 GB
●1024GB= 1 TB
常用DOS命令
Java语言的初学者，学习一些DOS命令,会非常有帮助。DOS是一个早期的操作系统，现在已经被Windows系统取
代，对于我们开发人员，目前需要在DOS中完成一-些事情， 因此就需要掌握一些必要的命令。
● 进入DOS操作窗口
● 按下Windows+R键盘，打开运行窗口，输入cmd回车，进入到DOS的操作窗口。
● 打开DOS命令行后，看到一个路径C:\user就表示我们现在操作的磁盘是c盘。
● 常用命令
?1.2 配置JDK
Java除了是一种编程语言外，它还包含其技术平台，Java技术应用最广泛的平台是Java SE和Java EE。
Java SE
Java SE( Java Platform, Standard Edition )即Java平台标准版，是Java技术的核心,提供基础Java开发工具、执行环境与应用程序接口(API)，其主要用于桌面应用程序的开发，包括常见的安装在本地计算机上的桌面软件
Java EE
Java EE ( Java Platform，Enterprise Edition) 即Java平台企业版，它能帮助人们开发和部署可移植、健壮、可伸缩且安全的服务器端Java应用程序。Java EE是在Java SE的基础上构建的，它提供Web服务、组件模型、管理和通信API,可以用于实现企业级的面向服务体系结构( service - oriented architecture,SOA)和Web 2.0应用程序。Java EE主要用于网络程序和企业级应用的开发
Java的优势
1.安全稳定
2.语法较为简洁
3.未来发展空间大
4.跨平台优势
● JVM Uava Virtual Machine ) : Java虚拟机，简称}VM, 是运行所有Java程序的假想计算机，是Java程序的运行环境，是Java 最具吸引力的特性之-。我们编写的Java代码，都运行在JVM之上。
● 跨平台:任何软件的运行，都必须要运行在操作系统之上,而我们用Java编写的软件可以运行在任何的操作系统上，这个特性称为Java语言的跨平台特性。该特性是由JVM实现的，我们编写的程序运行在JVM.上,而JVM运行在操作系统上。
JRE和JDK
● JRE (Java Runtime Environment) :是Java程序的运行时环境，包含JVM和运行时所需要的核心类库。
● jDK (Java Development Kit): 是Java程序开发工具包，包含JRE和开发人员使用的工具。
我们想要运行一一个已有的Java程序，那么只需安装JRE即可。
我们想要开发一个全新的Java程序, 那么必须安装JDK。
开发Java程序首先要安装JDK (Java Development Kit) ，JDK 是Java语言的软件开发工具包，本书采用JDK8.0的版本，JDK可以在Oracle公司的官方网站上免费下载。
安装JDK后，即可编译和运行Java程序了。在JDK中包含两个主要的工具，第一个是java即Java解释器，第二个是javac即Java编译器。
配置开发环境
JDK安装成功后，还需要配置环境变量才能正常使用，配置过程的步骤如下:
(1 )右键单击“我的电脑”，在弹出的菜单中选择“属性”一 >“高级系统设置”一>“环境变量”
(2)配置PATH属性，如图1.11所示。PATH属性允许系统在任何路径下识别Java命令。
(3)配置CLASSPATH属性，如图1.12所示。CLASSPATH属性用于指定Java加载类的路径。
(4)打开命令行窗体，输入"java -version” 命令，验证配置是否成功。
?1.3 Java程序编写方法
Java程序结构
搭建好Java开发环境后，即可开发Java程序了。在开发Java程序之前，我们先要了解Java程序的基本结构、基本框架
通常，建造房屋要先搭建一个框架，然后才能添砖加瓦，同理，Java 程序也需要搭建自己的结构。一段简单的Java代码，用于输出“欢迎进入Java编程世界!”，其程序结构的组成部分如下:
1.类的结构
其中，HelloWorld为类的名称( 类名称均为英文字母，规范的写法是类名首字母大写)，其必须与程序文件的名称完全相同。类名前面的public和class是两个关键字，他们的先后顺序不能改变，中间要用空格分隔。类名后面要跟-对大括号,所有属于该类的代码都放在大括号内。
2.程序的主方法
在程序结构中，main() 方法是程序的主方法，它是Java程序的入口，Java 程序从main()方法开始执行，没有main()方法，计算机就不知从哪开始执行程序，类似于在火车站乘车时，必须从规定的进站口进入。当然，-个Java项目中，一般只有一个main()方法，而在后续的学习中，每个类中都会有main()方法，由于我们目前处于学习的初级阶段，每个文件都是单独的，而在真正的项目中，只有一个main()方法，它是项目启动的源头。在编写main()方法时，必须按照其格式编写，程序要执行的代码都放在main()方法的大括号内。
每一个程序有且只有一个main()方法。
3.方法内的代码
这一行代码的作用是向控制台输出括号内的内容。本语句输出“ HelloWorld”,即双引号内的文字。使用代码“ System.out. println()”可以实现向控制台输出信息，将输出的信息放入英文的双引号内即可。
如果在输出信息时需要换行,可以在换行处添加“\n”,“\n”为转义字符,程序运行到该字符后不会直接显示该字符,而是将光标移动到下一行的第-格，即换行。另一个比较常用的转义字符为“\t” ，它的作用是将光标移动到下-个水平制表的位置。
Java程序的开发步骤
1.编写源程序
2.编译
3.运行
编译和运行是两回事
编译:是指将我们编写的Java源文件翻译成JVM认识的class文件,在这个过程中， javac 编译器会检查我们
所写的程序是否有错误，有错误就会提示出来,如果没有错误就会编译成功。
运行:是指将class文件交给JVM去运行，此时JVM就会去执行我们编写的程序了。
关于main方法
main方法:称为主方法。写法是固定格式不可以更改。main方法是程序的入口点或起始点，无论我们编写多少程序, JVM在运行的时候，都会从main方法这里开始执行。
关键字keywords
关键字:是指在程序中，Java已经定义好的单词，具有特殊含义。
HelloWorld案例中， 出现的关键字有public.I class.static、[ void 等,这些单词已经被Java定义好，全部都是小写字母，notepad++中颜色特殊。
关键字比较多,不能死记硬背,学到哪里记到哪里即可。
标识符
标识符:是指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等,都是标识符。
HelloWorld案例中， 出现的标识符有类名字Helloworld 。
命名规则:硬性要求
标识符可以包含英文字母26个(区分大小写)、0-9数字、 $ (美元符号)和_ (下划线)。
标识符不能以数字开头。
标识符不能是关键字。
命名规范: 软性建议
类名规范:首字母大写,后面每个单词首字母大写(大驼峰式)。
方法名规范:首字母小写，后面每个单词首字母大写(小驼峰式)。
变量名规范:全部小写。
?1.4 Java开发环境介绍
eclipse最初是由IBM公司开发的替代商业软件Visual Age for Java的下一代集成开发环境(IDE)，2001年11月贡献给开源社区，现在它由非营利软件供应商联盟eclipse基金会( eclipse Foundation)管理。
使用eclipse
打开eclipse后，输入’workspace" 路径，点击“OK"就会打开eclipse
创建Java项目
在eclipse中创建项目时,选择“File"-十"New”一→"Java Project"选项,弹出“New Java Project" 对话框，在“Project name"文本框中输入项目的名称，此处命名单击“Finish" 按钮，就完成了项目的创建
创建并编写Java源程序
在eclipse中，选中并右击之前创建的项目"javaproj1" ，在弹出的快捷菜单中选择“New" >“Class" 选项,弹出"New Java Class"对话框，在“Package"文本框中输入包名(包名就是文件夹的名称，为便于管理代码,通常用不同的包放置不同的java文件)，此处使用"com.mstanford.chapter1” 作为包名，在"Name”"文本框中输入类名,使用“JavaApp”作为类名,勾选。public static void main(String I] args)”的复选框,单击“Finish”按钮，就完成了Java文件的创建
编译Java源程序
这一步不需要手工操作，如果程序没有错误，eclipse 可以实现自动编译;如果有错误，eclipse 会给出相应的错误提示，修改正确后会自动完成编译。
运行Java程序
选中eclipse窗口中“JavaApp.java”类文件，选中“Run” 一→“Run As"一→“Java Application”选项运行该程序，运行结果显示在控制台
Java项目组织结构
在eclipse中Java项目的组织结构如下:
包资源管理器( Package Explorer)
包可以理解为文件夹，在文件系统中，我们会利用文件夹对文件进行分类管理，在Java项目中，使用包来组织和管理Java源文件。在eclipse界面左侧，可以看到包资源管理器视图
导航器( Navigator)
在eclipse中选择"Window" -→ShowView" - “Navigator” 选项，可以打开导航器视图
导航器类似于Windows中的资源管理器，它展示了项目中包含的文件及层次关系。在导航器中，bin 目录下是编译后的字节码文件，src目录下是Java源文件。这些文件都可以在eclipse的工作空间中找到。
第二章“变量与数据类型”
?2.1 变量 常量
常量概括
常量:是指在Java程序中固定不变的数据。
变量概括: .常量是固定不变的数据，那么在程序中可以变化的量称为变量。
变量的使用
在Java中，变量的使用步骤如下:
(1)声明变量:根据所存储的数据类型，为变量申请存储空间。
(2)赋值:将数据存储至变量中。
(3)使用变量:使用变量中的值。
?2.2 数据类型
Java的数据类型分为两大类:
基本数据类型:包括整数、浮点数、字符、布尔。
引用数据类型:包括类(String)、数组，接口(方法)。
四类八种基本数据类型:
1.整数类型
byte、short、 int 以及long均为整数的数据类型，整数用于表示没有小数部分的数值，它允许是负数，它们之间的区别在于取值范围的不同，长整型数值有一个后缀L (如300000000L)。从Java7开始，可以在数字字面上添加下划线，如1. 000 000表示100万，下划线仅便于阅读数据。这些整数类型中最常用的是int 类型。
2.浮点类型
浮点类型表示有小数部分的数值, double 表示的数值精度是float类型的两倍,称为双精度浮点型。在很多情况下，float类型的精度很难满足需求,大多数应用程序中均采用double类型。float类型的数值有一个后缀F(如3.14F),没有F的浮点数值(如3.14)默认为double类型。
3.字符类型
char类型用于表示单个字符，通常表示字符常量，如“A”“爱” ，使用char表示的字符值都必须包含于英文的单引号中。
4.布尔类型
布尔类型( boolean)的变量有两个取值一-true 和false,用于判定逻辑条件的真或假。除了上述的8种基本数据类型外，生活中还有一种运用广泛的数据，如人的姓名和地址等，它们通常由多个字符组成。Java将由多个字符组成的字符序列称为字符串，如“ 我爱你们”“I love you"。字符串类型也称为String类型，其表示的若干个字符序列必须包含于英文双引号内。
变量名称:在同一个大括号范围内,变量的名字不可以相同。
变量赋值:定义的变量,不赋值不能使用。
?2.3 控制台的输入和输出
控制台的输入
控制台输入的方法有多种，常用的一种是使用Scanner。在Java学习的前期，我们只需要先掌握它怎么使用，在后期学习了面向对象和流的概念后会对它有更深入的认识。Scanner 的使用步骤如下:
1.Scanner类的导入
在使用Scanner获取用户输入的数据前，需要先导入Scanner类，代码如下:
import java.util. Scanner;//该代码必须放在package代码和类定义的代码中间
2.Scanner对象的创建，代码如下:
Scanner sc = new Scanner(System.in);
3.获取用户输入的数据，代码如下:
int age = sc.nextInt0);//获取用户输入的数字后赋值给变量age
4.对获取到的用户数据进行处理
Scanner的常用方法
next()获取用户输入的字符串
nextInt()获取用户输入的整型数据
nextDouble()获取用户输入的Double类型数据
nextBoolean()获取用户输入的布尔类型数据
nextShort()获取用户输入的短整型数据
nextFloat() 获取用户输入的Float类型数据
next0.charAt(0)获取用户输入的字符串的第一个字符
控 制台的输出
讲解了如何使用System.out. print()方法或System.out.println () 方法将文本信息向控制台输出。通过对变量的学习，我们知道程序中的临时数据都存储于变量之中，那么如何将变量中存储的数据输出至控制台呢?在Java中提供了两种方式可以将变量的值输出至控制台。
(1)使用print()或printIn()方法，直接输出变量的值。代码如下:
System. out. printIn(score);
可以在变量前附加文字说明，然后使用连接字符串符号“+” 将文字说明字符串和变量的值连接起来。如果是两个数字之间的“+”，“+” 代表加法运算;但是如果有字符串文本参与“+” 运算，则起连接作用。代码如下:
System. out. printIn(“学生的成绩是:”+score);
(2)使用printf()方法，格式化输出。使用print或printIn输出数据时无法控制输出数据的精度，在Java中可以通过printf()方法控制数据输出的精度。例如:.
doubl pi = 3.1415926;
System. out. printf(" %8.2f",pi);
输出为: 3.14
上述代码表示变量pi可以输出8个字符的宽度和小数点后两位的精度，即打印出4个空格和4个字符。
在printf中，前面的字符串内可以包含多个格式控制符，后面是格式控制符对应的变量，语法为:
System.out.printf(“格式控制符1格式控制符2...”,变量1,变量--);
?2.4 调试
eclipse 调试工具的使用
使用eclipse调试解决程序问题的常规思路和步骤如下:
==1.分析可能出错的位置,设置断点
断点即程序运行到此处就暂停运行的某行语句。想找到程序运行到某处时变量的值是什么，可在该行设置一个断点，程序运行到此就会暂停下来。此时不仅可以在eclipse的变量视图中看到变量的值,还可以使用单步运行的功能逐步运行程序。
设置断点的方法很简单，在想设置断点的代码行左侧边栏处双击，双击后就出现一个圆形的断点标记即为设置成功，再次双击，即可取消断点。
2.启动调试，单步执行
成功设置断点后，打开调视图(Window> Show View > debug) ，单击枪▼按钮，即可启动调试，当用户输入完要减少的年龄后，程序会自动在设置断点的地方停下来
3.观察变量取值
第三章“运算符与表达式”
?3.1 运算符（一）
运算符的目
运算符能连接操作数的个数，称为运算符的目。Java 语言中运算符的目有三种:
(1)单目运算符:只能连接一个操作数，如“++”“–”等。
(2)双目运算符:可以连接两个操作数, Java语言中的多数运算符属于双目运算符
如“+”“-”“*”“1”等。
(3)三目运算符:可以连接三个操作数。Java语言中只有一个三目运算符，即条件运算符。
运算符的优先级
优先级是指在一个表达式中出现多个不同运算符，在进行计算时运算符执行的先后次序。例如，算术运算符中的.乘除运算符的优先级高于加减运算符的优先级，在Java语言中，运算符都存在自身的优先级，应遵循优先级高的运算符先处理的规则。
运算符的结合方向.
结合方向又称为结合性，是指当-个操作数连接两个同一优先级的运算符时，按运算符的结合性所规定的结合方向处理。Java 语言中各运算符的结合性分为两种，分别为左结合性(自左向右)和右结合性(自右向左)。
赋值运算符
在Java语言中，赋值运算符为“=”,赋值运算用于将赋值运算符右侧表达式的结果赋予赋值运算符左侧的变量
算术运算符
■ ++运算,变量自己增长1。反之, --运算,变量自己减少1,用法与++ - -致
独立运算:
变量在独立运算时，前++ 和后++没有区别。
■ 变量前++ :例如++i
■ 变量后++ :例如i++
混合运算:
和其他变量放在一起，前++和后++就产生了不同。
变量前++:变量a自己加1,将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2 。
变量后++:变量a先把自己的值1,赋值给变量b,此时变量b的值就是1,变量a自己再加1。a的结果是2, b的结果是1。
符号在字符串中的操作:
+符号在遇到字符串的时候，表示连接、拼接的含义。
“a”+“b"的结果是"ab”, 连接含义
复合运算符
Java中有些表达式可以通过复合运算符进行简化
?3.2 运算符（二）
关系运算符
关系运算符，是两个数据之间进行比较的运算,运算结果都是布尔值true或者false
逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值
true或者false
三元运算符格式:
数据类型变量名=布尔类型表达式?结果1:结果2
三元运算符计算方式: .
。布尔类型表达式结果是true,三元运算符整体结果为结果1,赋值给变量。
。布尔类型表达式结果是false,三元运算符整体结果为结果2,赋值给变量。
?3.3 运算符优先级和表达式
表达式
表达式是指由操作数和运算符组成的用于完成某种运算功能的语句
其中Y、X、Z、10称为操作数，=、*、+称为运算符。
操作数通常可以是常量、变量或表达式，而运算符则指可以完成某种运算功能的符号。
表达式是运算符与操作数的组合，其中操作数可以是常量、变量或其他表达式
操作数和运算符进行合理组合，可以组成非常复杂的表达式。表达式在计算时有一些规则，在混合运算中，将优先计算的表达式放在括号“()” 中。
运算符优先级
?3.4 数据类型转换
自动转换
一个int类型变量和一个byte类型变量进行加法运算，结果会是什么数据类型?
运算结果，变量的类型将是int类型,这就是出现了数据类型的自动类型转换现象。
●1自动转换:将取值范围小的类型自动提升为取值范围大的类型。
转换原理图解
byte类型内存占有1个字节，在和int类型运算时会提升为int类型，自动补充3个字节，因此计算后的结果还是int类
同样道理，当一个int类型变量和一个double变量运算时，int 类型将会自动提升为double类型进行运算。
转换规则
范围小的类型向范围大的类型提升， byte、 short、char运算时直接提升为int。
强制转换
将1.5 赋值到int类型变量会发生什么?产生编译失败，肯定无法赋值。
double 类型内存8个字节， int 类型内存4个字节。 1.5 是double 类型，取值范围大于int。可以理解为double 是8
升的水壶，int 是4升的水壶,不能把大水壶中的水直接放进小水壶去。
想要赋值成功，只有通过强制类型转换，将double类型强制转换成int类型才能赋值。
●强制类型转换:将取值范围大的类型强制转换成取值范围小的类型。
比较而言，自动转换是]ava自动执行的，而强制转换需要我们自己手动执行。
转换格式:
将1.5赋值到int类型，代码修改为:
同样道理，当-个short 类型与1相加，我们知道会类型提升,但是还想给结果赋值给short类型变
量，就需要强制转换。
●浮点转成整数,直接取消小数点，可能造成数据损失精度。
●int强制转成short砍掉2个字节，可能造成数据丢失。
ASCII编码表
●编码表:就是将人类的文字和一个十进制数进行对应起来组成一张表格。
将所有的英文字母，数字,符号都和十进制进行了对应,因此产生了世界上第一张编码表ASCII (American Standard Code for Information Interchange美国标准信息交换码)。
+=符号的扩展
分析: s += 1逻辑上看作是s = s + 1计算结果被提升为int类型,再向short类型赋值时发生错误，因为不能将取值范围大的类型赋值到取值范围小的类型。但是，s=s+1进行两次运算， += 是-个运算符,只运算-次, 并带有强制转换的特点,也就是说s += 1就是s = (short)(s + 1)]，因此程序没有问题编译通过，运行结果是2.
常量和变量的运算
分析: b3 = 1 + 2，1和2是常量,为固定不变的数据，在编译的时候(编译器javac)， 已经确定了1+2的结果并没有超过byte类型的取值范围，可以赋值给变量b3],因此b3=1 + 2是正确的。
反之, b4 = b2 + b3，b2 和b3是变量,变量的值是可能变化的，在编译的时候，编译器javac不确定b2+b3的结果是什么,因此会将结果以int类型进行处理，所以int类型不能赋值给byte类型，因此编译失败。
方法入门
概念：
我们在学习运算符的时候，都为每个运算符单独的创建-个新的类和main方法,我们会发现这样编写代码非常的繁琐，而且重复的代码过多。能否避免这些重复的代码呢，就需要使用方法来实现。
●方法:就是将一一个功能抽取出来,把代码单独定义在一个大括号内, 形成-个单独的功能。
当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性,也解决了代码冗余的现象。
方法的定义
定义格式：
●定义格式解释:
修饰符:目前固定写法public static。
返回值类型:目前固定写法void,其他返回值类型在后面的课程讲解。
方法名:为我们定义的方法起名，满足标识符的规范,用来调用方法。
参数列表:目前无参数， 带有参数的方法在后面的课程讲解。
return: 方法结束。因为返回值类型是void,方法大括号内的return可以不写。
方法的调用
方法在定义完毕后，方法不会自己运行，必须被调用才能执行，我们可以在主方法main中来调用我们自己定义好的方法。在主方法中，直接写要调用的方法名字就可以调用了。
●方法定义注意事项:
方法必须定义在一类中方法外
方法不能定义在另一个方法的里面
第四章“条件结构”
?4.1 条件结构
Java程序的结构有3种，分别是顺序结构、选择结构和循环结构。
1.顺序结构
顺序结构是一组按照书写顺序执行的语句结构，这种语句结构的执行流程是按顺序地从一个处理过程转向下一个处理过程。
2.选择结构
选择结构又称为分支结构。当程序执行到分支判断的语句时，首先判断条件，然后根据条件表达式的结果选择相应的语句执行。分支结构包括单分支、双分支和多分支3种形式。
3.循环结构
在程序设计中，对重复执行的语句采用循环结构处理。当程序执行到循环控制语句时，根据循环判定条件的结果决定重复执行多少次循环体操作。循环结构分为先判断后执行结构和先执行后判断结构2种形式。从程序执行过程的角度而言，顺序、选择及循环3种结构可以组合或嵌套来实现复杂多样的程序流程。
单分支if结构
if条件语句是根据条件判断之后再做处理的一种语法结构,我们首先学习简单的if条件语句,也称为单分支if语句，其语法如下:
判断语 if..else
?4.2 多重条件结构
多重条件结构
当一个问题存在多种可能的条件时，需要针对每一种条件分别进行处理。
多重if结构
通过单分支if语句和双分支if-else语句能够解决程序有两条选择执行流程的问题，如果要解决多条分支情况的问题，并针对每种分支情况有不同的操作，执行不同的语句，遇到此类问题时，我们需要采用多分支选择结构，多重if语句能实现多分支选择结构，其使用的语法如下。
字符类型判断的比较规则
?4.3 嵌套条件结构
嵌套if结构
嵌套if结构是指在条件结构的语句中包含另一个条件结构。
语法：
在嵌套的条件结构中，只有在外层条件成立的情况下，才会执行内层的条件语句，如上述代码结构中，条件表达式1成立才会执行条件表达式2,否则执行条件表达式3，逐层成立，逐层执行。
根据上述形式，编写一个思路(伪代码，仅为思路的提示过程)对应刚才的运动会需求描述。代码如下:
运行结果
?4.4 switch 结构
switch-case结构
switch语句又称为多路分支条件语句，用于处理多重条件的选择结构。使用switch语句实现多分支选择结构,可以简化程序的结构。特别是在处理等值判断问题时，使用switch更加方便。switch 语句的语法如下:
(1) switch表示“开关”，此开关就是switch关键字后面小括号中表达式的值，小括号内表达式值的类型只能是char、整数或String。
(2) case表示“情况”，case后必须是一个char、 整数或String类型的常量表达式，如“8”、“a”、"jack”。case块可以有多个，顺序可以改变，但是每个case后的常量值不能相同。
(3) default表示“ 默认”，即表达式的值与任何一个case之后常量表达式的值均不匹配时，执行default语句。default块可以省略，并且它与case的顺序也可以调整，通常default放在switch语句的最后。
(4) break表示“停止”，即跳出当前switch语句，不再继续执行switch语句中的剩余部分。switch语句的执行流程，如图所示。
switch语句的执行流程为:先计算switch后面小括号中表达式的值，然后将计算的结果顺序与每个case后的常量进行比较。当遇到两者相等的情况时，执行该case块中的语句，遇到break时则跳出switch结构，执行switch结构之后的语句。如果没有任何一个case后的常量与小括号中的值相等，则执行default 块中的语句。
switch-case结构的使用
了解了switch语句的语法结构及其执行过程后，可以使用switch语句解决等值判断的问题。以判断成绩的名次，输出相应的奖励为例，具体代码见示例。
运行效果
在使用switch语句时，特殊情况如下:
(1)在case语句块中省略break后，程序会继续向下执行，不会再进行等值判断，直到遇到break语句才跳出，否则-直执行switch语句到最后一-行。省略break后的代码的情况。
（2)多个case块可以执行同一个语句
第五章“循环结构”
?5.1 while 循环结构
循环简介
在编程时,通常会遇到要进行重复执行的问题。
while循环
在Java中，循环是指重复的操作或需要重复执行的代码。
任何循环都需要有循环开始或结束的条件，如果循环无休止地进行，则称之为死循环。一个完整的循环结构必须满足以下特征:
(1 )循环有开始或结束的条件。
(2)需要重复执行的操作或代码，称为循环操作或循环体。
Java中while循环是-种非常常见的循环结构，它是一种先判断然后再执行循环体的结构，语法如下:
在某些循环操作中，表达式和循环条件存在一定的关系，如计算1~ 100之间的整数和。分析步骤如下:
(1)循环初始条件为:“int count= 1;”。
(2)执行循环操作的条件为: “count<=100”。
(3)循环操作为:“sum = sum +count;”。
(4)改变循环条件中的变量:“count++;”
其中，循环操作中的表达式会累加count,每次加入count变量都会与条件- -同变化， 从1~100,当超过100时
循环结束。
语法
运行结果
?5.2 深入理解 while 循环
使用while语句循环接收用户输入
编写Java程序，根据输入的某个班级的学员成绩，计算该班级学员的平均成绩，要求输入班级的人数。
(1)声明变量sum、count
以及avg用于存储总成绩、班级人数以及平均成绩。
(2)通过Scanner接收用户输入的班级人数，并为变量count赋值。.
(3)根据平均值计算规则，需要计算总成绩，使用while循环结构实现总成绩的计算。
定义循环变量i，实现指定次数的循环(循环次数为班级人数)，通过分析可得:
在控制台中输入用户年龄，直到输入的数字为正确的年龄为止。
通过分析可得:
循环条件:年龄数据如果不在正确的范围内，即为小于0岁或大于130岁。
循环操作:给用户错误提示，重新输入年龄。
使用while循环结构实现时，由于while循环先判断循环条件，之后再执行循环体，因此，需要将第一次用户输
入的年龄放在while循环之外。具体实现思路如下:
 **?5.3 do-while循环**```
do-while 循环语法结构
与while循环不同，do-while 循环是先执行循环操作，再判断循环条件的结构，即使循环条件不成立，循环体
也至少执行一次。语法如下:
do-while 循环先执行一次循环操作，然后判断循环条件是否为真，若为真,则继续执行循环操作;若为假，则退出循环，继续执行循环外的语句。
do-while 循环的使用
问题描述:使用do-while循环实现，计算1~100之间所有自然数之和。
已对该问题进行过分析，自然数累加求和操作的过程，可以视为一个循环，由于需要从1累加至100，因此需要循环100次。定义变量sum，用于存储自然数的累加值，设置初始值为0，定义变量count作为循环控制变量，设置初始值为1。
通过分析可得:
while循环与do-while的区别
while循环与do-while循环在语法、执行过程以及使用场合等相互之间存在一定区别。
!\[在这里插入图片描述\](https://i-blog.csdnimg.cn/blog\_migrate/9b2b9d4535c82ddcdef7e5eaaa66e995.png) \*\*?5.4 深入理解 do-while 循环\*\*```
使用do-while循环模拟ATM机菜单选项
问题描述:在控制台中模拟ATM机菜单项的选择。
从图看出，用户需要多次选择不同菜单项，直到选择“退出”选项为止，可使用循环结构实现，而在用户选择菜单项的过程中，需要先显示菜单项列表，再由用户进行选择，最后判断是否退出，根据此业务流程，选择使用do-while循环实现更加适合。
通过分析可得:
循环条件:用户选择的菜单项不是“退出”。.
循环操作:显示菜单项列表，根据用户选择的菜单项，显示对应信息。
选择语句switch
switch语句格式:
case的穿透性
在switch语句中，如果case的后面不写break,将出现穿透现象,也就是不会在判断下一个case的值，直接向后运行,直到遇到break,或者整体switch结束。
上述程序中，执行case5后, 由于没有break语句，程序会-直向后走， 不会在判断case,也不会理会break,直接
运行完整体switch.
由于case存在穿透性，因此初学者在编写switch语句时，必须要写上break。
使用do-while循环计算输入的位数之和
(1)声明变量rdmNum， 并赋值为1 ~ 100之间的随机数字，产生随机数的代码如下:
因为next(100)的随机数范围是0到99,所以在此基础上再加1成为1到100。
(2)声明变量guess,存储用户输入的数字。
(3)由于猜数字游戏需要进行多次，直到猜中为止，可以使用循环实现。
根据猜数字游戏的规则，通过分析可得:
循环条件:输入的数字不等于随机数。
循环操作:接收用户输入的数字，比较输入数字和随机数的关系，并输出对应信息。
第六章“循环结构进阶”
?6.1 for 循环
for循环的简介
在使用while循环时，我们输出100次“好好学习，天天向上”，代码如下:
从上述代码中，可以发现循环次数“100” 已经固定，该次数由以下3个要素确定:
(1)初始部分:inti= 0。
(2)循环条件:i < 100。
(3)迭代部分:i++。
通过以上3要素，可以确定一个循环的次数，如果在循环次数已知的情况下，使用for循环语句能够使循环结构
更加简洁清晰。修改上述代码，使用for循环实现，代码如下:
使用eclipse运行这两种实现方式，发现其结果一致，但是使用for循环实现更为简洁。
在for循环中，循环初始部分、循环条件和循环迭代部分都在for循环语句中，结构清晰明了，在Java中for循
环使用广泛，特别适用于循环次数已知的情况。
for循环语句格式:
for循环的使用
使用for循环实现求1~100的和
for循环的执行结果如下:
(1)先初始化变量i (inti= 1)。
(2)然后判断循环条件(i<=100)。
(3)如果条件为true ,则执行循环体进行累加求和( sum += i), 然后继续执行迭代部分,改变循环变量的值(i++),
然后继续判断表达式2，这样就在判断、循环体与迭代部分之间形成循环，直至判断表达式2的值为false。
(4)如果循环条件为false,则循环体不执行，直接退出循环结构，不会执行循环体操作和迭代部分。
编写Java程序，输入一个学生姓名和5门课程成绩，求其总成绩
for循环的表达式
在使用for循环时，表达式1和表达式3都可以出现多个表达式，多个表达式之间使用逗号隔开
表达式1同时对变量i和j赋初值，表达式3同时改变i和j的值，在循环结构中可以存在多个循
环控制变量。在多个表达式之间的逗号用于分隔表达式，分隔表达式运算的顺序为从左至右。
在使用for循环时，表达式1、表达式2及表达式3均可省略，但“;”不能省略，下面我们分析一下省略表达式的情况。
编写Java程序，输入一个学生的5门课程的成绩，求其平均分。计算平均成绩，需要将每一门课程的成绩逐步累加到总成绩中，使用for循环实现，然后求出平均分。
(1)声明变量sum、score、avg和name,用于存储总成绩、单科成绩、平均分和学生姓名。
(2)通过Scanner接收用户输入的姓名，并为变量name赋值。
(3)根据总成绩计算规则，需要循环多次接收学生成绩以及累加学生成绩，使用for循环结构实现。
①表达式。需要接收5门课程成绩，因此，循环次数为5次，声明变量i作为循环控制变量，根据运行效果，建议将i的初始值设置为1,所以可将for循环中3个表达式设置为:
②循环操作。接收学生的单科成绩，将单科成绩累加至变量sum中。
(4)将总成绩除以科目数量就得到平均分。
(5)使用System.out.printf()实现格式化输出运算结果。
?6.2 深入理解 for 循环（一）
for循环案例(一)
问题描述:在控制台中输入-个自然数，判断该数字是否为完全数。完全数，又称完美数，是指能整除该数字的所有数字(除本身外)之和等于本身的数字。例如，6能够被1、2、3整除，而1、2、3之和与6相等，所以6为完全数。
1.表达式
声明变量num用于存储用户输入的数字，查找能够整除num的数字，需从1开始直到num-1为止，因此，声明变量i作为循环控制变量，for循环结构中的3个表达式如下:
2.循环操作
重复执行的操作是逐一判断1、2、3、… num-1,能否被num整除，若能够被整除，则将对应数字进行累加。因此，声明变量sum,用于存储累加值,设置初始值为0,由于需要从1开始进行判断,而i的初始值也为1,此时，只需将i反复与num进行整除判断即可，将能整除num的i累加至sum中。
使用for循环求“水仙花数”
问题描述:在控制台中输出100~999之间所有的“水仙花数”。水仙花数是指各位数字的3次幂之和等于本身的数字。例如:数字153，个位数字3次幂为27,十位数字3次幂为125,百位数字3次幂为1，而1、27、125之和与153相等，所以153为水仙花数。
1.表达式
查找水仙花数的区间是100~999，因此，声明变量i作为循环控制变量，for 循环结构中的3个表达式如下:
2.循环操作
重复执行的操作是逐一判断100999之间所有数字是否为水仙花数，而i的值区间也是100999，因此，每次循环只需判断i是否为水仙花数，通过运算符“1” 和“%”对各位进行分离，结合if条件根据水仙花数判断规则进行判断即可。
编写Java程序，在控制台中输入日期，计算该日期是对应年份的第几天。
(1)声明变量year、 month和date, 用于存储日期中的年、月、日。
(2)声明变量days,用于存储累加的天数。
(3)通过Scanner接收用户输入的日期，并为变量year、month 和date赋值。
(4)输入日期是当前输入年份的第几天的计算，包括两个部分天数的计算:①输入月份之前的所有月份天数的累加;②输入月份中已过天数累加。例如，输入日期: 2020年5月7日。先计算2020年1月至4月所有的天数, .2020年1月对应的天数31天，2月( 2020年为闰年)对应的天数29天，3月对应的天数31天，4月对应的天数30天，此时，不能包含5月的天数，2020年1月至4月所有的天数累加为121天，之后继续累加5月已过的天数7,最终结果为2020年5月7日为当前年份的128天。
(5)根据天数累加计算规则，需要循环多次依次累加所输入月份之前的每个月份的天数,使用for循环结构实现。
①表达式。需要累加month之前的月份,声明变量i作为循环控制变量,根据运行效果,建议将i的初始值设置为1,所以可将for循环中3个表达式设置为:
②循环操作。使用switch结构，计算i对应月份的天数并进行累加，当i为2时,需要进行闰年判断。
(6)使用上一步计算的结果，继续累加输入月份已过的天数。
(7)使用System. out. printf实现格式化输出运算结果。
 **?6.3 深入理解 for 循环（二）**```
三种循环的区别
while、do-while 和for三种循环语句形式各不相同，相互之间有一定的区别，但三者主要都是由循环条件和循环体构成。
(1) while和do-while循环通常用于循环次数未知的场合，for循环通常用于循环次数已知的场合。
(2)使用while循环和do-while循环时，循环控制变量的初始化通常在while循环和do- while循环之前完成,而for循环则在语法结构的表达式1中完成。
(3)使用while循环和do-while循环时，循环条件通常出现在while关键字之后的表达式中。在循环体中，除了包含重复执行的操作外，还必须存在能够改变循环条件结果的语句，而在for循环中循环条件通常出现在语法结构的表达式2中。语法结构的表达式3用于修改循环控制变量的值，从而改变循环条件的结果，在循环体中仅包含重复执行的操作，语法更加简洁。
(4) While循环和for循环是先判断后执行的循环结构。若循环条件一开始就不成立，则循环体-次也不执行，即循环次数可能为零次或多次，do-while循环是先执行后判断的循环结构，无论循环条件是否成立，循环体至少执行一次，即循环次数可能为一次或多次。
(5) for 循环功能更为强大，能够使用while和do-while实现的循环，几乎都可以使用for循环替换。对于同一个问题，既可以使用while循环和do-while循环实现，也可以使用for循环实现，三种循环之间可以相互转换。但在实际运用过程中，则需要根据具体的情况选择不同的循环结构实现。选择原则如下:
①循环次数已知的循环问题，通常使用for循环实现;循环次数未知的循环问题，通常使用while循环和do-while循环实现。
②在循环执行的过程中，若是先判断循环条件，再执行循环操作，则通常使用while循环和for循环实现;若是先执行循环操作，再判断循环条件，则使用do-while循环实现。
各种循环的使用场景
当遇到需要多次重复执行一个或多个任务的问题而考虑用循环来解决时,选择哪种循环比较适合呢? -般情况下，for循环使用频率最多,对于for循环一定要分析出需要解决业务的三个部分，分别是循环变量初始状态、循环条件和循环变量的改变。
1.while语句场景
如果业务可以转换为“当”这样的句式时,优先选择while语句来实现。例如:年存款利率为3% ,本金为10000元，当存款总额超过12000元时，收益具体是多少?
代码
执行结果
- do-while语句场景
如果业务可以转换为“直到"这样的句式时，优先选择do-while语句来实现。
代码
执行结果
for语句场景
如果业务中可以获取到一个确切的循环次数，可以考虑用for循环，筒而言之就是如果明确知道要重复几次做同样的事情，则使用for循环。例如: 1~100 的和、录入3名学生成绩等。
编写Java程序，在控制台输入数字n,计算表达式1-2+3-…+(2xn- 1)+2xn的结果
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?6.4 跳转语句**
循环在执行过程中，只有在循环条件不成立的情况下，才可以退出循环的执行。例如，沿着运动场跑5圈，可以将该过程视为一个循环，只有在跑完5圈之后才可以终止循环。但在实际情况中，由于个人的身体素质等问题,会出现未完成任务的情况，就需要终止循环。在程序执行过程中同样如此，有时需要根据需求终止循环或进入下一次循环，有时需要从程序的一个部分跳转至程序的其他部分，此时，可以使用跳转语句来实现。Java 语言支持三种形式的跳转语句: break 语句、continue 语句和return语句。而在循环结构中常用的是break语句和
continue语句。
break语句
break语句作为中断处理语句，只能用在while语句、do-while语句、for 语句以及switch结构中，用于中断当前结构的执行，通常和条件语句一同使用。当满足. -定条件时，break语句使程序立即退出当前语句结构，转而执行该语句结构之后的语句。
在Java语言中，switch结构的每-个case项都需要使用break语句来结束，当程序执行到break语句时，退出当前所在的switch结构。break 语句也可在循环结构中使用，用于跳出循环，即提前结束循环。
编写Java程序，输入一个区间，找出区间中第一个能够被3整除的数字。
代码：
运行效果：
continue语句
continue语句只能用于循环语句中，通常和条件语句一同使用，当满足一定条件时，终止本次循环，跳转至下一次循环。
(1)在while循环和do-while循环中，continue 语句使程序跳转至循环条件。
(2)在for循环中，continue语句使程序跳转至表达式3,改变循环控制变量的值后再进行表达式2的判断。编写Java程序，累加1~99的数字之和，要求跳过各位中含有3的数字
代码：
运行效果：
编写Java程序，输出1 ~ 100之间能够同时被3和4整除的最大的五个数字。
(1)声明变量count,用于存储满足条件的数据个数，设置初始值为0。
(2)在区间1~ 100中查找满足条件的数据，需要对每个数字进行逐-判断，可使用循环结构实现。
①表达式。由于需要找到满足条件的最大五个数字，因此，查找过程应从大到小进行数据的查找，声明变量i作
为循环控制变量，for循环结构中的3个表达式如下:
②循环操作。重复执行的操作是从100、99、98、… 1进行逐一判断，需要从100开始判断，而循环控制变量i的值也是从100开始，因此，每次循环过程只需要判断i中的值是否满足条件即可，如果不满足条件，则使用continue语句进行下一个数字的判断，如果满足条件，则输出i的值并对变量count的值进行加一，当count的值达到5时，则意味着已打印5个满足条件的数据，此时，使用break语句跳出循环，不再继续向下查找。
代码：
运行效果：
死循环
●死循环:也就是循环中的条件永远为true,死循环的是永不结束的循环。例如: while(true)}.
在后期的开发中，会出现使用死循环的场景，例如:我们需要读取用户输入的输入,但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了,就可以结束循环了，如何去结束一 个死循环呢，**就需要使用到跳出语句了。**
嵌套循环
●所谓嵌套循环，是指一一个循环的循环体是另一个循环。 比如for循环里面还有一 个for循环， 就是嵌套循环。**总共的循环次数=外循环次数\*内循环次数**
●嵌套循环执行流程:
。执行顺序:①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
。外循环- -次，内循环多次。
。比如跳绳: -共跳5组,每组跳10个。5组就是外循环，10个就是内循环。
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**第七章“类和对象”**
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?7.1 理解类和对象**
对象
现实世界中的所有事物都可以视为对象，如学校中的一辆自行车、-辆汽车、一本书、一个人、拍打中的篮球等;即现实世界中切实的、可触及的实体都可以视为对象。对象在生活中随处可见，小到一-粒沙子，大到一栋大厦，可以说，世界就是由一个个具体的对象所组成。在面向对象编程的思想中，万物皆对象。
Java是一门面向对象的编程语言，要学会用面向对象的思想思考问题，面向对象( Object-Oriented，OO)思想的核心就是对象( Object)。对象表示现实世界中的实体，因此，面向对象编程( OOP)能够很好地模拟现实世界，符合人们思考问题的方式，能更好地解决现实世界中的问题。下文将分析身边的对象，如图所示。
图中显示了2个对象，学生马小云和老师艾承旭。通常，每一个对象都有自己的特征，例如:
学生马小云的特征是:“姓名: 马小云，年龄: 18岁，年级:大一，体重: 56kg”。
老师艾承旭的特征是:“姓名: 艾承旭，年龄: 28岁，职业:老师，体重: 60kg”。
在面向对象编程中将对象具有的特征称为属性，通常情况下，不同对象具有不同的属性或属性值。
对象还能执行某些操作或具备某些行为能力。例如，马小云能执行的操作有:听课、看书和做作业。艾承旭能执行的操作有:讲课、编写程序和批阅作业。
对象能够执行的操作或具备的行为能力称为方法，如马小云有听课、看书、做作业的方法。
**每一个对象都具有自己的属性和方法，属性是指该对象的特征，方法是指该对象的行为或操作。例如，路边睡觉的一条小狗，其属性有:品种、颜色、年龄等;方法有:叫、吃、跑等。不同的对象-般具有不同的属性或属性值。**
抽象与类
通过上面的介绍，我们了解到每一个具体事物就是对象，在众多具有相同属性和方法的对象中，可以提取事物的共性，进而分门别类。例如，前面提到的学生马小云是一个对象，在教室中还有像马小云一样的同学,如张三、李四、王五等，通常将与马小云具有同样属性和方法的对象统称为学生。**提取事物的共性，进行模板设计的过程就是从对象抽象到类的过程,抽象即从具体事物中提取共性的过程,将抽象出来的属性和行为组织在一个单元中,我们就将它称为类。**
多个对象所拥有的共同特性就称为类的属性。例如，每个学生都有姓名、年龄、体重等共同特征，这些就是学生类的属性。但是每一个对象的属性值又各不相同，如张三和李四的体重值不同。对象具有的行为或能执行的操作称为类的方法，如学生都具有看书、学习的方法。通过分析对象，进行抽象思考提取出类，再以类为设计模板去创造更多的对象，这是思维进化的过程。如同在生.产汽车前，首先会设计汽车模型，确定好汽车相关的属性与功能，
如图所示，然后通过设计出的汽车模型生产一辆辆具体的汽车，人们在生产产品前都会经过一个抽象分析、详细设计再到制造的过程。同理，设计出类的目的，就是要通过类去创造一个个具体的对象，类可以视为对象的模板，其作用是创建对象。
类与对象的关系
了解类和对象的概念后，可以发现它们之间既有区别又有联系。简而言之，类是一个抽象的概念模型，而对象是具体的事物。
从类的来源进行分析，类是具有相同属性和共同方法的所有对象的统称，对象就是类的一个实例。
**类与对象的关系如下:类是抽象的，对象是具体的;类是对象的模板,对象是类创建出的一个实例。在现实世界、大脑中的概念世界和程序运行的计算机世界中，类和对象的关系如图所示。**
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?7.2 Java中的类和对象**
**Java是面向对象的编程语言，可以使用Java语言定义类。在Java语言中，类是程序的基本单元，所有的程序都以类为组织单元，类中主要包含属性和方法。**
类的定义
(1)访问修饰符是对类的访问范围的一种限定，本课程均使用public修饰符，表示公有。
(2) class 为定义类的关键字。
(3)类名也是Java中的标识符，必须满足标识符的命名规则;类名的命名规范中，要求类名首字母要大写，且类名简洁并富有含义。
类的成员
类中的主要成员为属性和方法。
1.属性
属性用于表示类的特征，它是类的成员的一部分，在Java类的主体中定义变量，描述类所具有的特征(属性) ,这些变量称为类的成员变量。
例子：
2.方法.
通过在类中定义方法，描述类所具有的行为，这些方法称为类的成员方法。
定义方法的语法如下:
语法说明:
(1)访问修饰符用于限制方法被访问的范围，本课程使用public修饰，表示公有的方法，可以在任何地方使用。
(2)返回值类型是方法执行完成后需要返回结果的类型，如果没有返回值，则使用void表示。
(3)方法名的命名规则使用Java标识名的命名规则，通常使用有意义的名称来描述方法的作用，命名规范一般采用camel (骆驼)命名法。
(4)方法体为方法执行的代码，如果方法返回类型void, 则在方法体中一定要返回和方法类型声明一致的值,返回结果的语法是“return 值;”。
定义管理员类(Admin)，管理员类中的属性包括:姓名、账号、密码、电话;方法包括:登录、显示自己的信息。
(1)分析类的属性及其变量类型。.
(2)分析类的方法及其功能。
(3)使用定义类的语法定义管理员类。.
定义英雄类(Hero)，英雄类中的属性包括:姓名、攻击力、防御力、生命值和魔法值;方法包括:攻击、介绍。
(1)分析类的属性及其变量类型。
(2)分析类的方法及其功能。
(3)使用定义类的语法定义英雄类。
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?7.3 对象的创建与使用**
对象的创建
定义好Engineer类后，下面即可根据定义的模板创建对象。类的作用就是创建对象，由类生成对象,称为类的实例化过程。一个实例也就是一个对象，一个类可以生成多个对象。创建对象的语法如下
在创建类的对象时，需要使用Java的new关键字。例如:创建Engineer类的两个对象。
engineer1和engineer2这2个对象的类型就是Engineer类型。使用new创建对象时，并未对其数据成员进行赋值。考虑到每个对象的属性值可能是不一样的，所以要在创建对象后，再对其数据成员进行赋值。
对象的使用
在Java中，要引用对象的属性和方法，需要使用“.” 操作符。其中，对象名在圆点的左侧，属性或方法的名称在圆点的右侧。
语法：
对象名。属性//引用对象的属性
对象名。方法名0 // 引用对象的方法
例如，创建Engineer类的对象后，即可为对象的属性赋值或调用方法，代码如下:
engineer1.name=“ 艾边成”; // 为name属性赋值
engineer1.showlnfo(); // 调用showInfo()的方法
类的定义格式举例:
对象的使用格式举例:
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?7.4 面对对象编程**
(1)程序设计是要模拟现实世界，帮助解决现实世界中的问题。面向对象程序设计思想更符合，人类的思维习惯，类是具有相同属性和共同行为的一组对象的抽象归类，由类创建出的对象,与人们生活中的具体事物相对应。
(2)对象的属性和行为被封装在类中，外界通过弓|用对象的属性和调用对象的方法来使用它们，使用者不需要关注类的内部实现,使用之前定义的类中定义的属性与方法,它们的关系如图所示。
(3)类可以视为对象的模板，只需要一次定义后就能创建n个对象，增加了重用性。
数据类型终结
Java中的数据类型主要分为以下两类。
1.基本数据类型
在Java中包含8种基本数据类型:整型(int)、短整型(short)、长整型(long)、字节整数(byte)、字符型(char)、单精度浮点型(float)、双精度浮点型( double )和布尔类型( boolean)。
2.引用数据类型
引用数据类型有字符串(String) ，使用class关键字定义的类都属于引用数据类型。例如:我们创建了一个汽.车Car类，使用“Car c = new Car();"创建出的对象c则属于创建的Car类型。
构造方法
我们学习了如何根据类型去创建一个对象，语法如下:
类名对象名=new类名();
语法中“new类名()”其实就是对构造方法的调用，完成对象的创建。语法如下
\[构造方法访问修饰符\]< 方法名> (\[参数列表\]) {
\[方法体\]
}
代码：
Cat 类定义了三个属性，分别是name、age 和color,还定义了两个构造方法，其中第一个与我们之前定义的方法类似。在方法名称后面的括号里没有任何东西，这种叫**无参构造方法**，使用它构建的对象包含的属性都是默认值。**无参构造方法**代码如下:
此时cat对象的name、age和color属性分别是null、0和null。
而Cat类的第二个构造方法的括号内，有一些变量的声明，这些方法括号内的变量，称之为“方法参数”。在有参数的构造方法内，代码完成了将三个参数分别赋值给三个属性的过程。代码如下:
当前只需要理解构造方法的参数，即可帮助我们在构造对象时，完成对对象属性的赋值。例如:
至此，我们可以知道，通过使用有参构造方法，可以快速地为创建的对象赋予需要的初始值，完成有效的对象初始化。构造方法和普通方法有很大的区别，区别如下:
(1)构造方法的名称必须和类名保持一致。
(2)构造方法不能有返回值类型。
(3)构造方法-般用public修饰。
(4)构造方法可以完成对类成员变量的初始赋值。
编写Java程序，定义Java类Point 用来表示坐标，坐标范围在(0,0) 到( 100,
100)以内，并显示符合规范的坐标在控制台。
(1)定义Point 类，为该类分别定义两个属性x和y,用来表示横坐标和纵坐标。
(2)为Point类定义两个构造方法，分别是无参构造方法和有参构造方法。
(3)在有参构造方法中完成对参数的判定,如果不满足坐标范围则给出错误提示且给坐标一个(1, 1)初始坐标，.
如果参数符合标准，则完成对属性x和y的赋值。
(4)定义Point类的showl)方法，完成x和y的打印。
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**第八章“方法”**
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?8.1 方法概括**
**编写程序的目的在于解决实际问题，在解决一个问题时，可以使用逐步分解、分而治之的方法，即将一个复杂的问题分解为若干个简单的问题，之后分别求解。在程序开发过程中，亦是如此。在程序中包含比较复杂的逻辑和功能时，可以将这些功能分解为若干个子功能分别实现，而这些子功能组合在一起，便形成了完整的程序。因此,对程序进行模块化设计，需要将其分解为若干个子程序模块，每个子程序模块实现特定的功能。例如，为了实现整数之间的四则运算功能,从功能上可以将其分解为5个模块,使用某功能时只需要调用相应的模块即可**
说明
在Java语言中,使用方法可以实现程序的模块化设计,使程序设计简单、直观,从而提高程序的可读性和可维护性。在Java语言中，方法是指- -段被封装起来且能实现一定功能的代码。工作原理类似于加工车间，将原材料送至加
工车间,通过加工,车间就能生产出对应的产品。在程序中,调用方法并传递相应的参数,方法就能完成对应的功能。一个Java语言程序可以由一个主方法和若干个子方法构成，主方法可以根据程序的需要合理地组织调用其他方法,从而实现程序的整体功能;子方法则用于实现程序的某个功能模块。方法之间完全平等，不存在隶属关系。程序的执行从主方法开始，同一个方法可以被-一个或多个方法多次调用，在调用过程中，通过返回值和参数进行数据传递。
通常在两种情况下，可考虑使用方法实现:
**(1)程序中可能重复出现相同或相似的代码，从中抽取出共同的部分，定义为方法，使该功能定义一次，可以多次使用，从而有效减少代码量，提高代码的重用率。
(2)程序中具有逻辑独立性的代码，即使该段代码只出现-次，也可以定义为方法，用于分解程序的复杂性，使程序结构更加清晰，更容易理解。**
在之前的示例中，我们已经接触了很多方法，如main()方法、控制台的输入输出方法等。在Java语言中，按照方法定义方式的不同，可以将其分为两种:系统方法和自定义方法。
1.系统方法
由系统定义的方法，称为系统方法，此类方法在程序中无需定义，直接调用即可。
例如，我们需要产生一个126~150的随机数。
使用Random的nextInt()方法可以帮助我们产生一个随机数。在指定参数后可以产生指定范围的随机数，比如rdm.nextInt(5)产生的为0到4的随机数，通过指定25产生0到24的随机数再加126则会产生126~150的随机数了。
2.自定义方法
系统方法只能完成基本的程序功能，并不能完全满足实际程序开发的需要。在Java语言中，允许用户根据功能需求自定义方法，自定义方法必须先定义后调用，如定义方法获取两数之间的最大值。
●修饰符: public static固定写法
●返回值类型:表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
●参数列表:方法在运算过程中的未知数据，调用者调用方法时传递
●return: 将方法执行后的结果带给调用者，方法执行到return，整体方法运行结束
小贴士: return 结果;这里的“结果"在开发中，我们正确的叫法成为方法的返回值
自定义方法的简介
自定义方法由方法签名和方法体组成，方法签名包括访问修饰符、返回值类型、方法名以及参数列表，方法体指具体实现的代码，必须使用一对括号"{}" 括起来。在Java语言中，方法必须遵循先定义后使用的原则。
1.自定义方法的定义的通用格式
(1)访问修饰符。用于设置方法可访问的范围，在Java语言中存在多种访问修饰符，现阶段通常使用public ,表示无任何访问限制。
(2)返回值类型。返回值是指方法被调用、执行之后，返回给主调方法的值。返回值类型是指返回值的数据类型，可以是Java语言所支持的任意类型,若不返回任何值,则其返回值类型用void关键字表示。
(3)方法名。方法名即方法的名称，通常通过方法名实现方法的调用，方法名与变量名命名规则一致，为了更好地描述方法的功能，建议使用有意义的英文单词作为方法名，且每个单词的首字母小写，如果由多个单词组成，则第一个单词首字母小写后续单词首字母大写。
(4)形式参数列表。形式参数为方法定义时的接口变量，用于在调用方法时，向方法传递数据。形式参数的个数可以是任意的，但括号“()” 不能省略，当存在多个形式参数时，使用逗号“,” 分隔。
(5)方法体。方法体即方法的实现部分，方法体中可以包含任意行代码，但括号"{}"不能省略。例如:
max()方法用于获取两数之间的最大值，具体说明如下:
(1) public为访问修饰符，表示该方法无任何的访问限制。
(2) int为返回值类型，表示该方法执行完毕之后将返回一个整型的数据，即两数之间的最大值。
(3)变量a、b为形式参数，表示在调用方法时可以向方法传递两个整型的数据，即需要比较的两个数据。
(4)括号“{"之间的代码为方法体，用于实现获取两数之间的最大值的过程。
2.自定义方法调用的通用格式
调用max()方法，将实参num1、num2 的值传递至max()方法中的形参a、b，执行max()方法，将较大值返回至主调方法，赋值给变量result。
3.自定义方法的分类
按照方法的结构，可以将方法分为以下几类:
(1)无参数无返回值的方法。
(2)有参数无返回值的方法。
(3)无参数有返回值的方法。
(4)有参数有返回值的方法。
不同类型的方法在定义和调用时，存在一些差异。
编写Java程序，让用户输入指定数字实现产生随机数。
(1)定义两个变量start和end来保存起始值和结束值。
(2)通过结束值减去起始值得到变化区间再加起始值，核心代码如下:
代码：
**?8.2 无参数无返回值的方法**
无参数无返回值的方法定义和调用
无参数无返回值的方法是Java语言中形式最为简单的方法，其定义和调用语法如下:
**(1)无参数无返回值方法的定义:**
**(2)无参数无返回值方法的调用:**
程序执行过程有别于之前的程序，当程序中存在方法调用时，程序执行的过程将
发生改变。
主方法作为程序的入口和出口，将首先被调用，在一个方法中调用另一个方法，程序控制将从主调方法中的方法调用语句转移至被调方法，执行被调方法体中的语句序列，在执行完方法体中所有的语句之后,将自动返回至主调方法的方法调用语句，并继续向下执行。如图所示。
练习：编写Java程序，根据用户输入的课程名称，输出对应课程的简介。
(1)定义三个方法，分别用于实现输出对应课程简介的功能。
(2) main方法主要用于控制程序执行流程，具体执行流程包括:①接收用户输入课程名称;②使用switch结构，根据用户输入的课程名称，调用对应方法。
!\[在这里插入图片描述\](https://i-blog.csdnimg.cn/blog\_migrate/4beb1df7508c2b451239e59a690df146.png)!\[在这里插入图片描述\](https://i-blog.csdnimg.cn/blog\_migrate/5d91e86d75d7bcb815efe7302b9212be.png)!\[在这里插入图片描述\](https://i-blog.csdnimg.cn/blog\_migrate/1275bcd0c078d0a00b66cb4ada2eb7b5.png) \*\*?8.3 有参数无返回值的方法\*\*
无参数无返回值的方法是形式最为简单的一种方法，但是功能上存在很大的局限性，若要实现更加灵活的功能,可以为方法提供参数，这样会大大提升方法的灵活性。其定义和调用语法如下:
(1)有参数无返回值方法的定义如下:
(2)有参数无返回值方法的调用如下:
实现按指定次数输出指定信息，要求定义方法实现信息的输出
在被调方法中输出的信息以及输出的次数和主调方法中所接收用户输入的数据完
全一致。说明在调用方法时，主调方法可以向被调方法传递数据，而数据的传递是通过方法的参数实现的。方法参数是主调方法与被调方法进行数据传递的主要渠道，方法的参数分为形式参数和实际参数两种。形式参数出现在方法定义中，在整个方法内部有效。实际参数出现在主调方法中，其作用是将实参的值传递给被调方法的形参，从而实现主调方法向被调方法传递数据的功能。方法调用时参数传递的过程，如图所示。
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?8.4 成员变量和局部变量**
在Java语言中，根据定义变量位置的不同，可以将变量分成两大类:成员变量和局部变量。成员变量指的是在类范围里定义的变量，即前面章节介绍的属性;局部变量指的是在方法里定义的变量。不管是成员变量还是局部变量都应该遵守相同的命名规则:从语法角度来看，只要一个合法的标识符即可;但从程序可读性角度来看，应该是多个有意义的单词连缀而成，其中第一个单词首字母大写。Java程序中的变量划分如图所示。
成员变量分为实例字段和类字段( static修饰的属性，后续章节会有详细介绍)，实例字段即我们之前学习的类的属性，实例字段从类的实例化后就存在，直到对象消亡而消亡，正是由于这个原因，我们称其为成员变量，它是实例的一个成员，与实例共存亡。
只要实例存在，程序就可以访问该实例的实例字段。在程序中访问实例字段的语法如下:
局部变量
局部变量分为三类，分别是方法的参数、方法内部声明的变量以及代码块中声明的变量。
(1)局部变量的作用域相对比较小，如方法的参数和方法内声明的变量都只在方法体内能够正常访问，超出方法范围后是无法访问到的，代码
if代码块中声明的name变量，在if代码块外是不能访问的。同理，for 循环中的赋值表达式中，声明的循环变量也同样不能在循环体外访问到。
编写Java程序,在控制台中输入一个数字,
要求定义方法实现找出能够整除该数字的所有数字。
(1)定义方法findNums()， 用于实现查找所有能够整除指定数字的所有数字。
根据需求说明要求，方法findNums()需要定义一个int类型的参数number,因此，方法findNums()的方法签名如下:
由于要查找出所有能够整除指定数字的所有数字，需要从1开始查找直到指定数字为止，可以通过for循环实现。
(2) main() 方法中接收用户输入的数字，并调用方法findNums输出结果。
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**第九章“方法与参数类型”**
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?9.1 有参数有返回值的方法**
定义方法的目的是为了实现特定功能或进行某种运算，无论是实现功能，还是执行运算，都会产生一个结果，而这个结果需要反馈给调用方。例如:购买商品进行结算时，会产生一个结果反馈给用户，即购买商品的付款金额是多少;在论坛中注册新用户时，会产生一个结果反馈给用户，即注册是否成功。在方法中参与运算或实现功能所需要的数据，可以使用参数实现。而对于方法产生的结果则可通过返回值反馈给调用方。
存在返回值的方法一般有两种形式:
无参数有返回值的方法和有参数有返回值的方法。
无参数有返回值的方法适用范围很少，我们更多使用的是有参数有返回值的方法。
有参数有返回值的方法定义和调用
有参数有返回值的方法是Java语言中形式最为复杂的方法，其定义和调用语法如下:
(1)有参数有返回值方法的定义如下:
(2)有参数有返回值方法的调用如下:
方法的返回值也称为方法值,是指方法被调用、执行后，返回给主调方法的值,通过被调方法中的return语句实现。
return语句是Java语言中的跳转语句，其主要作用如下:
(1)结束被调方法的执行，返回主调方法。此时，方法体中位于return语句之后的代码将不再执行。例如:
运行上述代码，将只会输出一次“Hello World!“，在程序运行过程中，当遇到return语句之后，不再向下执行，结束main() 方法的执行，程序终止。若删除return语句，则将会输出两次“ Hello World!”。
(2)返回一个表达式的值，该值将作为方法调用过程中方法的返回值。编写Java程序,在控制台输入一个年份，判断该年份是否为闰年并输出结果。要求定义方法实现闰年的判断，并返回判断结果。代码见示例。
9.1.2 返回值的传递过程
由图9.1的输出结果可以得出，被调方法的返回值在主方法中被正确接收，说明在调用方法时，被调方法可以向主调方法返回数据，而数据的返回是通过方法的返回值实现的。
在调用方法的过程中，控制权从主调方法移交至被调方法，在被调方法执行之前，先完成参数的传递，之后进行被调方法的执行。在执行被调方法的过程中，当遇到return语句时，先计算return之后表达式的计值，再结束被调方法的执行返回主调方法，此时计算的结果作为返回值一并带回主调方法。方法调用时返回值传递的过程，如图所示。
关于方法返回值的内容，总结如下:
(1 )返回值传递的时机:返回值传递发生在被调方法执行完毕返回主调方法时。在被调方法执行过程中遇到语句“return表达式”，先计算表达式的值，再结束被调方法的执行，返回主调方法时同时进行返回值的传递。
(2)返回值传递的过程:接收返回值的变量“= return”语句之后的表达式的值。返回值传递的过程其实就是一个赋值的过程，将return语句之后的表达式的值赋值给主调方法中用于接收返回值的变量。
(3)返回值传递的意义:返回值传递是指将数据从被调方法传递至主调方法的一-种方式。返回值传递实际上是提供另一个数据通道，传递方向是从被调方法到主调方法，传递的数据量有且仅有一个。
方法返回值的注意事项
使用返回值可以很方便的将被调方法中的运算结果或处理结果传递至主调方法，但在使用返回值时很容易出现一些问题，具体注意事项如下:
(1)方法可以没有返回值，也可以存在返回值，但最多只能存在一个返回值。例如:
上述代码将提示错误，因为定义方法时设置返回值为void,表示方法不存在返回值，因此，在方法体中不能出现语句“return 表达式”。例如:
上述代码也将提示错误，因为若方法存在返回值，返回值最多只能有一个，可以使用语句“return a;"或“return b”。
(2)方法的返回值可以为变量、常量以及表达式。在方法体中使用return 语句设置返回值时，return 之后可以是常量、变量或表达式。例如:
(3)在无返回值方法中，方法体内可以没有return语句，当被调方法执行完毕后，将自动返回至主调方法。也可以使用return语句，结束被调方法的执行，返回主调方法。
类似于循环，循环的结束有两种情况:**循环条件不成立或执行break语句**。被调方法的终止执行也存在两种情况: **被调方法中所有代码执行完毕或执行return语句**。例如:
调用方法Method\_ A,若参数num为奇数时，条件“num%20”不成立，不会执行return语句，输出“HelloWorld!”后，方法Method\_ \_A 所有代码执行完毕，终止被调方法执行返回主调方法。若参数num为偶数时，条件“num%20”成立，执行return语句，将直接终止被调方法执行返回主调方法。
(4)在有返回值方法中，方法体中必须包含“return 表达式;”语句。例如:
上述代码将提示错误，因为定义方法时设置返回值类型为int,表示方法存在int类型的返回值，因此，需要在方法体中添加语句“return a;”。
(5)方法体中返回值的数据类型必须与方法中定义时指定的返回值类型相匹配。例如:
上述代码将提示错误，因为定义方法时设置返回值类型为int,而返回值为变量a，其数据类型为double类型，两者之间的数据类型不匹配，因此，可以将“return a;”修改为“return (int)a;” 或修改方法返回值类型为double。
(6)使用条件结构时，必须保证每一个分支都包含返回值。例如:
在.上述代码中,虽然存在多个“return表达式;”语句,但这并不代表方法存在多个返回值,因为在方法执行过程中,每次只能执行条件结构中的一个分支，即只会执行一个“return表达式;”语句。只是在不同条件下执行不同的分支,返回不同值而已，从而保证在每个分支中都存在返回值，否则将提示错误。
编写Java程序，用户输入3个操作数，分别求出最大值、最小值和平均值。
(1)定义Java类，定义3个方法，用来求3个数字的最大值、最小值和平均值。
(2)在main()方法中使用Scanner完成对3个实例字段的赋值，再分别调用3个方法得到结果进行打印。
参考代码如下:
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?9.2 参数的数据类型**
**Java的数据类型分为值类型和引用类型，这两种类型在作为参数使用时是有区别的。**
值类型的参数
当方法的参数是值类型时，因为值类型变量里存放的是变量的值，形参和实参会完成变量值的拷贝。当方法内代码完成形参值的改变时，实参不会同步改变。代码见示例。
**我们可以在方法内改变的形参通过return关键字返回,在方法调用时接收改变后的返回值即可。**
引用 类型的参数
Java中引用类型变量里存储的是对象的内存地址，通过内存地址可以访问到对象的属性和方法。当引用类型变量完成相互赋值时，即完成对象地址的拷贝，而非对象属性的拷贝。
当我们将引用类型作为方法参数使用时，因为参数的数据类型为引用类型，变量里存放的是对象的内存地址，所以形参和实参实际是同一个对象，改变实参的值，形参也会改变。代码见示例。
**有参方法的调用实际就是实参为形参赋值的过程，形参和实参取值是否同步取决于参数的数据类型，当参数是值类型时，形参和实参的取值是不同步的，当参数是引用类型时，形参和实参的取值是同步的。**
编写Java程序，定义Employee类以及HR类，实现HR为Employee加薪的功能。
(1)定义Employee类，并定义属性name、salary和deptName属性分别标识员工姓名、员工工资和员工所在部门名称。
(2)定义HR类，并定义属性name、deptName以及方法updateSalary()用来更新员工工资，该方法参数为Employee类型。
(3)编写测试类，在测试类中分别创建Employee对象和HR对象并为属性赋值，调用HR对象的updateSalary()方法完成对员工工资的添加。
参考代码如下:
员工类的代码如下:
HR类的代码如下:
测试类的代码如下:
执行效果：
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?9.3 深入理解方法**
质数的判断
问题描述:在控制台中输出50~ 100之间的所有质数。质数是指只能被1和本身整除的数字。例如，7只能被1、7整除，所以7为质数。要求:判断质数的方法实现。
根据问题描述可知，程序结构设计如下:
**1.定义方法isPrimeNumber()用于实现指定数字是否为质数的判断**
(1)根据方法功能分析可知，方法isPrimeNumber()需要设置一个int类型的参数num，表示待判断的数字，且需要返回判断结果，可通过返回值实现，因此方法isPrimeNumber()的方法签名如下:public static bool isPrimeNumber(int num)
(2)质数的判断过程，可使用循环结构实现，从2开始直到num-1，逐一判断这些数字中是否存在能够整除num的数字，若不存在，则当前数字为质数，否则为非质数。
(3) 声明变量result表示判断结果，设置初始值为true， 在循环过程中若存在能够整除num的数字，则将变量result的值设置false，表示num为非质数，同时可以借助break提高执行效率，因为只要存在一个数字能够整除num, num即为非质数，不需要继续判断之后的数字。
**2.在Main() 方法中通过循环并调用方法isPrimeNumber()， 逐一判断50~ 100中数字是否为质数，若返回判断结果为true,则意味着当前所判断的数字为质数，输出至控制台，否则继续判断下一个数字是否为质数**
代码如下：
执行效果:
问题描述:用户在控制台输入一个三位数字，判断该数字是否为水仙花数。
**分析**
根据问题描述可知，程序结构设计如下:
定义方法isNarcissus()，用户判断参数数字是否为水仙花数，如果是返回true,否则返回false。
(1) 水仙花数是一个三位数字，三位数字的立方之和等于数字本身。
(2) 根据方法功能分析可知，方法isNarcissus() 需要设置int类型的参数num，表示需要判断的数字，判断后的结果，可通过返回值实现，因此方法isNarcissus()的方法签名如下:
public boolean isNarcissus (int num)
执行效果：
对学生的英语考试成绩进行评测，评测规则如下:
编写Java程序，在控制台输入一位学生的英语考试成绩，根据评测规则，输出对应的成绩等级。要求:定义函.数实现学生成绩的评测功能。
(1)定义方法getLevel(), 用于根据成绩评测规则，输出对应的成绩等级。
根据需求说明要求,方法getLevel()需要定义-个参数: int 类型num,表示学生的英语成绩,且需要返回评测结果,可通过返回值实现，因此方法getLevel()的方法签名如下:
由于评测规则需要多次进行判断，可使用多重if实现。
(2) main()方法中接收用户输入的学生英语成绩，调用方法getLevel()获取评测结果并输出。
参考代码如下:
执行效果：
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?9.4 方法使用**
模拟程序菜单的案例
定义菜单类，在菜单中封装登录菜单与登录后的主菜单。
代码：
问题描述:模拟银行账户存取款以及查看余额功能。
要求:将各种业务功能模块分别定义方法实现。
**根据问题描述以及运行效果可知，程序结构设计如下:**
(1) 定义方法queryBalance()， 用于实现查询余额功能。根据方法功能分析可知，方法queryBalance()只需要设置一个int类型的参数balance,表示银行账户余额，因此方法queryBalance()的方法签名如下:
**public void queryBalance(int balance)**
(2) 定义方法deposit()， 用于实现存款功能。根据方法功能分析可知，方法deposit()需要设置一个int类型的参数balance,表示银行账户余额，但由于存款操作需要在方法中更新账户余额，且需要保留更新后的账户余额，所以需要将修改后的余额返回给调用者。因此，方法deposit() 的方法签名如下:
**public int deposit (int balance)**
(3) 定义方法withdrawal()， 用于实现取款功能。根据方法功能分析可知，方法withdrawal()需要设置一个int类型的参数balance， 表示银行账户余额，与存款操作相同，存款也需要更新账户余额，为了能保留更新后的账户余额，所以同样需要将修改后的余额返回。因此，方法withdrawal()的方法签名如下:
**public int withdrawal(int balance)**
(4)在main() 方法中实现程序的执行流程，并在对应操作中调用方法即可。
执行效果：
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**第十章“数组”**
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?10.1 数组概括**
数组的优势
计算机程序离不开算法和数据结构，之前所学习的程序中用if语句、if-else 语句、switch语句实现的条件结构与用while语句、do-while语句、for 语句实现的循环结构解决的是程序的逻辑问题，即算法问题。那么，在程序中还应该有数据的操作，而计算机存储、组织数据的方式即数据结构。
数据结构就是把数据按照某种特定的结构来保存，设计合理的数据结构是解决问题的前提。例如，存储一位学生的Java成绩，并为其Java成绩提升5分。代码如下:
使用变量可以非常方便地解决此类问题，但是在程序设计过程中，通常需要存储和操作多个数据，此时仍可以使用变量实现。
**数组是编程语言中最常见的一种数据类型，可用于存储多个数据。**
数组是一个变量，用于将相同数据类型的数据存储在内存空间中。数组中的所有元素必须属于相同的数据类型。一个整型变量存储一个整数，那么数组也是一一个变量，只不过它存储了-组相同类型的数据。例如，一个整型数组存储一组整数，一个字符串类型的数组存储一组字符串。 声明一个变量将会在内存中开辟一个内存空间，然后将数据存储在对应内存空间中。同样，创建一个数组将 会在内存中开辟-段连续的内存空间，用于存储多个数据,如图。
数组在内存中为了能够存取多个数据更加方便，在设计数组时，数组的结构和基本要素都与生活中的电子储物柜非常类似，如图所示。
为了便于查找，超市门口每一个储物柜都会设置名称，数组当然也需要名称，这样才能够引用对应的数组。另外，找到正确的储物柜后还需要根据储物箱的编号找到对应的储物箱取出物品。数组也一样，找到内存中对应数组的那段连续的存储空间后，还需要根据不同的下标找到数组中的某个数据。
(1)数组中存储的数据称为数组元素,同一个数组中的数组元素必须具有相同的数据类型,且在内存中连续分布。
(2)无论数组中包含多少个数组元素，该数组只存在一个名称，即数组名。
(3)数组元素按顺序进行存储和编号，数组元素的编号称为下标，在Java语言中，数组的下标从0开始，其他元素按顺序编号，它标明了元素在数组中的位置。
(4)数组元素均存在下标，可以通过“数组名\[下标\]”的方式访问数组中的任何元素。由于数组元素是按顺序存储的，每个元素固定对应一个下标，因此可以通过下标快速地访问到每个元素，类似于通过储物箱编号找到对应储物箱一样。例如，grades\[0\] 是指数组中的第-个元素，grades\[1\] 是指数组中的第二:个元素 。
(5)一个储物箱的容量是有限的，所以可以存放物品的数量也是有限的。同理，数组的长度指数组可以存储元素的最大个数，在创建数组时确定，操作数据时需防止下标越界的错误。例如，图中数组下标最大为4，如果数组的下标超过此大小，程序就会因为错误而终止。
数组的分类
在Java语言中，存在多种形式的数组。
(1)按照数组元素数据类型的不同，可以将其分为整型数组、字符型数组、字符串型数组和浮点型数组等。可根据存储数据的形式选择对应数据类型的数组。例如，如果要存储班级中所有学生的姓名，可以使用字符串类型的数组;如果要存储公司中所有员工的薪资，可以使用浮点类型的数组。
(2)按照数组的维数不同，可以将其分为一维数组、多维数组以及交错数组等。
一维数组: -维数组是最简单、最常用的一种数组形式，只存在一个下标，用于存储一行或一列数据。 例如，存储班级中所有学生某门课程的成绩。一维数组的结构如图所示。
多维数组:多维数组是存在多个下标的数组，最简单数组形式是二维数组，用于存储存在多行多列的数据。例如，存储班级中所有学生5门课程的成绩。二维数组可以被认为是多行多列的表格，二维数组的结构如图所示。
交错数组:交错数组是数组中包含的数组，以二维交错数组为例，需要先设置数组的行数,之后再为每一行创建长度不同的数组，因此，交错数组的每- -行的长度会不同，交错数组的结构如图所示。
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?10.2 一维数组**
数组的定义和使用.
在Java语言中，最常用的数组是一维数组， 数组的使用类似于变量的使用，分为以下4个步骤:
1.声明数组
声明数组是使用数组的第一步， 需要说明数组元素的类型以及数组的名称。
2.创建数组
声明数组，只是得到了一个存放数组的变量，并不会为数组分配内存空间，此时的数组无法存储数据。要为数组分配内存空间，这样数组的每一个 元素才能进行存储数据。在Java语言中，可以通过new关键字创建数组,为数组分配内存空间。
3.初始化数组
创建数组将会为数组分配内存空间，之后便可在数组中存储数据，可通过数组的下标为数组进行初始化。
方法一：
义可以存储3个整数的数组容器，代码如下:
方法二：
定义存储1，2, 3, 4, 5整数的数组容器。
方法三：
事实上，如果所定义的数组是基本数据类型的数组，即char类型、int 类型、double 类型、float 类型以及
boolean类型，若没有指定初始值，则会依据数据类型的不同，为数组元素赋予默认值，详情见表10.1。
在Java语言中，数组的创建和初始化存在多种方式
4.引用数组元素
数组元素初始化完毕后，可以通过“ 数组名l下标\]”方式对数组中的元素进行存取。使用下标对数组元素进行引用时，需防止下标越界而出现的错误，数组中第-个元素的下标为0,最后一个元素的下标为数组长度-1。特别值得注意的是，数组是一种引用类型，具有方法和属性，可以使用length属性在程序中动态获得数组的长度。
输入本部门5位员工的薪资，并根据用户输入的序号为指定员工进行提薪。若用户输入序号出现越界,则提示错误。要求:薪资的涨幅不能超过原薪资的20%，若涨幅超过20%，则按照原薪资的20%进行提薪。运行结果所示。
**分析：**
**根据问题描述可知，要实现对指定员工的薪资进行提升，则必须在程序中保存5位员工的薪资，可定义数组存储员工的薪资。按照数组使用的步骤，根据用户输入薪资对数组进行初始化，并对指定索引下的员工薪资进行提薪。**
(1)在程序中涉及到数组长度时，不建议直接使用数值常量5,而使用数组的length属性动态获取数组长度。
这对于程序的可维护性很重要，若后期要对数组的长度进行修改时，只需要修改数组创建时定义的长度，其他代码不需要做任何修改。例如，使用for循环结构对数组进行初始化时，for 循环表达式2中涉及到数组的长度,规范代码如下:
(2)当用户输入需要提薪的员工序号时,员工序号是1到5,而对应的数组元素下标是0到4,所以在进行提薪操作时,需要将员工的序号转换为对应数组元素的下标，对应数组元素的下标=用户输入的员工序号-1。
完整代码见示例。
输入员工序号出错
输出提薪后的薪资
**?10.3 数组的应用（一）**
数组是程序开发过程中最常用的存储数据的结构之- -，且数组常与循环配合使用，特别是for循环，用于解决程序中比较复杂的问题。程序中很多经典的算法均涉及到数组的应用，数组最基本的应用包括数据元素的遍历以及最大值、最小值的判断等。
遍历数组元素
在操作数组元素时，经常针对数组中所有的元素进行。此时，需要将数组中所有的数据使用下标进行遍历，遍历时使用for循环更为方便。
**编写Java程序，输入本部门5位员工的姓名和薪资，输出5位员工的姓名以及年薪，运行结果如图**
**分析：
根据问题描述可知，需要在程序中存储5位员工的姓名和薪资，由于姓名为字符串类型，薪资为整型，不能存储在同一个数组中，因此，需要定义两个数组分别存储员工姓名和薪资。**
增强型for循环与数组的遍历
采用普通循环对数组进行遍历时，都需要获取数组的下标，依次获取数组的元素。为简化对数组的遍历操作，提高数组遍历的效率，Java提供了增强型的for循环，该循环专用于数组或集合的遍历操作。其语法格式如下:
循环将依次取出数组或集合中的每一个元素并赋值给循环变量，然后执行语句块，直至遍历完数组或集合中的所有元素为止。
在增强型for循环中，数据类型可以是基本数据类型，也可以是引用数据类型。变量用于依次存储数组中的元素，将遍历到的数组元素存储到该变量中。数组可以是-维数组，也可以是二维数组。
使用增强型for循环遍历一维数组的代码如下:
改上一个代码图：
某软件公司要求对技术部门的所有员工进行技能评测，技术评测分为两个部分:理论部分以及实操部分，最终评测成绩=理论成绩x0.4+实操成绩x0.6,要求输入技术部门5位员工的理论成绩和实操成绩，计算并输出各位员工的最终评测成绩。运行效果如图所示。
(1)定义3个数组writenExam、 labExam和scores, 分别用于存储员工理论成绩、实操成绩和最终评测成绩。
(2)由于每个员工存在3个属性:理论成绩、实操成绩以及最终评测成绩，而3个属性对应的数据存储在3个数组中，所以，3个数组中同一下标处的数据用于描述同一个员工。例如，第3位员工的理论成绩是writenExam\[2\],实操成绩是labExam\[2\],最终评测成绩是score\[2\]。
(3)使用循环依次接收用户输入的理论成绩和实操成绩，将数据存储在数组writenExam和labExam中。
(4)使用循环依次计算每位员工的最终评测成绩，将数据存储在数组scores中。
(5)使用循环结构输出每位员工的最终评测成绩。
参考代码如下:
[](https://blog.youkuaiyun.com/a25847a/article/details/145465706?ops_request_misc=elastic_search_misc&request_id=b3dd4fc22080429c7db5503ddd4235db&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-145465706-null-null.142^v102^pc_search_result_base9&utm_term=java%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%E8%AF%A6%E7%BB%86&spm=1018.2226.3001.4187)
**?10.4 数组的应用（二）**
在现实生活中，经常会对一组数据求最大值和最小值，而最大值和最小值的判断可以借助数组实现。以求最大值为例，最大值即一组数据中最大的值。获取最大值的过程类似于古装电影中的打擂比武，如图所示。
首先，第一个上擂台的人是擂主,然后与下一个竞争对手进行比武，若取胜,则第一个人仍是擂主,否则，竞争对手便成为擂主，然后擂主继续与之后的竞争对手进行比武，以此类推，最后站在擂台上的擂主，便是本次比武的胜利者。类似于打擂，求最大值的过程也是如此，如图所示。
首先将数组的第一个元素赋值给变量max，之后将数组中剩余的数组元素依次与变量max进行比较，若数组元素较大，则将数组元素赋值给变量max，否则变量max保持不变，最终变量max中存储的就是最大值。可以使用下述代码表示:
观察，上述代码，分析可知，这是一个循环的过程，因此可采用循环的方式简化代码量，提高程序执行效率，代码如下：
求最小值的过程与求最大值类似，首先将数组的第-个元素赋值给变量min,之后将数组中剩余的数组元素依次与变量min进行比较，若数组元素较小，则将数组元素赋值给变量min,否则，变量min保持不变，最终变量min中存储的就是最小值。在示例10.4中添加代码实现求最小值，修改后的代码见示例。
Java虚拟机的内存划分
**为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。**
●JVM的内存划分:
一个数组内存图
以上方法执行,输出的结果是\[I@5f150435,这个是什么呢?是数组在内存中的地址。new出来的内容,都是在堆内存中存储的，而方法中的变量arr保存的是数组的地址。
**输出arr\[0\]，就会输出arr保存的内存地址中数组中0索引上的元素**
两个数组内存图
两个变量指向一个数组
数组遍历
●数组遍历:就是将数组中的每个元素分别获取出来，就是遍历。遍历也是数组操作中的基石。
以上代码是可以将数组中每个元素全部遍历出来,但是如果数组元素非常多，这种写法肯定不行，因此我们需要改造成循环的写法。数组的索引是0到lenght-1，可以作为循环的条件出现。
数组作为方法返回值
数组作为方法的返回值，返回的是数组的内存地址
数组反转
●数组的反转:数组中的元素颠倒顺序,例如原始数组为1,2,3,4,5, 反转后的数组为5,4,3,2,1
●实现思想:数组最远端的元素互换位置。
实现反转，就需要将数组最远端元素位置交换
定义两个变量，保存数组的最小索弓|和最大索引
两个索引上的元素交换位置
最小索引++,最大索引-.再次交换位置
最小索引超过了最大索引，数组反转操作结束
数组的排序.
在编写程序中，经常会遇到对一组数据进行排序的问题，对于数组的排序，其实存在很多的方法，如快速排序法、冒泡排序法、选择排序法以及插入排序法等。但是无论哪种方式，都需要进行复杂的比较或交换才能够实现，幸运的是，Java设计人员已经帮助我们实现了排序算法，通过Arrays .sort()方法可以快速实现数组元素的排序(默认按升序排列)，代码见示例。
在使用Arrays.sort()方法之后，数组中学生成绩将按照从底到高的方式进行排序，也就是升序方式排序。但在进行成绩排名时，往往需要按照从高到低的方式排序，这又该如何实现呢?只需将数组在排序好后，将数组的前半部分和后半部分交换即可，代码见示例。
? **后记** **好了各位，以上就是这篇博客的全部内容，有不懂的或模糊的可以评论留言，我会抽时间写一个没章节的总结，愿我们一起成长，一起加油。 我自己近期准备建立一个自己的微信公众号《星沅传》 写作过程不易，不过终于在过年那一天前写完了，写作已经是凌晨2点半了，准备睡觉了，晚安世界 如果本篇博客有任何错误，请批评指教，不胜感激!**
### Java开发的就业市场正在经历结构性调整，竞争日益激烈
传统纯业务开发岗位（如仅完成增删改查业务的后端工程师）的需求，特别是入门级岗位，正显著萎缩。随着企业技术需求升级，市场对Java人才的要求已从通用技能转向了更深入的领域经验（如云原生、微服务）或前沿的AI集成能力。这也导致岗位竞争加剧，在一、二线城市，求职者不仅面临技术内卷，还需应对学历与项目经验的高门槛。
### 大模型为核心的AI领域正展现出前所未有的就业热度与人才红利
2025年，AI相关新发岗位数量同比激增543%，单月增幅最高超过11倍，大模型算法工程师位居热门岗位前列。行业顶尖人才的供需严重失衡，议价能力极强，跳槽薪资涨幅可达30%-50%。值得注意的是，市场并非单纯青睐算法研究员，而是急需能将大模型能力落地于复杂业务系统的工程人才。这使得具备企业级架构思维和复杂系统整合经验的<font color='red'>Java工程师，在向“Java+大模型”复合人才转型时拥有独特优势，成为企业竞相争夺的对象，其薪资天花板也远高于传统Java岗位。
<font color="red">说真的，这两年看着身边一个个搞Java、C++、前端、数据、架构的开始卷大模型，挺唏嘘的。大家最开始都是写接口、搞Spring Boot、连数据库、配Redis，稳稳当当过日子。 </font>
结果GPT、DeepSeek火了之后，整条线上的人都开始有点慌了，大家都在想：“我是不是要学大模型，不然这饭碗还能保多久？”
先给出最直接的答案：一定要把现有的技术和大模型结合起来，而不是抛弃你们现有技术！掌握AI能力的Java工程师比纯Java岗要吃香的多。
<font color="red"> 即使现在裁员、降薪、团队解散的比比皆是……但后续的趋势一定是AI应用落地！大模型方向才是实现职业升级、提升薪资待遇的绝佳机遇！</font>
## 如何学习AGI大模型？
作为一名热心肠的互联网老兵，我决定把宝贵的AI知识分享给大家。 至于能学习到多少就看你的学习毅力和能力了 。我已将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。
因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取
****************************************************************************************************************************************************************************************************************************************************************[2025最新版优快云大礼包：《AGI大模型学习资源包》免费分享](https://mp.weixin.qq.com/s/7nPWUAEJxt8QXGCU0d8CUA)******************************************************************************************************************************************************************************************************************************************************************
一、2025最新大模型学习路线
===============
一个明确的学习路线可以帮助新人了解从哪里开始，按照什么顺序学习，以及需要掌握哪些知识点。大模型领域涉及的知识点非常广泛，没有明确的学习路线可能会导致新人感到迷茫，不知道应该专注于哪些内容。
**我们把学习路线分成L1到L4四个阶段，一步步带你从入门到进阶，从理论到实战。**
### L1级别:AI大模型时代的华丽登场
> L1阶段：我们会去了解大模型的基础知识，以及大模型在各个行业的应用和分析；学习理解大模型的核心原理，关键技术，以及大模型应用场景；通过理论原理结合多个项目实战，从提示工程基础到提示工程进阶，掌握Prompt提示工程。
### L2级别：AI大模型RAG应用开发工程
> L2阶段是我们的AI大模型RAG应用开发工程，我们会去学习RAG检索增强生成：包括Naive RAG、Advanced-RAG以及RAG性能评估，还有GraphRAG在内的多个RAG热门项目的分析。
### L3级别：大模型Agent应用架构进阶实践
> L3阶段：大模型Agent应用架构进阶实现，我们会去学习LangChain、 LIamaIndex框架，也会学习到AutoGPT、 MetaGPT等多Agent系统，打造我们自己的Agent智能体；同时还可以学习到包括Coze、Dify在内的可视化工具的使用。
### L4级别：大模型微调与私有化部署
> L4阶段：大模型的微调和私有化部署，我们会更加深入的探讨Transformer架构，学习大模型的微调技术，利用DeepSpeed、Lamam Factory等工具快速进行模型微调；并通过Ollama、vLLM等推理部署框架，实现模型的快速部署。
整个大模型学习路线L1主要是对大模型的理论基础、生态以及提示词他的一个学习掌握；而L3 L4更多的是通过项目实战来掌握大模型的应用开发，针对以上大模型的学习路线我们也整理了对应的学习视频教程，和配套的学习资料。
二、大模型经典PDF书籍
============
书籍和学习文档资料是学习大模型过程中必不可少的，我们精选了一系列深入探讨大模型技术的书籍和学习文档，**它们由领域内的顶尖专家撰写，内容全面、深入、详尽，为你学习大模型提供坚实的理论基础**。**（书籍含电子版PDF）**
三、大模型视频教程
=========
对于很多自学或者没有基础的同学来说，书籍这些纯文字类的学习教材会觉得比较晦涩难以理解，因此，我们**提供了丰富的大模型视频教程**，以动态、形象的方式展示技术概念，**帮助你更快、更轻松地掌握核心知识**。
四、大模型项目实战
=========
**学以致用** ，当你的理论知识积累到一定程度，就需要通过项目实战，**在实际操作中检验和巩固你所学到的知识**，同时为你找工作和职业发展打下坚实的基础。
五、大模型面试题
========
面试不仅是技术的较量，更需要充分的准备。
在你已经掌握了大模型技术之后，就需要开始准备面试，我们将提供精心整理的大模型面试题库，涵盖当前面试中可能遇到的各种技术问题，让你在面试中游刃有余。
因篇幅有限，仅展示部分资料，需要点击下方链接即可前往获取
****************************************************************************************************************************************************************************************************************************************************************[2025最新版优快云大礼包：《AGI大模型学习资源包》免费分享](https://mp.weixin.qq.com/s/7nPWUAEJxt8QXGCU0d8CUA)****************************************************************************************************************************************************************************************************************************************************************
6万+
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
