第01章_Java语言概述

1. Java知识脉络图

1.1 Java基础全程脉络图

1.2 本章专题与脉络

2. 抽丝剥茧话Java

2.1 当前大学生就业形势

• 麦可思研究院发布了《2022年中国大学生就业报告》，针对2021届毕业生收入较高的本科专业排行榜：

• 麦可思研究院发布过《2021年中国大学生就业报告》，应届本科毕业生就业数量较大的前十位行业类的就业质量：

  

• 报告还对毕业三年后的2017届毕业生所在十大行业进行了统计：

• 从国家统计局发布的2021年全国平均工资来看，不管在城镇非私营单位还是私营单位，IT业均为最高。

2.2 IT互联网是否依旧靠谱

过去不能代表未来！互联网是否依旧靠谱？！

2014 年至 2018 年间，我国网民规模从 6.49 亿增长为 8.29 亿，增幅为 27.5%。同一时间段，全国移动互联网接入的流量却从 20.6EB 增长到了 711.1EB，增幅达 3352%（获取和处理的信息量大幅增加）。

随着 5G 技术进一步拓宽移动互联网的速度和容量，产业互联网将在消费型流量的基础上创造生产型流量，根据报告的预测，至 2024 年，全国移动互联网的接入流量将达到 127663.8EB， 流量规模达到2018年的179.5倍。

当下，5G、物联网、人工智能、产业互联网都是国家政策大方向，需要大量能与机器对话的中高端人才。

2.3 IT行业岗位分析

软件开发，是进入互联网IT圈最好的选择之一！

• 起始薪资高
• 工作环境好
• 涨薪幅度高
• 行业更公平

2.4 软件开发之Java开发

• 移动应用领域（集成Android平台）：Java在Android端是主要开发的语言，占有重要的地位。

  

• 企业级应用领域（JavaEE后台）：用来开发企业级的应用程序，大型网站如淘宝、京东、12306，以及各大物流、银行、金融、社交、医疗、交通、各种OA系统等都是用JavaEE技术开发的。

  

• 大数据分析、人工智能领域：流行的大数据框架，如Hadoop、Flink都是用Java编写的。Spark使用Scala编写，但可以用Java开发应用。

  

  

  Eversoft公司在提到2022年Java发展趋势时写道：

  Java 是用于开发大数据项目的最主流的语言。我们可以轻松地预测它也将在之后继续主导大数据！

• 游戏领域、桌面应用、嵌入式领域：很多大型游戏的后台、桌面应用等也是Java开发的。

2.5 到底多少人在用Java

2020年，根据 IDC 的报告“Java Turns 25”显示，超过 900 万名开发人员（全球专职开发人员中的 69%）在使用 Java——比其他任何语言都多。该报告指出，大多数企业业务服务都依靠 Java 来实现。

… Java 一直是开发人员中最流行的编程语言，被誉为“宇宙第一语言”。

我想告诉大家：

“市场的需求比较大，市场的供给比较大”

“如果你在Java领域里持续积累5-7年以上，那么你至少会成为这个行业的一个专家！”

2.6 八卦一下程序员

还可以是：

2.7 Java系列课程体系

• 见02_学习路线图之《Java中高级程序员全程学习路线图.xmind》

2.8 Java职业晋升路线图

薪资数据统计来源：拉勾网

3. 计算机的硬件与软件

3.1 计算机组成：硬件+软件

3.2 CPU、内存与硬盘

• CPU（Central Processing Unit，中央处理器）

  • 人靠大脑思考，电脑靠CPU来运算、控制。

• 硬盘（Hard Disk Drive）

  • 计算机最主要的存储设备，容量大，断电数据不丢失。
  • 正常分类：机械硬盘（HDD）、固态硬盘（SSD）以及混合硬盘（SSHD）
  • 固态硬盘在开机速度和程序加载速度远远高于机械硬盘，缺点就是贵，所有无法完全取代机械硬盘。

• 内存（Memory）

  • 负责硬盘上的数据与CPU之间数据交换处理
  • 具体的：保存从硬盘读取的数据，提供给CPU使用；保存CPU的一些临时执行结果，以便CPU下次使用或保存到硬盘。
  • 断电后数据丢失。

3.3 输入设备：键盘输入

• 熟悉指法

不熟悉键盘的小伙伴，可以“金山打字通”走起了。坚决杜绝二指禅！！

4. 软件相关介绍

4.1 什么是软件

软件，即一系列按照特定顺序组织的计算机数据和指令的集合。有系统软件和应用软件之分。

Pascal之父Nicklaus Wirth： “Programs = Data Structures + Algorithms”

系统软件：

应用软件：

4.2 人机交互方式

• 图形化界面（Graphical User Interface，GUI），这种方式简单直观，使用者易于接受，容易上手操作。

• 命令行方式（Command Line Interface，CLI），需要在控制台输入特定的指令，让计算机完成一些操作。需要记忆一些指令，较为麻烦。

  

4.3 常用的DOS命令

DOS（Disk Operating System，磁盘操作系统）是Microsoft公司在Windows之前推出的一个操作系统，是单用户、单任务（即只能执行一个任务）的操作系统。现在被Windows系统取代。

对于Java初学者，学习一些DOS命令，会非常有帮助。

进入DOS操作窗口：

• 按下Windows+R键盘，打开运行窗口，输入cmd回车，进入到DOS的操作窗口。

  

常用指令：

• 操作1：进入和回退

• 操作2：增、删

• 操作3：其它

5. 计算机编程语言

5.1 计算机语言是什么

• 语言：是人与人之间用于沟通的一种方式。例如：中国人与中国人用普通话沟通。而中国人要和英国人交流，可以使用英语或普通话。

• 计算机编程语言，就是人与计算机交流的方式。人们可以使用编程语言对计算机下达命令，让计算机完成人们需要的功能。

• 计算机语言有很多种。如：C 、C++、Java、Go、JavaScript、Python，Scala等。

体会：语言 = 语法 + 逻辑

5.2 计算机语言简史

• 第一代：机器语言（相当于人类的石器时代）

  • 1946年2月14日，世界上第一台计算机ENAC诞生，使用的是最原始的穿孔卡片。这种卡片上使用的是用二进制代码表示的语言，与人类语言差别极大，这种语言就称为机器语言。比如一段典型的机器码：

    1 2 3

    1. 0000,0000,000000010000 代表 LOAD A, 16 2. 0000,0001,000000000001 代表 LOAD B, 1 3. 0001,0001,000000010000 代表 STORE B, 16

  • 这种语言本质上是计算机能识别的唯一语言，人类很难理解。可以大胆想象”此时的程序员99.9%都是异类！“

    

• 第二代：汇编语言（相当于人类的青铜&铁器时代）

  • 使用英文缩写的助记符来表示基本的操作，这些助记符构成了汇编语言的基础。比如：LOAD、MOVE等，使人更容易使用。因此，汇编语言也称为符号语言。

  • 优点：能编写高效率的程序

  • 缺点：汇编语言是面向机器的，不同计算机机型特点不同，因此会有不同的汇编语言，彼此之间不能通用。程序不易移植，较难调试。

    

  • 比起机器语言，汇编大大进步了，是机器语言向更高级的语言进化的桥梁。目前仍然应用于工业电子编程领域、软件的加密解密、计算机病毒分析等。

• 第三代：高级语言（相当于人类的信息时代）

  • 高级语言发展于20世纪50年代中叶到70年代，是一种接近于人们使用习惯的程序设计语言。它允许程序员使用接近日常英语的指令来编写程序，程序中的符号和算式也与日常用的数学式子差不多，接近于自然语言和数学语言，容易为人们掌握。比如：

    

  • 高级语言独立于机器，有一定的通用性；计算机不能直接识别和执行用高级语言编写的程序，需要使用编译器或者解释器，转换为机器语言才能被识别和执行。

此外，高级语言按照程序设计方法的不同，又分为：面向过程的语言、面向对象的语言。

• C、Pascal、Fortran面向过程的语言
• C++面向过程/面向对象
• Java跨平台的纯面向对象的语言
• C#、Python、JavaScript、Scala…

目前以及可预见的将来，计算机语言仍然处于“第三代高级语言”阶段。但是不管是什么语言，最后都要向机器语言靠近，因为CPU只认识0和1。

5.3 计算机语言排行榜

TIOBE （https://www.tiobe.com/tiobe-index/）是一个流行编程语言排行，每月更新。排名权重基于世界范围内 工程师数量，Google、Bing、Yahoo! 、Wikipedia、Amazon、Youtube和百度这些主流的搜索引擎，也将作为排名权重的参考指标。

计算机语言走势

5.4 编程语言，该学哪个？

网传的编程语言鄙视链：

• C语言：万物之源

• 诞生于1972年，由AT&T公司旗下贝尔实验室创建完成，用于构建Unix操作系统。

• 偏向计算机底层操作（操作系统、网络、硬件驱动等）。

• 优势：几乎所有现代编程语言都脱胎于C

• 劣势：相当陡的学习曲线；不支持面向对象编程

• C++语言：难学的语言

• 诞生于1983年，作为C语言的增强方案、升级版本。C++是C语言的超集，C语言的大部分知识也适用于C++。
• 用途：windows 或 MacOS UI、office全家桶、主流的浏览器、Oracle、MySQL、著名的游戏引擎（如星际争霸、魔兽世界）等
• 优势：很多公司都用 C++ 开发核心架构，如 Google、腾讯、百度、阿里云等；面向对象性
• 劣势：体系极为庞大，这是世界目前来说最复杂也是最难的编程语言。

• C#语言：背靠大树的语言

• 诞生于2000年，一款强大而灵活的编程语言。靠着微软这棵大树，是多年来windows平台的一门主流编程语言。
• 用途：windows桌面应用开发、Windows Azure、游戏开发

• PHP语言：最好的语言？

• 诞生于1994年，一款服务器端脚本语言。最初表示个人主页（Personal Home Page）
• PHP语法和C类似，有很多的模板和框架，简单易懂，也许你可以在短短几天做出web app。它主要用于web端，快速建站网络开发
• 劣势：学习门槛太低；其代码运行速度低于大部分编程语言党争对手

• Python：易学的语言

• 诞生于1991年，一种面向对象的语言，虽然运行效率不高，但是开发效率非常高。
• Python被称为胶水语言，哪里都可以用。

• JavaScript语言：前端为王

• 诞生于1995年，网景公司开发完成。
• JavaScript是JavaScript 是目前所有主流浏览器上唯一支持的脚本语言。在前端开发中，占有不可替代的地位。

• Java语言：需求旺盛

• 创建于1995年，Java是一种面向对象、基于类的编程语言。
• Java可能是目前运用最广的项目语言。代码稳定性超过 C 和 C++，生产力远超 C 和 C++。有 JVM 在，可以轻松地跨平台。
• 具有强大的开源开发工具，大量的开源共享库。
• Java拥有世界上数量最多的程序员，最不缺人。

• Go语言：夹缝中生存

• Go 语言现在很受关注，它是取代 C 和 C++ 的另一门有潜力的语言。
  • C 语言太原始了，C++ 太复杂了，Java 太高级了，所以 Go 语言就在这个夹缝中出现了。
• Go语言已成为云计算领域事实上的标准语言，尤其是在 Docker/Kubernetes 等项目中。
• Go 语言语法特别简单，你有了 C 和 C++ 的基础，学习 Go 的学习成本基本为零。
• Go社区从Java社区移植了各种优秀的框架或库。

总结：

• 程序设计语言有很多种，每种语言都是为了实现某个特定的目的而发明的。
• 没有“最好”的语言，只有在特定场景下相对来说，最适合的语言而已。
• 如果你掌握了一种编程语言，也会更容易上手其它的编程语言。关键是学习如何使用程序设计方法来解决问题。这也是本套课程的主旨。
• Talk is cheap，Show me the code。

6. Java语言概述

6.1 Java概述

• 是SUN(Stanford University Network，斯坦福大学网络公司 ) 1995年推出的一门高级编程语言。

• 是一种面向Internet的编程语言。Java一开始富有吸引力是因为Java程序可以在Web浏览器中运行。这些Java程序被称为Java小程序（applet），内嵌在HTML代码中。

• 伴随着互联网的迅猛发展，以及Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言。

6.2 Java语言简史

起步阶段：

1991年，Sun公司的工程师小组想要设计一种语言，应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些设备的处理能力和内存都很有限，并且不同的厂商会选择不同的中央处理器(CPU)，因此这种语言的关键是代码短小、紧凑且与平台无关（即不能与任何特定的体系结构捆绑在一起）。

Gosling团队率先创造了这个语言，并命名为“Oak“（起名的原因是因为他非常喜欢自己办公室外的橡树)。后因智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。

随着20世纪90年代互联网的发展，Sun公司发现该语言在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。（Java是印度尼西亚爪哇岛的英文名称，因盛产咖啡而闻名。）

发展阶段：

6.3 Java之父

• 詹姆斯·高斯林(James Gosling)先生以“Java 技术之父”而闻名于世。他是Java 技术的创始人，他亲手设计了Java语言，并开发了Java编译器和Java虚拟机，使Java成为了世界上最流行的开发语言。
• James Gosling于1984 年加入Sun公司，并一直服务于Sun公司，直至2010年前后，Sun被Oracle并购而加入Oracle，担任客户端软件集团的首席技术官; 2010年4月从Oracle离职。

6.4 公司八卦

• SUN 与 Oracle

SUN是一家极具创新能力的公司，2001年 “9.11”以前，SUN公司市值超过1000亿美元。 但是没能利用Java构建一个强有力、可变现的生态系统，没打好Java这张牌。此后，互联网泡沫破裂，硬件需求大幅减少，它的市值在一个月之内跌幅超过90%。SUN公司的成长用了20年，而衰落只用了1年！

• Oracle 与 Google

Google和Oracle的侵权事件：

2010 年 8 月，Oracle 起诉 Google 的 Android 系统侵权，要求赔偿 26 亿美元。

• Oracle认为Google的代码中使用了Java的37个API，并且认为Google是故意为之，因为这样做的好处是可以让更多的Java程序员更容易接受Android的代码。
• Oracle认为Android 中有9行代码直接抄袭了Java的实现。这9行牛气哄哄的代码都出自一人之手，他就是Java 大牛——Joshua Bloch。

2018 年 3 月，美国联邦巡回上诉法院裁决，谷歌侵犯了甲骨文的版权，支付高达88亿美元的赔偿金。

2021 年 4 月，美国最高法院给出了最终裁决：谷歌胜诉，其代码属于“合理使用”的范畴。为期十多年的软件行业“第一版权案”落幕。

1
2
3
4
5
6
7
8
9
10

//Code In OpenJDK / Android ：
1. private static void rangeCheck(int arrayLen, int fromIndex, int toIndex) {
2.    if (fromIndex > toIndex)
3.        throw new IllegalArgumentException("fromIndex(" + fromIndex +
4.                   ") > toIndex(" + toIndex+")");
5.    if (fromIndex < 0)
6.        throw new ArrayIndexOutOfBoundsException(fromIndex);
7.    if (toIndex > arrayLen)
8.        throw new ArrayIndexOutOfBoundsException(toIndex);
9. }

6.5 Java技术体系平台

• Java SE(Java Standard Edition)标准版
  • 支持面向桌面级应用（如Windows下的应用程序）的Java平台，即定位个人计算机的应用开发。
  • 包括用户界面接口AWT及Swing，网络功能与国际化、图像处理能力以及输入输出支持等。
  • 此版本以前称为J2SE
• Java EE(Java Enterprise Edition)企业版
  • 为开发企业环境下的应用程序提供的一套解决方案，即定位在服务器端的Web应用开发。
  • JavaEE是JavaSE的扩展，增加了用于服务器开发的类库。如：Servlet能够延伸服务器的功能，通过请求-响应的模式来处理客户端的请求；JSP是一种可以将Java程序代码内嵌在网页内的技术。
  • 版本以前称为J2EE
• Java ME(Java Micro Edition)小型版
  • 支持Java程序运行在移动终端（手机、机顶盒）上的平台，即定位在消费性电子产品的应用开发
  • JavaME是JavaSE的内伸，精简了JavaSE 的核心类库，同时也提供自己的扩展类。增加了适合微小装置的类库：javax.microedition.io.*等。
  • 此版本以前称为J2ME

注意：

Android开发不等同于Java ME的开发

7. Java开发环境搭建（掌握）

7.1 什么是JDK、JRE

• JDK (Java Development Kit)：是Java程序开发工具包，包含JRE 和开发人员使用的工具。
• *JRE * (Java Runtime Environment) ：是Java程序的运行时环境，包含JVM 和运行时所需要的核心类库。

如下是Java 8.0 Platform：

小结：

JDK = JRE + 开发工具集（例如Javac编译工具等）

JRE = JVM + Java SE标准类库

7.2 JDK版本选择

• 自Java 8版本发布以来，其后的每次更新，都会有小伙伴高呼：Java8 YYDS！
• 论坛的声音：“你发任你发，我用Java 8！”

数据说话1：

JRebel 于2022年4月前后发布了《2022 年Java生态系统状况报告》，报告中提到使用Java11 的占比最多，Java 8 紧随其后，如下图。而此前2020年的报告显示，Java8占比达到了84.48%。

我的分析：

G1是最受欢迎的GC算法。Java 11及更高版本的G1收集器是默认的GC，而Java 8中并不是。出于对G1的喜爱，很多开发者才会选择抛弃Java 8。

数据说话2：

此外，某美国软件开发商在对近千名专业的Java开发者调研后，发布的《2022年Java开发者生产力报告》称：八年前发布的Java 8依然是Java中应用最广泛的版本，占比 37%，其次是 Java 11，占比29% 。

高斯林说话：

Spring框架说话：

在Java 17正式发布之前，Java开发框架Spring率先在官博宣布，Spring Framework 6和Spring Boot 3计划在2022年第四季度实现总体可用性的高端基线：

• Java 17+(来自 Spring Framework 5.3.x 线中的 Java 8-17)

• Jakarta EE 9+（来自Spring框架5.3.x 线中的 Java EE 7-8）

Spring 官方说明：https://spring.io/blog/2022/01/20/spring-boot-3-0-0-m1-is-now-available

意味着：springboot3.0 是需要用java17和spring6.0为基础建设。如果从企业选型最新springboot3.0作为架构来说，它搭配jdk17肯定是标配了。

7.3 JDK的下载

• 下载网址（Oracle公司官网）：
• 下载步骤：如图所示，在官网底部选择Developers开发者

（1）在Developers页面中间的技术分类部分，选择Java，单击进入，如图所示：

（2）这里展示的是最新Java版本，例如Java17。单击Download Java，然后选择具体的版本下载。

（3）选择Download Java按钮后

（4）如果想安装Java8 可以选择如下位置：

（5）选择Accept License Agreement，

（6）注册或登录后下载：

（7）如果需要安装其它版本，可以选择Java archive：

接着进行选择下载即可：

7.4 JDK的安装

• 安装说明
  • 傻瓜式安装，下一步即可。
  • 建议：安装路径不要有中文或者空格等特殊符号。
  • 本套课程会同时安装JDK8 和 JDK17，并以JDK17为默认版本进行讲解。

• 安装步骤：

（1）双击jdk-17_windows-x64_bin.exe文件，并单击下一步，如图所示：

（2）修改安装路径，单击更改，如图所示：

（3）将安装路径修改为D:\develop_tools\jdk\jdk-17.0.2\，并单击下一步，如图所示：

（4）稍后几秒，安装完成，如图所示：

7.5 配置path环境变量

7.5.1 理解path环境变量

什么是path环境变量？

答：window操作系统执行命令时，所要搜寻的路径。

为什么配置path？

答：希望在命令行使用javac.exe等工具时，任意目录下都可以找到这个工具所在的目录。

以JDK为例演示

我们在C:\Users\songhk目录下使用javac命令，结果如下：

我们在JDK的安装目录的bin目录下使用javac命令，结果如下：

我们不可能每次使用java.exe，javac.exe等工具的时候都进入到JDK的安装目录下，太麻烦了。这时就需要配置path环境变量。

7.5.2 JDK8配置方案1：只配置path

• 步骤：

（1）打开桌面上的计算机，进入后在左侧找到此电脑，单击鼠标右键，选择属性，如图所示：

（2）选择高级系统设置，如图所示：

（3）在高级选项卡，单击环境变量，如图所示：

（4）在系统变量中，选中Path 环境变量，双击或者点击编辑 ,如图所示：

（5）点击新建，填入D:\develop_tools\jdk\jdk1.8.0_271\bin ，并将此值上移到变量列表的首位。如图所示：

• 编辑模式1：

• 编辑模式2：（注意，结尾需要有英文模式下的;）

（6）环境变量配置完成，重新开启DOS命令行，在任意目录下输入javac 或java命令或java -version，运行成功。

7.5.3 JDK8配置方案2：配置JAVA_HOME+path（推荐）

• 步骤：

（1）打开桌面上的计算机，进入后在左侧找到计算机，单击鼠标右键，选择属性，如图所示：

（2）选择高级系统设置，如图所示：

（3）在高级选项卡，单击环境变量，如图所示：

（4）在系统变量中，单击新建 ，创建新的环境变量，如图所示：

（5）变量名输入JAVA_HOME，变量值输入 D:\develop_tools\jdk\jdk1.8.0_271 ，单击确定，如图所示：

（6）选中Path 环境变量，双击或者点击编辑 ，如图所示：

（7）在变量值的最前面，键入%JAVA_HOME%\bin。如图所示：

注意：强烈建议将%JAVA_HOME%\bin声明在path环境变量中所有变量的最前面！

（8）环境变量配置完成，重启DOS命令行，在任意目录下输入javac 或java命令或java -version，运行成功。

我想说：

有的书籍、论坛、视频上还提到配置classpath，用于指名class文件识别的路径。其实是没必要的，反而建议大家如果配置了classpath环境变量，要删除。对于初学者，反而不友好。

小结如下：

7.5.4 JDK17配置方案：自动配置

不管大家有没有提前安装JDK8或其它版本JDK，在我们安装完JDK17之后，理应按JDK8的方式配置path环境变量。但是，我们发现在安装完JDK17以后，配置环境变量之前，执行CMD指令：

竟然成功了！而且是17.0.2版本。因为JDK17在安装之后，自动进行了环境变量的配置。如下：

这里建议，将JDK17安装的路径，设置为JAVA_HOME，并将%JAVA_HOME%\bin上移到首位。

思考：如果你仍然希望在JDK8下开发Java程序？如何做呢？

8. 开发体验：HelloWorld（掌握）

JDK安装完毕，我们就可以开发第一个Java程序了，习惯性的称为：HelloWorld。

8.1 开发步骤

Java程序开发三步骤：编写、编译、运行。

• 将 Java 代码编写到扩展名为 .java 的源文件中
• 通过 javac.exe 命令对该 java 文件进行编译，生成一个或多个字节码文件
• 通过 java.exe 命令对生成的 class 文件进行运行

8.2 编写

（1）在D:\JavaSE\chapter01 目录下新建文本文件，完整的文件名修改为HelloWorld.java，其中文件名为HelloWorld，后缀名必须为.java。

（2）用记事本或editplus等文本编辑器打开（虽然记事本也可以，但是没有关键字颜色标识，不利于初学者学习）

（3）在文件中输入如下代码，并且保存：

1
2
3
4
5

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

• 友情提示1：每个字母和符号必须与示例代码一模一样，包括大小写在内。

• 友情提示2：

或

第一个HelloWord 源程序就编写完成了，但是这个文件是程序员编写的，JVM是看不懂的，也就不能运行，因此我们必须将编写好的Java源文件 编译成JVM可以看懂的字节码文件 ，也就是.class文件。

8.3 编译

在DOS命令行中，进入D:\JavaSE\chapter01目录，使用javac 命令进行编译。

使用文件资源管理器打开D:\JavaSE\chapter01目录，然后在地址栏输入cmd。

命令：

1

javac Java源文件名.后缀名java

举例：

1

javac HelloWorld.java

编译成功后，命令行没有任何提示。打开D:\JavaSE\chapter01目录，发现产生了一个新的文件 HelloChina.class，该文件就是编译后的文件，是Java的可运行文件，称为字节码文件，有了字节码文件，就可以运行程序了。

8.4 运行

在DOS命令行中，在字节码文件目录下，使用java 命令进行运行。

命令：

1

java 主类名字

主类是指包含main方法的类，main方法是Java程序的入口：

1
2
3

public static void main(String[] args){
    
}

举例：

1

java HelloChina

错误演示：

java HelloChina.class

9. Java开发工具

9.1 都有哪些开发Java的工具

• 级别一：文本开发工具

• 级别二：集成开发环境（Integrated Development Environment，IDE）

把代码编写，编译，执行，调试等多种功能综合到一起的开发工具。

9.2 如何选择

前期我们先使用文本开发工具，培养代码感，利于公司笔、面试。

后期我们使用IDE，提供更强大的功能支持。

10. HelloWorld案例常见错误

10.1 拼写问题

• 单词拼写问题
  • 正确：class 错误：Class
  • 正确：String 错误：string
  • 正确：System 错误：system
  • 正确：main 错误：mian
• Java语言是一门严格区分大小写的语言
• 标点符号使用问题
  • 不能用中文符号，英文半角的标点符号（正确）
  • 括号问题，成对出现

10.2 编译、运行路径问题

举例1：

• 源文件名不存在或者写错
• 当前路径错误
• 后缀名隐藏问题

举例2：

• 类文件名写错，尤其文件名与类名不一致时，要小心
• 类文件不在当前路径下，或者不在classpath指定路径下

10.3 语法问题

举例1：

声明为public的类应与文件名一致，否知编译失败。

举例2：

编译失败，注意错误出现的行数，再到源代码中指定位置改错

10.4 字符编码问题

当cmd命令行窗口的字符编码与.java源文件的字符编码不一致，如何解决？

解决方案一：

• 在Notepad++等编辑器中，修改源文件的字符编码：

• 在EditPlus中可以将Java源文件另存为ANSI编码方式（中文操作系统下即为GBK字符集）

解决方案二：

在使用javac命令式，可以指定源文件的字符编码

1

javac -encoding utf-8 Review01.java

10.5 建议

• 注意缩进!

  • 一定要有缩进。缩进就像人得体的衣着一样！

  • 只要遇到{}就缩进，缩进的快捷键tab键。

• 必要的空格

  • 变量类型、变量、赋值符号、变量值之间填充相应空格，更美观。比如： int num = 10;

11. HelloWorld小结

11.1 Java程序的结构与格式

结构：

1
2
3
4
5

类{
    方法{
        语句;
    }
}

格式：

（1）每一级缩进一个Tab键

（2）{}的左半部分在行尾，右半部分单独一行，与和它成对的”{“的行首对齐

11.2 Java程序的入口

Java程序的入口是main方法

1
2
3

public static void main(String[] args){
    
}

11.3 两种常见的输出语句

• 换行输出语句：输出内容，完毕后进行换行，格式如下：

  1	System.out.println(输出内容);

• 直接输出语句：输出内容，完毕后不做任何处理，格式如下

  1	System.out.print(输出内容);

注意事项：

​ 换行输出语句，括号内可以什么都不写，只做换行处理

​ 直接输出语句，括号内什么都不写的话，编译报错

11.4 源文件名与类名

（1）源文件名是否必须与类名一致？public呢？

1
2
3
4
5

如果这个类不是public，那么源文件名可以和类名不一致。但是不便于代码维护。

如果这个类是public，那么要求源文件名必须与类名一致。否则编译报错。

我们建议大家，不管是否是public，都与源文件名保持一致，而且一个源文件尽量只写一个类，目的是为了好维护。

（2）一个源文件中是否可以有多个类？public呢？

1
2
3

一个源文件中可以有多个类，编译后会生成多个.class字节码文件。

但是一个源文件只能有一个public的类。

12. 注释(comment)

• 什么是注释？

  • 源文件中用于解释、说明程序的文字就是注释。

• 注释是一个程序员必须要具有的良好编程习惯。实际开发中，程序员可以先将自己的思想通过注释整理出来，再用代码去体现。

  程序员最讨厌两件事：

  一件是自己写代码被要求加注释

  另一件是接手别人代码，发现没有注释

• 不加注释的危害

  

• Java中的注释类型：

  • 单行注释

    1

    //注释文字

  • 多行注释

    1 2 3 4 5

    /* 注释文字1 注释文字2 注释文字3 */

  • 文档注释 (Java特有)

    1 2 3 4

    /** @author 指定java程序的作者 @version 指定源文件的版本 */

• 注释的作用

  • 它提升了程序的可阅读性。（不加注释的危害性，见图。）
  • 调试程序的重要方法。

• 具体使用1：单行注释、多行注释

  • 对于单行和多行注释，被注释的文字，不会出现在字节码文件中，进而不会被JVM（java虚拟机）解释执行。

  • 多行注释里面不允许有多行注释嵌套。

  • 一个段子

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

    A：嘿 //是什么意思啊？ B：嘿. A：呃 我问你//是什么意思？ B：问吧. A：我刚才不是问了么？ B：啊？ A：你再看看记录... B：看完了. A：......所以//是啥？ B：所以什么？ A：你存心耍我呢吧？ B：没有啊 你想问什么？ …… 不断循环之后，A一气之下和B绝交，自己苦学程序。 N年之后，A终于修成正果，回想起B，又把聊天记录翻出来看，这时，他突然发现B没有耍他…… 而他自己也不知道当年他问B的究竟是什么问题……

• 具体使用2：文档注释（Java特有）

  • 文档注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。

  • 操作方式。比如：

    1	javadoc -d mydoc -author -version HelloWorld.java

案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

//单行注释
/*
多行注释
*/
/**
文档注释演示。这是我的第一个Java程序！^_^
@author songhk
@version 1.0
*/
public class HelloWorld{
    
	/**
	Java程序的入口
	@param args main方法的命令参数
	*/
    public static void main(String[] args){
        System.out.println("hello");
    }
}

13. Java API文档

• API （Application Programming Interface，应用程序编程接口）是 Java 提供的基本编程接口。
• Java语言提供了大量的基础类，因此 Oracle 也为这些基础类提供了相应的说明文档，用于告诉开发者如何使用这些类，以及这些类里包含的方法。大多数Java书籍中的类的介绍都要参照它来完成，它是编程者经常查阅的资料。
• Java API文档，即为JDK使用说明书、帮助文档。类似于：

• 下载API文档：
  • 在线看：https://docs.oracle.com/en/java/javase/17/docs/api/index.html
  • 离线下载：https://www.oracle.com/java/technologies/javase-jdk17-doc-downloads.html

14. Java核心机制：JVM

14.1 Java语言的优缺点

Java确实是从C语言和C++语言继承了许多成份，甚至可以将Java看成是类C语言发展和衍生的产物。“青出于蓝，而胜于蓝”。

14.1.1 优点

• 跨平台性：这是Java的核心优势。Java在最初设计时就很注重移植和跨平台性。比如：Java的int永远都是32位。不像C++可能是16，32，可能是根据编译器厂商规定的变化。
• 通过Java语言编写的应用程序在不同的系统平台上都可以运行。“Write once , Run Anywhere”。
• 原理：只要在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机 (JVM ，Java Virtual Machine) 即可。由JVM来负责Java程序在该系统中的运行。

• 面向对象性：

  面向对象是一种程序设计技术，非常适合大型软件的设计和开发。面向对象编程支持封装、继承、多态等特性，让程序更好达到高内聚，低耦合的标准。

• 健壮性：吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制。

• 安全性高：

  Java适合于网络/分布式环境，需要提供一个安全机制以防恶意代码的攻击。如：安全防范机制（ClassLoader类加载器），可以分配不同的命名空间以防替代本地的同名类、字节代码检查。

• 简单性：

  Java就是C++语法的简化版，我们也可以将Java称之为“C++--”。比如：头文件，指针运算，结构，联合，操作符重载，虚基类等。

• 高性能：

  • Java最初发展阶段，总是被人诟病“性能低”；客观上，高级语言运行效率总是低于低级语言的，这个无法避免。Java语言本身发展中通过虚拟机的优化提升了几十倍运行效率。比如，通过JIT(JUST IN TIME)即时编译技术提高运行效率。

  • Java低性能的短腿，已经被完全解决了。业界发展上，我们也看到很多C++应用转到Java开发，很多C++程序员转型为Java程序员。

14.1.2 缺点

• 语法过于复杂、严谨，对程序员的约束比较多，与python、php等相比入门较难。但是一旦学会了，就业岗位需求量大，而且薪资待遇节节攀升。
• 一般适用于大型网站开发，整个架构会比较重，对于初创公司开发和维护人员的成本比较高（即薪资高），选择用Java语言开发网站或应用系统的需要一定的经济实力。
• 并非适用于所有领域。比如，Objective C、Swift在iOS设备上就有着无可取代的地位。浏览器中的处理几乎完全由JavaScript掌控。Windows程序通常都用C++或C#编写。Java在服务器端编程和跨平台客户端应用领域则很有优势。

14.2 JVM功能说明

JVM（Java Virtual Machine ，Java虚拟机）：是一个虚拟的计算机，是Java程序的运行环境。JVM具有指令集并使用不同的存储区域，负责执行指令，管理数据、内存、寄存器。

14.2.1 功能1：实现Java程序的跨平台性

我们编写的Java代码，都运行在JVM 之上。正是因为有了JVM，才使得Java程序具备了跨平台性。

使用JVM前后对比：

14.2.2 功能2：自动内存管理(内存分配、内存回收)

• Java程序在运行过程中，涉及到运算的数据的分配、存储等都由JVM来完成
• Java消除了程序员回收无用内存空间的职责。提供了一种系统级线程跟踪存储空间的分配情况，在内存空间达到相应阈值时，检查并释放可被释放的存储器空间。
• GC的自动回收，提高了内存空间的利用效率，也提高了编程人员的效率，很大程度上减少了因为没有释放空间而导致的内存泄漏。

面试题：

Java程序还会出现内存溢出和内存泄漏问题吗？ Yes!

15. 章节案例

案例1：个人信息输出

1
2
3
4
5
6
7
8

class Exercise1{
	public static void main(String[] args){
		System.out.println("姓名：康师傅");
		System.out.println();//换行操作
		System.out.println("性别：男");
		System.out.println("家庭住址：北京程序员聚集地：回龙观");
	}
}

案例2：输出：心形

结合\n(换行)，\t(制表符)，空格等在控制台打印出如下图所示的效果。

方式一：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//方式一：
class Exercise2{
	public static void main(String[] args){
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("*");
		System.out.print("\t");
		//System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("I love java");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");
		
		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("    ");
		System.out.print("*");

	}

}

方式二：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Exercise3{
	public static void main(String[] args){
		
		System.out.print("\t"+"*"+"\t\t\t\t\t\t\t\t\t\t\t\t"+"*"+"\t"+"\n");
		System.out.print("*"+"\t\t"+"*"+"\t\t\t\t"+"I love Java"+"\t\t\t\t"+"*"+"\t\t\t"+"*"+"\n");
		System.out.print("\t"+"*"+"\t\t\t\t\t\t\t\t\t\t\t\t"+"*"+"\t"+"\n");
		System.out.print("\t\t"+"*"+"\t\t\t\t\t\t\t\t\t\t"+"*"+"\t\t"+"\n");
		System.out.print("\t\t\t"+"*"+"\t\t\t\t\t\t\t\t"+"*"+"\t"+"\n");
		System.out.print("\t\t\t\t"+"*"+"\t\t\t\t\t\t"+"*"+""+"\t"+"\n");
		System.out.print("\t\t\t\t\t"+"*"+"\t\t\t\t"+"*"+""+"\t\t"+"\n");
		System.out.print("\t\t\t\t\t\t"+"*"+"\t\t"+"*"+""+"\t\t"+"\n");
		System.out.print("\t\t\t\t\t\t\t"+"*"+"\n");


	}

}

第02章_变量与运算符

本章专题与脉络

1. 关键字（keyword）

• 定义：被Java语言赋予了特殊含义，用做专门用途的字符串（或单词）
  • HelloWorld案例中，出现的关键字有 class、public 、 static 、 void 等，这些单词已经被Java定义好了。
• 特点：全部关键字都是小写字母。
• 关键字比较多，不需要死记硬背，学到哪里记到哪里即可。
• 官方地址： https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

说明：

1. 关键字一共50个，其中const和goto是保留字(reserved word)。
2. true，false，null不在其中，它们看起来像关键字，其实是字面量，表示特殊的布尔值和空值。

2. 标识符( identifier)

Java中变量、方法、类等要素命名时使用的字符序列，称为标识符。

技巧：凡是自己可以起名字的地方都叫标识符。(自己定义类名/自己定义变量名/自己定义方法名)

标识符的命名规则（必须遵守的硬性规定）：

1
2
3
4
5

> 由26个英文字母大小写，0-9 ，_或 $ 组成  
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。

练习：miles、Test、a++、 –a、4#R、$4、 #44、apps、class、public、int、x、y、radius

标识符的命名规范（建议遵守的软性要求，否则工作时容易被鄙视）:

1
2
3
4
5
6
7
8
9
10
11

> 包名：多单词组成时所有字母都小写：xxxyyyzzz。
  例如：java.lang、com.atguigu.bean
  
> 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
  例如：HelloWorld，String，System等
  
> 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
  例如：age,name,bookName,main,binarySearch,getName
  
> 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
  例如：MAX_VALUE,PI,DEFAULT_CAPACITY

注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

更多细节详见《代码整洁之道_关于标识符.txt》《阿里巴巴Java开发手册-1.7.1-黄山版》

3. 变量

3.1 为什么需要变量

一花一世界，如果把一个程序看做一个世界或一个社会的话，那么变量就是程序世界的花花草草、万事万物。即，变量是程序中不可或缺的组成单位，最基本的存储单元。

3.2 初识变量

• 变量的概念：

  • 内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化

  • 变量的构成包含三个要素：数据类型、变量名、存储的值

  • Java中变量声明的格式：数据类型 变量名 = 变量值

    

• 变量的作用：用于在内存中保存数据。

• 使用变量注意：

  • Java中每个变量必须先声明，后使用。 ①先声明后赋值 int age； age=10； ②声明同时赋值 int age=25；
  • 使用变量名来访问这块区域的数据。
  • 变量的作用域：其定义所在的一对{ }内。
  • 变量只有在其作用域内才有效。出了作用域，变量不可以再被调用。
  • 同一个作用域内，不能定义重名的变量。(不同域可以同名)

3.3 Java中变量的数据类型

Java中变量的数据类型分为两大类：

• 基本数据类型：包括 整数类型、浮点数类型、字符类型、布尔类型。

• 引用数据类型：包括数组、 类、接口、枚举、注解、记录。

  

3.4 变量的使用

3.4.1 步骤1：变量的声明

1

格式：数据类型  变量名;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

//例如：
//存储一个整数类型的年龄
int age; 

//存储一个小数类型的体重
double weight;

//存储一个单字符类型的性别 
char gender;

//存储一个布尔类型的婚姻状态
boolean marry;

//存储一个字符串类型的姓名
String name;

//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。

注意：变量的数据类型可以是基本数据类型，也可以是引用数据类型。

3.4.2 步骤2：变量的赋值

给变量赋值，就是把“值”存到该变量代表的内存空间中。同时，给变量赋的值类型必须与变量声明的类型一致或兼容。

变量赋值的语法格式：

1

变量名 = 值;

举例1：可以使用合适类型的常量值给已经声明的变量赋值

1
2
3

age = 18;
weight = 109;
gender = '女';

举例2：可以使用其他变量或者表达式给变量赋值

1
2
3
4
5
6

int m = 1;
int n = m;
        
int x = 1;
int y = 2;
int z = 2 * x + y;

3：变量可以反复赋值

1
2
3
4
5
6
7

//先声明，后初始化
char gender;
gender = '女';

//给变量重新赋值，修改gender变量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男

举例4：也可以将变量的声明和赋值一并执行

1
2

boolean isBeauty = true;
String name = "迪丽热巴";

内存结构如图：

4. 基本数据类型介绍

4.1 整数类型：byte、short、int(默认)、long

• Java各整数类型有固定的表数范围和字段长度，不受具体操作系统的影响，以保证Java程序的可移植性。

• 定义long类型的变量，赋值时需要以”l“或”L“作为后缀。 – 例如：long age=12l
• Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long。
• Java的整型常量默认为 int 型。

4.1.1 补充：计算机存储单位

• 字节（Byte）：是计算机用于计量存储容量的基本单位，一个字节等于8 bit。

• 位（bit）：是数据存储的最小单位。二进制数系统中，每个0或1就是一个位，叫做bit（比特），其中8 bit 就称为一个字节(Byte)。

• 转换关系：

  • 8 bit = 1 Byte
  • 1024 Byte = 1 KB
  • 1024 KB = 1 MB
  • 1024 MB = 1 GB
  • 1024 GB = 1 TB

4.2 浮点类型：float、double(默认)

• 与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。

• 浮点型常量有两种表示形式：
  • 十进制数形式。如：5.12 512.0f .512 (必须有小数点）
  • 科学计数法形式。如：5.12e2 512E2 100E-2
• float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。
• double(通常采用此类型)：双精度，精度是float的两倍。
• 定义float类型的变量，赋值时需要以”f“或”F“作为后缀。 – 例如：float age=12f
• Java 的浮点型常量默认为double型。

4.2.1 关于浮点型精度的说明

• 并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。

• 浮点类型float、double的数据不适合在不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度，需要使用BigDecimal类。(算法题经常出现)

• 测试用例：

1
2
3
4
5
6
7
8
9

//测试1：（解释见章末企业真题：为什么0.1 + 0.2不等于0.3）
System.out.println(0.1 + 0.2);//0.30000000000000004

//测试2：
float ff1 = 123123123f;
float ff2 = ff1 + 1;
System.out.println(ff1);
System.out.println(ff2);
System.out.println(ff1 == ff2);  #输出是True  因为精度太差所以竟然是相等的！！！！！

4.2.2 应用举例

案例1：定义圆周率并赋值为3.14，现有3个圆的半径分别为1.2、2.5、6，求它们的面积。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/**
 * @author 尚硅谷-宋红康
 * @create 12:36
 */
public class Exercise1 {
    public static void main(String[] args) {
        double PI = 3.14; //圆周率

        double radius1 = 1.2;
        double radius2 = 2.5;
        int radius3 = 6;

        System.out.println("第1个圆的面积：" + PI * radius1 * radius1);
        System.out.println("第2个圆的面积：" + PI * radius2 * radius2);
        System.out.println("第3个圆的面积：" + PI * radius3 * radius3);
    }
}

案例2：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。
它需要一个程序将华氏温度（80度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。

1

℃ = (℉ - 32) / 1.8

1
2
3
4
5
6
7
8
9
10
11

/**
 * @author 尚硅谷-宋红康
 * @create 12:51
 */
public class Exercise2 {
    public static void main(String[] args) {
        double hua = 80;
        double she = (hua-32)/1.8;
        System.out.println("华氏度" + hua+"℉转为摄氏度是" +she+"℃");
    }
}

4.3 字符类型：char

• char 型数据用来表示通常意义上“字符”（占2字节）

• Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。

• 字符型变量的三种表现形式：

  • 形式1：使用单引号(‘ ‘)括起来的单个字符。

    例如：char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;

  • 形式2：直接使用 Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。

    例如：\u0023 表示 ‘#’。

  • 形式3：Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。

    例如：char c3 = ‘\n’; // ‘\n’表示换行符

  转义字符	说明	Unicode表示方式
  \n	换行符	\u000a
  \t	制表符	\u0009
  \"	双引号	\u0022
  \'	单引号	\u0027
  \\	反斜线	\u005c
  \b	退格符	\u0008
  \r	回车符	\u000d

• char类型是可以进行运算的。因为它都对应有Unicode码，可以看做是一个数值。

• 举例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class IdentifierTest {
    public static void main(String[] args){
        //形式1 使用单引号(' ')括起来的单个字符
        char bl='a';
        System.out.println(bl);  // a
        char zg='中';
        System.out.println(zg);  // 中

        //形式2 直接使用 `Unicode值`来表示字符型常量：
        char qiguai='\u0036';
        System.out.println(qiguai); // 6


        //形式3 使用`转义字符‘\’`  来将其后的字符转变为特殊字符型常量。
        char c9='\n';
        char c10='\t';
        // hello
        // world
        System.out.println("hello"+c9+"world");
        // hello	world
        System.out.println("hello"+c10+"world");
    }
}

4.4 布尔类型：boolean

• boolean 类型用来判断逻辑条件，一般用于流程控制语句中：

  • if条件控制语句；
  • while循环控制语句；
  • for循环控制语句；
  • do-while循环控制语句；

• boolean类型数据只有两个值：true、false，无其它。

  • 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。
  • 拓展：Java虚拟机中没有任何供boolean值专用的字节码指令，Java语言表达所操作的boolean值，在编译之后都使用java虚拟机中的int数据类型来代替：true用1表示，false用0表示。——《java虚拟机规范 8版》

• 举例：

1
2
3
4
5
6
7

boolean isFlag = true;

if(isFlag){
    //true分支
}else{  
    //false分支
}

经验之谈：

Less is More！建议不要这样写：if ( isFlag = = true )，只有新手才如此。关键也很容易写错成if(isFlag = true)，这样就变成赋值isFlag为true而不是判断！老鸟的写法是if (isFlag)或者if ( !isFlag)。

5. 基本数据类型变量间运算规则

在Java程序中，不同的基本数据类型（只有7种，不包含boolean类型）变量的值经常需要进行相互转换。

转换的方式有两种：①自动类型提升和②强制类型转换。

5.1 自动类型提升

规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型 。

基本数据类型的转换规则如图所示：

（1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时

1
2
3
4
5
6

int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换

//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，显式表示long类型。否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算(自动转换为最大类型)。

1
2
3
4
5

int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double  输出为3.0

（3）当byte,short,char(三个在int之前的不分前后的类型)数据类型的变量进行算术运算时，按照int类型处理。

1
2
3
4
5
6
7
8

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;// byte编译报错，b1 + b2自动升级为int,所以是需要int来接结果!!!!!

char c1 = '0'; // int值为48
char c2 = 'A'; // int值为65
int i = c1 + c2;  //至少需要使用int类型来接收
System.out.println(c1 + c2); //48+65=113

练习：

1
2
3
4
5
6
7
8
9
10
11
12

设 x 为float型变量，y为double型变量，a为int型变量，b为long型变量，c为char型变量，则表达式
x + y * a / x + b / y + c的值类型为：
代码如下：	
    	float x=1.0f;
        double y=2.0;
        int a=1;
        long b=3l;
        char c='a';  // int值为97
        double sum = x + y * a / x + b / y + c;
        System.out.println(x+y*a/x+b/y+c);    //101.5

A. int   B. long  C. double  D. char

5.2 强制类型转换

将3.14 赋值到int 类型变量会发生什么？产生编译失败，肯定无法赋值。

1

int i = 3.14; // 编译报错

想要赋值成功，只有通过强制类型转换，将double 类型强制转换成int 类型才能赋值。

规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。

自动类型提升是Java自动执行的，而强制类型转换是自动类型提升的逆运算，需要我们自己手动执行。

转换格式：

1

数据类型1 变量名 = (数据类型1)被强转数据值;  //()中的数据类型必须<=变量值的数据类型

（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。

1
2
3
4
5
6
7

int i = (int)3.14;//损失精度  输出为3 截断了后面的0.14

double d = 1.2;
int num = (int)d;//损失精度  输出为1 截断了后面的0.2

int i = 200;
byte b = (byte)i;//溢出  输出负56 因为原码补码问题导致

（2）当某个值想要提升数据类型时(本身可以通过自动类型提升完成)，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略。

1
2
3
4

int i = 1;
int j = 2;
double bigger = (double)(i/j);  // 0.0
int bigger2=i/j; // 0 可能想要一个double类型 所以使用强制类型转换才可以做到成为0.0

（3）声明变量时，long(可以√省略)，float(不可以×省略)。

1
2
3
4
5
6
7
8
9
10
11
12
13

//记忆方法：  可以看作long定义的时候可能是int(整数型默认)自动类型转换为long   所以可以省略
//           可以看做float定义的时候可能是double(浮点数默认)没办法自动类型转换为double  所有不可以省略

long l1 = 123L;
long l2 = 123;//如何理解呢？ 此时可以看做是int类型的123自动类型提升为long类型

//long l3 = 123123123123; //报错，因为123123123123超出了int的范围。
long l4 = 123123123123L;


//float f1 = 12.3; //报错，因为12.3看做是double，不能自动转换为float类型
float f2 = 12.3F;
float f3 = (float)12.3;

练习：判断是否能通过编译

1
2
3
4
5
6
7
8
9
10
11
12
13

1）short  s = 5;
   s = s-2;                     //判断：no   因为short-int的结果是一个int(往上自动类型转换) 所以需要强制类型转换
2） byte b = 3;
    b = b + 4;                  //判断：no   因为byte+int的结果是一个int(往上自动类型转换) 所以需要强制类型转换
    b = (byte)(b+4);            //判断：yes  要强制类型转换
3）char c = ‘a’;
   int  i = 5;
   float d = .314F;
   double result = c+i+d;       //判断：yes 因为是char+int+float 结果是一个float  可以自动类型转换为double
4） byte b = 5;
    short s = 3;
    short t = s + b;            //判断：no  因为当byte,short数据类型进行算术运算时，按照int类型  
								//可以改成short t = (short) (s + b);

*问答：为什么标识符的声明规则里要求不能数字开头？ * — 是本身的数值 / 他是一个变量所对应的值

1
2
3
4

//如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
//进而，如下的声明中l的值到底是123？还是变量123L对应的取值12呢？ 出现歧义了。
long l = 123L;  // 123还是12

5.3 基本数据类型与String的运算

5.3.1 字符串类型：String

• String不是基本数据类型，属于引用数据类型 【所以不能够进行基本数据类型的自动类型转换和强制类型转换】
• 使用一对""来表示一个字符串，内部可以包含0-n个字符。
• 声明方式与基本数据类型类似。例如：String str = “尚硅谷”;

5.3.2 运算规则

1、任意八种基本数据类型的数据与String类型只能进行连接“+”运算，且结果一定也是String类型

1
2
3
4
5
6
7
8
9
10
11

System.out.println("   " + 1 + 2); //空格空格空格12  

int num = 10;
boolean b1 = true;
String s1 = "abc";

String s2 = s1 + num + b1;
System.out.println(s2);  //abc10true

//String s3 = num + b1 + s1;  //编译不通过，因为int类型不能与boolean运算
String s4 = num + (b1 + s1); //编译通过  10trueabc  [b1+s1先成为字符串tureabc,然后int+string成为string]

2、String类型不能通过强制类型()转换，转为其他的类型

1
2
3
4

String str = "123";
int num = (int)str;//错误的

int num = Integer.parseInt(str);//借助包装类的方法才能转

5.3.3 案例与练习

案例：公安局身份登记

要求填写自己的姓名、年龄、性别、体重、婚姻状况（已婚用true表示，单身用false表示）、联系方式等等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

/**
 * @author 尚硅谷-宋红康
 * @create 12:34
 */
public class Info {
    public static void main(String[] args) {
        String name = "康师傅";
        int age = 37;
        char gender = '男';
        double weight = 145.6;
        boolean isMarried = true;
        String phoneNumber = "13112341234";

        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("性别：" + gender);
        System.out.println("体重：" + weight);
        System.out.println("婚否：" + isMarried);
        System.out.println("电话：" + phoneNumber);
		//或者
        System.out.println("name = " + name + ",age = " + age + "，gender = " + 
                           gender + ",weight = " + weight + ",isMarried = " + isMarried +
                           ",phoneNumber = " + phoneNumber);
    }
}

练习：

练习1：

1
2
3
4
5
6
7

String str1 = 4;                       //判断对错： × 可以改为String str1=String.valueOf(4);
String str2 = 3.5f + "";               //判断str2对错：对 float+string=string类型
System.out.println(str2);              //输出：3.5 
System.out .println(3+4+"Hello!");     //输出：7Hello!    注意从左往右先算最后和string变为字符串
System.out.println("Hello!"+3+4);      //输出：Hello!34    
System.out.println('a'+1+"Hello!");    //输出：98Hello!   注意从左往右先算最后和string变为字符串
System.out.println("Hello"+'a'+1);     //输出：Helloa1

练习2：

1
2
3
4
5
6
7
8

System.out.println("*    *");				//输出： *    *
System.out.println("*\t*");					//输出： *	*
System.out.println("*" + "\t" + "*");		//输出： *	*
System.out.println('*' + "\t" + "*");		//输出： *	*
System.out.println('*' + '\t' + "*");		//输出： 51*         '*'是char类型在进行算数运算时转为int类型计算！！！
System.out.println('*' + "\t" + '*');		//输出： *   *
System.out.println("*" + '\t' + '*');		//输出： *   *
System.out.println('*' + '\t' + '*');		//输出： 93          '*'是char类型在进行算数运算时转为int类型计算！！！

6. 计算机底层如何存储数据

计算机世界中只有二进制，所以计算机中存储和运算的所有数据都要转为二进制。包括数字、字符、图片、声音、视频等。

世界上有10种人 ，认识和不认识二进制的。

6.1 进制的分类

• 十进制（decimal）

  • 数字组成：0-9
  • 进位规则：满十进一

• 二进制（binary）

  • 数字组成：0-1
  • 进位规则：满二进一，以0b或0B开头

• 八进制（octal）：很少使用

  • 数字组成：0-7
  • 进位规则：满八进一，以数字0开头表示

• 十六进制

  • 数字组成：0-9，a-f
  • 进位规则：满十六进一，以0x或0X开头表示。此处的 a-f 不区分大小写

代码演示：

1
2
3
4
5
6
7
8
9

class BinaryTest {
	public static void main(String[] args) {
		int n1=123;  //十进制   1*10^2+2*10^1+3*10^0=100+20+3=
        int n2=0b11; //二进制   1*2^1+1*2^0=2+1=3
        int n3=071;  //八进制   7*8^1+1*8^0=56+1=57
        int n4=0x12f;//十六进制 1*16^2+2*16^1+15*16^0=256+32+15=303
		System.out.println("n1:"+n1+"\nn2:"+n2+"\nn3:"+n3+"\nn4:"+n4);
	}
}

6.2 进制的换算举例

6.3 二进制的由来

二进制，是计算技术中广泛采用的一种数制，由德国数理哲学大师莱布尼茨于1679年发明。

二进制数据是用0和1两个数码来表示的数。它的基数为2，进位规则是“逢二进一”。

二进制广泛应用于我们生活的方方面面。比如，广泛使用的摩尔斯电码（Morse Code），它由两种基本信号组成：短促的点信号“·”，读“滴”；保持一定时间的长信号“—”，读“嗒”。然后，组成了26个字母，从而拼写出相应的单词。

记忆技巧：

我们偶尔会看到的：SOS，即为：

6.4 二进制转十进制

二进制如何表示整数？

• 计算机数据的存储使用二进制补码形式存储，并且最高位是符号位。
  • 正数：最高位是0
  • 负数：最高位是1

• 规 定
  • 正数：原码=反码=补码
  • 负数：
    • 负数的原码：把十进制转为二进制，然后最高位设置为1
    • 负数的反码：在原码的基础上，最高位不变，其余位取反（0变1,1变0）
    • 负数的补码：反码+1

二进制转十进制：权相加法

针对于byte数据举例来说：

• 例如：byte类型（1个字节，8位）

  25 ==> 原码 0001 1001 ==> 反码 0001 1001 –>补码 0001 1001

  -25 ==>原码 1001 1001 ==> 反码1110 0110 ==>补码 1110 0111

1
2
3
4
5
6
7
8

整数：
正数：25   00000000 00000000 000000000 00011001（原码）
正数：25   00000000 00000000 000000000 00011001（反码）
正数：25   00000000 00000000 000000000 00011001（补码）

负数：-25  10000000 00000000 000000000 00011001（原码）
负数：-25  11111111 11111111 111111111 11100110（反码）
负数：-25  11111111 11111111 111111111 11100111（补码）

一个字节可以存储的整数范围是多少？

1
2
3
4
5
6
7
8
9

//1个字节：8位

0000 0001  ~  0111 111 ==> 1~127

1000 0001 ~ 1111 1111 ==> -127 ~ -1

0000 0000 ==>0

1000 0000 ==> -128（特殊规定）=-127-1

6.5 十进制转二进制

十进制转二进制：除2取余的逆

6.6 二进制与八进制、十六进制间的转换

二进制转八进制(三合一)

二进制转十六进制(四合一)

八进制、十六进制转二进制(一拆多)

6.7 各进制间的转换

练习：

1
2
3
4
5
6
7
8
9

1.将以下十进制数转换为十六进制和二进制
十进制:     123  256  87  62
十六进制:    7b  100  57  3e  从走往左四合一，不够补0
二进制:    1111011 100000000 1010111 111110   除2取余反向读

2.将以下十六进制数转换为十进制和二进制
十六进制：  0x123   0x25F  0x38  0x62
十进制：     291     607    56    98  拆开按照16^算
二进制：   100100011 1001011111 111000 1100010 一拆四 到时候最前面的0记得删除!!!

7. 运算符（Operator）（掌握）

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

运算符的分类：

• 按照功能分为：算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符

• 按照操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）

7.1 算术运算符

7.1.1 基本语法

举例1：加减乘除模

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class ArithmeticTest1 {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		
		System.out.println(a + b);// 3+4=7
        System.out.println(a - b);// 3-4=-1
        System.out.println(a * b);// 3*4=12
        System.out.println(a / b);// 3/4=0
        System.out.println(a % b);// 3%4=3 取余为3

        //重点：结果与被模数符号相同
        System.out.println(5%2);//1   被模数为5
        System.out.println(5%-2);//1  被模数为5
        System.out.println(-5%2);//-1 被模数为-5
        System.out.println(-5%-2);//-1 被模数为-5		
		//商*除数 + 余数 = 被除数
		//5%-2  ==>商是-2，余数时1    (-2)*(-2)+1 = 5
		//-5%2  ==>商是-2，余数是-1   (-2)*2+(-1) = -4-1=-5
	}
}

举例2：“+”号的两种用法

• 第一种：对于+两边都是数值的话，+就是加法的意思 —– 数值+数值=数值
• 第二种：对于+两边至少有一边是字符串的话，+就是拼接的意思 —– 字符串+数值=字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class ArithmeticTest2 {
	public static void main(String[] args) {
		// 字符串类型的变量基本使用
		// 数据类型 变量名称 = 数据值;
		String str1 = "Hello";
		System.out.println(str1); // Hello
		
		System.out.println("Hello" + "World"); // HelloWorld
		
		String str2 = "Java";
		// String + int --> String
		System.out.println(str2 + 520); // Java520
		// String + int + int
		// String		+ int
		// String
		System.out.println(str2 + 5 + 20); // Java520
	}
}

举例3：自加自减运算

理解：++ 运算，表示自增1。同理，-- 运算，表示自减1，用法与++ 一致。

1、单独使用

• 变量在单独运算的时候，变量前++和变量后++，是没有区别的。
• 变量前++ ：例如 ++a 。
• 变量后++ ：例如 a++ 。

1
2
3
4
5
6
7
8
9
10

public class ArithmeticTest3 {
	public static void main(String[] args) {
		// 定义一个int类型的变量a
		int a = 3;
		//++a;
		a++;
        // 无论是变量前++还是变量后++，结果都是4
		System.out.println(a);
	}
}

2、复合使用

• 和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同。

• 变量前++ ：变量先自增1，然后再运算。
• 变量后++ ：变量先运算，然后再自增1。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class ArithmeticTest4 {
	public static void main(String[] args) {
		// 其他变量放在一起使用
		int x = 3;
		//int y = ++x; // y的值是4，x的值是4，
		int y = x++; // y的值是3，x的值是4
		
		System.out.println(x);
		System.out.println(y);
		System.out.println("==========");
        
		// 和输出语句一起
		int z = 5;
		//System.out.println(++z);// 输出结果是6，z的值也是6
		System.out.println(z++);// 输出结果是5，z的值是6
		System.out.println(z);
        
	} 
}

7.1.2 案例与练习

案例1：

1
2
3
4
5
6
7
8
9
10
11
12

随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
格式如下：
数字xxx的情况如下：
个位数：
十位数：
百位数：

例如：
数字153的情况如下：
个位数：3
十位数：5
百位数：1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/**
 * @author 尚硅谷-宋红康
 * @create 12:20
 */
class ArithmeticExer1 {
	public static void main(String[] args) {
		//随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
        // 主打一个缩小范围然后取余确定最后一位
        int n=1234;
        int qian=n/1000;
        int bai=n/100%10;  // 提示:n/100=12
        int shi=n/10%10;   //提示:n/100=123
        int ge=n%10;
        System.out.println("个位数："+ge);
        System.out.println("十位数："+shi);
        System.out.println("百位数："+bai);
        System.out.println("千位数："+qian);

	}
}

拓展：获取一个四位数的个位，十位，百位，千位

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/**
 * @author 尚硅谷-宋红康
 * @create 12:39
 */
public class ArithmeticExer01 {
    public static void main (String [] args) {
        // 获取一个四位数的个位，十位，百位，千位
        // 主打一个缩小范围然后取余确定最后一位
        int n=1234;
        int qian=n/1000;
        int bai=n/100%10;  // 提示:n/100=12
        int shi=n/10%10;   //提示:n/100=123
        int ge=n%10;
        System.out.println("个位数："+ge);
        System.out.println("十位数："+shi);
        System.out.println("百位数："+bai);
        System.out.println("千位数："+qian);

    }
}

案例2：为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？

1
2
3
4
5
6
7
8
9
10
11
12
13

/**
 * @author 尚硅谷-宋红康
 * @create 17:47
 */
public class ArithmeticExer2 {
    public static void main(String[] args){
        //为抵抗洪水，战士连续作战89小时，编程计算共多少天零多少小时？
        int sum=89;
        int day=89/24;
        int hour=89%24;
        System.out.println("一共"+day+"天"+hour+"小时");
    }
}

练习1：算术运算符：自加、自减

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class ArithmeticExer3{
    public static void main(String[] args){
        int i1 = 10;
        int i2 = 20;
        int i = i1++;  // 此时 i=10 i1=11
        System.out.print("i="+i); // i=10
        System.out.println("i1="+i1);// i1=11
        i = ++i1; // 此时i1=12 i=12
        System.out.print("i="+i);// i=12
        System.out.println("i1="+i1);// i1=12
        i = i2--; // 此时i2=19 i=20
        System.out.print("i="+i);// i=20
        System.out.println("i2="+i2);// i2=19
        i = --i2;  // 此时i2=18 i=18
        System.out.print("i="+i);// i=18
        System.out.println("i2="+i2);// i2=18
    }
}

练习2：

1

System.out.println("5+5=" + 5 + 5); //打印结果是？ 5+5=55   因为string+int+int => string+int => string

练习3：

1
2
3

byte bb1 = 127;
bb1++;
System.out.println("bb1 = " + bb1);//-128

练习4：

1
2
3

int i = 1;
int j = i++ + ++i * i++;  //从左往右 1+3*3=10 最后i等于4 
System.out.println("j = " + j);

练习5：（企业真题）写出下列程序的输出结果

1
2
3
4
5
6
7

int i = 2;
int j = i++;
System.out.println(j);

int m = 2;
m = m++; //(1)先取b的值“2”放操作数栈 (2)m再自增,m=3 (3)再把操作数栈中的"2"赋值给m,m=2
System.out.println(m);  // 是2!!!!

7.2 赋值运算符

7.2.1 基本语法

• 符号：=

  • 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
  • 支持连续赋值(先定义好之后才能连续赋值)。

• 扩展赋值运算符： +=、 -=、*=、 /=、%=

  赋值运算符	符号解释
  +=	将符号左边的值和右边的值进行相加操作，最后将结果赋值给左边的变量
  -=	将符号左边的值和右边的值进行相减操作，最后将结果赋值给左边的变量
  *=	将符号左边的值和右边的值进行相乘操作，最后将结果赋值给左边的变量
  /=	将符号左边的值和右边的值进行相除操作，最后将结果赋值给左边的变量
  %=	将符号左边的值和右边的值进行取余操作，最后将结果赋值给左边的变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

public class SetValueTest1 {
	public static void main(String[] args) {
		int i1 = 10;
		long l1 = i1; //自动类型转换

		byte bb1 = (byte)i1; //强制类型转换

		int i2 = i1;

		//连续赋值的测试
		//以前的写法
		int a1 = 10;
		int b1 = 10;
		
		//连续赋值的写法
		int a2,b2;
		a2 = b2 = 10;
		
		int a3 = 10,b3 = 20;

		//举例说明+=  -=  *=  /=   %=  
		int m1 = 10;
		m1 += 5; //类似于 m1 = m1 + 5的操作，但不等同于。
		System.out.println(m1);//15
		
		//练习1：开发中，如何实现一个变量+2的操作呢？
		// += 的操作不会改变变量本身的数据类型。其他拓展的运算符也如此!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
		//写法1：推荐
		short s1 = 10;
		s1 += 2; //编译通过，因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
		System.out.println(s1);//12
		//写法2：
		short s2 = 10;
		//s2 = s2 + 2;//编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
		s2 = (short)(s2 + 2);
		System.out.println(s2);


		//练习2：开发中，如何实现一个变量+1的操作呢？
		//写法1：推荐
		int num1 = 10;
		num1++;
		System.out.println(num1);

		//写法2：
		int num2 = 10;
		num2 += 1;
		System.out.println(num2);

		//写法3：
		int num3 = 10;
		num3 = num3 + 1;
		System.out.println(num3);

	}
}

7.2.2 练习

练习1：

1
2
3

short s = 3; 
s = s+2;  //① 编译报错   s是一个short short+int=int不能直接给short 需要强制类型转换 s=(short)(s+2);
s += 2;   //② 正常执行   short+int=int 自动完成了强制类型转换(+=不改变值的数据类型)

练习2：

1
2
3
4
5

int i = 1;
i *= 0.1;
System.out.println(i);// 因为*=不改变值的数据类型 0.1就截断为0   [脑子短路]
i++;
System.out.println(i);//1

练习3：

1
2
3
4
5

int m = 2;
        int n = 3;
        n *= m++; 	// 可以看作是 n = n * m++;  n=3*2=6 m=3
        System.out.println("m=" + m);//3
        System.out.println("n=" + n);//6

练习4：

1
2
3

int n = 10;
n += (n++) + (++n);  // 可以看作是 n = n + (n++) + (++n)=10+10+12=32
System.out.println(n);//32

练习5：你有几种办法实现变量值减1？变量值减2呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

/**
 * @author 尚硅谷-宋红康
 * @create 16:55
 */
public class MinusTest {
    public static void main(String[] args) {
        //练习①：变量值减1
        short s = 10;
        //方式1：
        //s = (short)(s - 1);
        //方式2：推荐
        s--; //或者 --s
        //方式3：
        s -= 1;

        //练习②：变量值减2
        short s1 = 10;
        //方式1：
        //s1 = (short)(s1 - 2);
        //方式2：推荐
        s1 -= 2;
    }
}

7.3 比较(关系)运算符

• 比较运算符的结果都是boolean型，结果只有true/false。

• > < >= <= ：只适用于基本数据类型（除boolean类型之外）

  == != ：适用于基本数据类型和引用数据类型

• 比较运算符“==”不能误写成“=”

举例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class CompareTest {
	public static void main(String[] args) {
		int i1 = 10;
		int i2 = 20;
		
		System.out.println(i1 == i2);//false
		System.out.println(i1 != i2);//true
		System.out.println(i1 >= i2);//false


		int m = 10;
		int n = 20;
		System.out.println(m == n);//false
		System.out.println(m = n);//20

		boolean b1 = false;
		boolean b2 = true;
		System.out.println(b1 == b2);//false
		System.out.println(b1 = b2);//true
	}
}

思考：

1
2
3
4
5
6

boolean b1 = false;
//区分好==和=的区别。
if(b1 == true)  //if(b1 = true)
	System.out.println("结果为真");
else
	System.out.println("结果为假");

7.4 逻辑运算符

7.4.1 基本语法

• 逻辑运算符，boolean 逻辑运算符 boolean =boolean 。

• 运算符说明：

  • & 和 &&：表示”且”关系，当符号左右两边布尔值都是true时，结果才能为true。否则，为false。
  • | 和 || ：表示”或”关系，当符号两边布尔值有一边为true时，结果为true。当两边都为false时，结果为false。
  • ! ：表示”非”关系，当变量布尔值为true时，结果为false。当变量布尔值为false时，结果为true。
  • ^ ：当符号左右两边布尔值不同时，结果为true。当两边布尔值相同时，结果为false。
    • 理解：异或，追求的是“异”！

• 逻辑运算符用于连接布尔型表达式，在Java中不可以写成 3 < x < 6，应该写成x > 3 & x < 6 。

• 区分“&”和“&&”：

  • 相同点：如果符号左边是true，则二者都执行符号右边的操作

  • 不同点：& ： 如果符号左边是false,则继续执行符号右边的操作

  ​ && ：如果符号左边是false,则不再继续执行符号右边的操作(有一个不符合可以跳过)

  • 建议：开发中，推荐使用 &&

• 区分“|”和“||”：

- 相同点：如果符号左边是false，则二者都执行符号右边的操作



- 不同点：| ： 如果符号左边是true，则继续执行符号右边的操作

  ​               || ：如果符号左边是true，则不再继续执行符号右边的操作(有一个符合可以跳过)



- 建议：开发中，推荐使用 ||

代码举例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

public class LoginTest {
	public static void main(String[] args) {
		int a = 3;
		int b = 4;
		int c = 5;

		// & 与，且；有false则false
		System.out.println((a > b) & (a > c)); 
		System.out.println((a > b) & (a < c)); 
		System.out.println((a < b) & (a > c)); 
		System.out.println((a < b) & (a < c)); 
		System.out.println("===============");
		// | 或；有true则true
		System.out.println((a > b) | (a > c)); 
		System.out.println((a > b) | (a < c)); 
		System.out.println((a < b) | (a > c));
		System.out.println((a < b) | (a < c));
		System.out.println("===============");
		// ^ 异或；相同为false，不同为true  追求异！！！
		System.out.println((a > b) ^ (a > c));
		System.out.println((a > b) ^ (a < c)); 
		System.out.println((a < b) ^ (a > c)); 
		System.out.println((a < b) ^ (a < c)); 
		System.out.println("===============");
		// ! 非；非false则true，非true则false
		System.out.println(!false);
		System.out.println(!true);
        
        //&和&&的区别
        System.out.println((a > b) & (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a > b) && (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a == b) && (a++ > c)); 
        System.out.println("a = " + a);
        
        //|和||的区别
        System.out.println((a > b) | (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a > b) || (a++ > c)); 
        System.out.println("a = " + a);
        System.out.println((a == b) || (a++ > c)); 
        System.out.println("a = " + a);
	}
}

7.4.2 案例与练习

案例：

1
2
3
4
5
6
7

1. 定义类 CompareLogicExer
2. 定义 main方法
3. 定义一个int类型变量a,变量b,都赋值为20
4. 定义boolean类型变量bo1 , 判断++a 是否被3整除,并且a++ 是否被7整除,将结果赋值给bo1
5. 输出a的值,bo1的值
6. 定义boolean类型变量bo2 , 判断b++ 是否被3整除,并且++b 是否被7整除,将结果赋值给bo2
7. 输出b的值,bo2的值

1
2
3
4
5
6
7
8
9
10
11
12

public class CompareLogicExer {
    public static void main(String[] args) {
        int a=20;
        int b=20;
        boolean b01=(++a%3==0)&&(a++%7==0);
        System.out.println(a);  // a=22 先是++a之后成为21 最后a++成为22
        System.out.println(b01); // true
        boolean b02=(b++%3==0)&&(++b%7==0); //一定要记得&&是可以跳出来循环的！
        System.out.println(b);  // b=21  先是b++之后成为21 直接&&不成立直接跳出来了!!!! 
        System.out.println(b02); // false
    }
}

练习1：区分 & 和 && (&&被推荐使用，因为有一个不符合就跳出判断了)

1
2
3
4
5
6
7

int x = 1;
int y = 1;

if(x++ == 2 & ++y == 2){  // 1==2 不成立但是x=2 然后&不能跳过循环继续y=2 2==2成立  但是最终是false&true=false
 	x = 7;
}
System.out.println("x=" + x + ",y=" + y); // x=2 y=2

1
2
3
4
5
6

int x = 1,y = 1;

if(x++ == 2 && ++y == 2){ // 1==2不成立 x=2  因为是&&直接跳出循环
	x =7;
}
System.out.println("x="+x+",y="+y); // x=2 y=1

练习2：区分 | 和 ||(||被推荐使用，因为有一个符合就跳出判断了)

1
2
3
4
5
6

int x = 1,y = 1;

if(x++==1 | ++y==1){  // 1==1 x=2 左边成立 y=2 2==1不成立  true|false=true
	x =7;
}
System.out.println("x="+x+",y="+y); // x=7 y=2

1
2
3
4
5
6

int x = 1,y = 1;

if(x++==1 || ++y==1){ // 1==1 左边成立 x=2 直接成功
	x =7;
}
System.out.println("x="+x+",y="+y); // x=7 y=1

练习3：程序输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class  Test  {
	public static void main (String []  args)  {
		boolean x = true;
        boolean y = false;
        short z = 42;
        
        if ((z++ == 42) && (y = true)) {   // 42==42 左边成立 z=43  y=true
            z++;       // z=44
        }
        if ((x = false) || (++z == 45)) { // x=false 左边成立 z=45 45==45 不成立
            z++; // z=46
        }

        System.out.println("z=" + z); // z=46
	}
}

1
2

//结果为：
//z= 46

7.5 位运算符（难点、非重点）

7.5.1 基本语法

• 位运算符的运算过程都是基于二进制的补码运算

（1）左移：<<

运算规则：在一定范围内，数据每向左移动n位，相当于原数据*2^n。（正数、负数都适用）

【注意】当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

1

3<<4  类似于  3*2^4 => 3*16 => 48

1

-3<<4  类似于  -3*2^4 => -3*16 => -48

（2）右移：>>

运算规则：在一定范围内，数据每向右移动n位，相当于原数据/(2^n)。（正数、负数都适用）

【注意】如果不能整除，向下取整。

1

69>>4  类似于  69/(2^4) = 69/16 =4

1

-69>>4  类似于  -69/(2^4) = -69/16 = -5

（3）无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0。（正数、负数都适用）

1

69>>>4  类似于  69/2的4次 = 69/16 =4

1

-69>>>4   结果：268435451

（4）按位与：&

运算规则：对应位都是1才为1，否则为0。

• 1 & 1 结果为1

• 1 & 0 结果为0

• 0 & 1 结果为0

• 0 & 0 结果为0

1

9 & 7 = 1

1

-9 & 7 = 7

（5）按位或：|

运算规则：对应位只要有1即为1，否则为0。

• 1 | 1 结果为1

• 1 | 0 结果为1

• 0 | 1 结果为1

• 0 & 0 结果为0

1

9 | 7  //结果： 15

1

-9 | 7 //结果： -9

（6）按位异或：^

运算规则：对应位一个为1一个为0，才为1，否则为0(找异!)。

• 1 ^ 1 结果为0

• 1 ^ 0 结果为1

• 0 ^ 1 结果为1

• 0 ^ 0 结果为0

1

9 ^ 7  //结果为14

1

-9 ^ 7 //结果为-16

（7）按位取反：~

运算规则：对应位为1，则结果为0；对应位为0，则结果为1。

• ~0就是1

• ~1就是0

1

~9  //结果：-10

1

~-9  //结果：8

7.5.2 举例

举例1：

举例2：体会 m = k ^ n = (m ^ n) ^ n

7.5.3 案例

案例1：高效的方式计算2 * 8的值（经典面试题）

1

答案：2 << 3 、  8  << 1

案例2：如何交换两个int型变量的值？String呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

/**
 * @author 尚硅谷-宋红康
 * @create 16:58
 */
public class BitExer {
    public static void main(String[] args) {
        int m = 10;
		int n = 5;

		System.out.println("m = " + m + ", n = " + n);

		//（推荐）实现方式1：优点：容易理解，适用于不同数据类型    缺点：需要额外定义变量
		//int temp = m;
		//m = n;
		//n = temp;

		//实现方式2：优点：没有额外定义变量    缺点：可能超出int的范围；只能适用于数值类型
		m=m+n; //20+10=30             全上来了m+n
        n=m-n; //30-20=10   n=10      全部的值-右边原来的=剩下的就是左边的(新的右边的)
        m=m-n; //30-20=20   m=20      全部-新的右边的=新的左边的
	
		//实现方式3：优点：没有额外定义变量    缺点：不易理解；只能适用于数值类型
		m = m ^ n; 
		n = m ^ n; //(m ^ n) ^ n
		m = m ^ n;

		System.out.println("m = " + m + ", n = " + n);
    }
}