Java基础知识笔记

喜欢的东西买了吧

已于 2024-08-01 15:57:54 修改

阅读量252

点赞数 2

文章标签： java 开发语言笔记改行学it

于 2024-06-20 15:06:09 首次发布

本文链接：https://blog.csdn.net/qq_68861010/article/details/139832586

版权

初识Java

Java背景知识

Java是美国sun公司（Stanford University Network）在1995年推出的一门计算机高级编程语言。
Java早期称为Oak（橡树），后期改名为Java。
Java之父：詹姆斯.高斯林（James Gosling）。
2009年 sun公司被Oracle公司（甲骨文公司）收购。

sun公司在1995年年初步发布了Java语言，sun公司直接把Java放到互联网上，免费给大家使用。甚至连源代码也不保密，也放在互联网上向所有人公开。

有了Java语言后，浏览器的功能被扩大了，Java程序可以直接在浏览器里运行，可以直接与远程服务器交互：用Java语言编程，可以在互联网上像传送电子邮件一样方便地传送程序文件！

1995年，sun虽然推出了Java，但这只是一种语言，如果想开发复杂地应用程序，必须要有一个强大地开发类库。因此，sun在1996年年年初发布了JDK１.0.这个版本包括两个部分：运行环境（即JRE）和开发环境（JDK）。运行环境包括核心API、集成API、用户界面API、发布技术、Java虚拟机（JVM）5个部分；开发环境包括：编译Java程序的编译器（即javac命令）。

接着，sun在1997年2月18日发布了JDK1.1。JDK1.1增加了JIT（即时编译）编译器。JIT和传统的编译器不同，传统的编译器是编译一条，运行完后将其扔掉；而JIT会将经常用到的指令保存在内存中，当下次调用时就不需要重新编译了，通过这种方式让JDK在效率上有了很大提升。

1998年12月，sun发布了Java历史上最重要的JDK版本：JDK1.2，伴随JDK1.2一同发布的还有JSP/Servlet、EJB等规范，并将Java分成了J2EE、J2SE、J2ME三个版本。

J2ME：主要用于控制移动设备和信息家电等有限存储设备。

J2SE：整个Java技术的核心和人基础，它是J2ME和J2EE编程的基础。

J2EE：Java技术中应用最广泛的部分，J2EE提供了企业应用开发相关的完整解决方案。

不仅如此，JDK1.2还把它的API分成了三大类：核心API、可选API、特殊API。

核心API：由sun公司制定的基本的API，所有的Java平台都应该提供。这就是平常所说的Java核心类库。

可选API：这就是sun公司为JDK提供的扩充API，这些API因平台的不同而不同。

特殊API：用于满足特殊要求的API，如用于JCA和JCE的第三方加密类库。

Java技术体系（Java有哪些技术平台）

技术体系：Java SE（Java　Standard　Edition）：标准版

说明：Java技术的核心和基础

技术体系：Java　EE（Java Enterprise Edition）：企业版

说明：企业级应用开发的一套解决方案

技术体系：Java ME（Java　Micro　Edition）：小型版

说明：针对移动设备应用的解决方案

JDK的选择安装和下载

搭建Java开发环境

Java的开发环境叫JDK（Java　Development　Kit：Java开发者工具包），必须安装JDK才能使用Java。是sun提供的一套用于开发Java应用程序的开发包，它提供了编译、运行Java程序所需的各种工具和资源，包括Java编译器、Java运行时环境，以及常用的Java类库等。

JRE

JRE，Java运行时环境，它的全称是Java Runtime Environment，因此也被称为JRE，他是运行Java程序的必需条件。

一般而言，如果运行Java程序，可以安装JRE，无须安装JDK。

简单来说，JRE包含JVM。JVM是运行Java程序的核心虚拟机，而运行Java程序不仅需要核心虚拟机，还需要其他的类加载器、字节码校验器以及大量的基础类库。JRE除了包含JVM之外，还包含运行Java程序的其他环境支持。

注：

如果需要开发Java程序，则应该选择安装JDK；当然，安装了JDK之后，就包含了JRE，也是可以运行Java程序。但如果只是运行Java程序，则需要在计算机上安装JRE，仅安装了JVM是不够的。实际上，Oracle网站上提供的就是JRE的下载，并不是单独JVM的下载。

JDK的发展史

1996年JDK（1.0）

1998年JDK（1.2）

2000年JDK（1.3）

.......

2004年JDK-5

2009年JDK（Orale收购sun）

......

2014年JDK-8 LTS（LTS：long-term support 长期支持版）

......

(企业更在意稳定性 JDK８)

如何获取JDK

百度输入Oracle

进入官网

点击products

Java　

Java　downloads

Java　17

Windows

如何安装JDK

傻瓜式安装，直接下一步．．．（注意１：安装路径中不要包含中文和空格）（注意2：所有的开发工具最好安装到统一目录）

先找到下载文件点击下一步更改路径路径不包含中文和空格

如何验证JDK是否成功

看Java、javac是否可用
看Java、javac的版本好是否无问题

1. 打开命令行窗口

按下Win+R，在运行输入框中输入cmd，敲回车

2. 看Java、Javac是否可用

输入Java 或输入javac

3. 验证版本号是否正确

输入Java -version 或输入Javac -version

如何卸载JDK

找到控制面板

程序

卸载程序

找到JDK

右击卸载确定

前置知识：了解JDK中的Java、Javac的基本作用

java --> jdk ...... ---> bin

说明：将来我们写好的Java程序都是高级语言，计算机底层是硬件不能识别这些语言，必须先通过Javac编译工具进行翻译，然后再通过Java执行工具才可以驱动机器干活。

java.exe 执行工具
javac.exe 编译工具

安装JDK 组件了解

Development Tools、Source Code

Development Tools

Development Tools：这是JDK的核心，包括编译Java程序必需的命令工具。实际上，这个选项里面已经包含了运行Java程序的JRE，这个JRE会安装在JDK安装目录的子目录里，这也是无须安装公共JRE的原因。

公共JRE是一个独立的JRE系统，会单独安装在系统的其他路径下。公共JRE会向IE浏览器和系统中注册Java运行时环境。通过这种方式，系统中任何应用程序都可以使用公共JRE。由于现在在网页上执行Applet的机会越来越少，而且完全可以选择使用JDK目录下的JRE来运行Java程序，因此没有太大必要安装公共JRE。

Source Code

安装这个选项将会安装Java所有核心类库的源代码。

JDK安装路径下的文件路径

bin、db、include、jre、lib、javafx-src、src.zip、README和LICENSE等说明性文档。

bin

bin：该路径下存放了JDK的各种工具命令，常用的javac、Java等命令就放在该路径下。

db

db：该路径是安装Java DB的路径。

include

include：一些平台特定的头文件。

jre

jre：该路径下安装的就是运行Java程序所需的JRE环境。

lib

lib：该路径下存放的是JDK工具命令的实际执行程序。

javafx-src

javafx-src：该压缩文件里存放的就是Java FX 所有核心类库的源代码。

src.zip

src.zip：该压缩文件里存放的是Java所有核心类库的源代码。

掌握DOS窗口常见命令的使用

补充几个命令行窗口的常用命令

切换至D盘输入 D:
切换至E盘输入 E:
查看当前目录下的文件信息输入dir
进入单级目录 eg：进入单级目录饼干呢输入cd 饼干呢（tab键可以往后补全)
进入多级目录输入 cd D:\itheima\JavaSE（目录路径可以找到文件全部复制粘贴到命令行窗口）
回退到上一级目录输入cd..
回退到盘符根目录输入 cd /
清屏输入 cls

Java程序运行机制

高级语言的运行机制

计算机高级语言按程序的执行方式可以分为编译型和解释型两种。

编译型语言

编译型语言是指使用专门的编译器，针对特定平台（操作系统）将某种高级语言源代码一次性“翻译”成可以被该平台硬件执行的机器码（包括机器指令和操作数），并包装成该平台所能识别的可执行性程序的格式，这个转换过程称为编译（Compile）。编译生成的可执行性程序可以脱离开发环境，在特定的平台上独立运行。

有些程序编译结束后，还可能需要对其他编译好的目标代码进行链接，即组装两个以上的目标代码模块生成最终的可执行程序，通过这种方式实现低层次的代码复用。

因为编译型语言是一次性地编译成机器码，所以可以脱离开发环境独立运行，而且通常运行效率较高；但因为编译型语言地程序被编译成特定平台上地机器码，因此编译生成地可执行性程序通常无法移植到其他平台上运行；如果需要移植，则必须将源代码复制到特定平台上，针对特定平台进行修改，至少也需要采用特定平台上地编译器重新编译。

现有的　C、C++、Objective－C、Pascal等高级语言都属于编译型语言。

解释型语言

解释型语言是指使用专门的解释器对源程序逐行解释成特定平台的机器码并立即执行的语言。解释型语言通常不会进行整体性的编译和链接处理，解释型语言相当于把编译型语言中的编译和解释过程混合到一起同时完成。

可以认为：每次执行解释型语言的程序都需要进行一次编译，因此解释型语言的程序运行效率通常较低，而且不能脱离解释器独立运行。但解释型语言有一个优势：跨平台比较容易，只需要提供特定平台的解释器即可，每个特定平台上的解释器负责将源程序解释成特定平台的机器指令即可。解释型语言可以方便地实现源程序级的移植，但这是以牺牲程序执行效率为代价的。·

现有的 Ruby、Python等语言属于解释型语言。

伪编译型语言

Visual Basic，它属于半编译型语言，并不是真正的编译型语言。

Java程序的运行机制

Java语言比较特殊，由Java语言编写的程序需要经过编译步骤，但这个编译步骤并不会生成特定平台的机器码，而是生成一种与平台无关的字节码（也就是 * . class文件）。这种字节码不是可执行性的，必须使用Java解释器来解释执行。因此可以认为：Java语言既是编译型语言，也是解释型语言。或者说，Java语言既不是纯粹的编译型语言，也不是纯粹的解释型语言。Java程序的执行过程必须经过先编译、后解释两个步骤。

JVM

Java语言里负责解释执行字节码文件的是Java虚拟机，即JVM（Java Virtual Machine）。JVM是可运行Java字节码文件的虚拟计算机。所有平台上的JVM向编译器提供相同的编程接口，而编译器只需要面向虚拟机，生成虚拟机能理解的代码，然后由虚拟机来解释执行。在一些虚拟机的实现中，还会将虚拟机代码转换成特定系统的机器码执行，从而提高执行效率。

当使用Java编译器编译Java程序时，生成的是与平台无关的字节码，这些字节码不面向任何具体平台，只面向JVM。不同平台上的JVM都是不同的，但它们都提供了相同的接口。JVM是Java程序跨平台的关键部分，只要为不同平台实现了相应的虚拟机，编译后的安居啊字节码就可以在该平台上运行。显然，相同的字节码程序需要在不同的平台上运行，这几乎是“不可能的”，只有通过中间的转换器才可以实现，JVM就是这个转换器。

JVM是一个抽象的计算机，和实际的计算机一样，它具有指令集并使用不同不存储区域。它负责执行指令，还管理数据、内存和寄存器。

JVM的统一标准

Oracle公司制定的Java虚拟机规范在技术上规定了JVM的统一标准，具体定义了JVM的如下细节：

1.指令集

2.寄存器

3.类文件的格式

4.栈

5.垃圾回收堆

6.存储区

Oracle公司制定这些规范的目的是为了提供统一的标准，最终实现Java程序的平台无关性。

开发HelloWorld程序

Java程序开发的三步骤

开发Java程序，需要三个步骤：编写代码，编译代码，运行代码
编写代码 HelloWorld.java（源代码源文件）---> 编译代码使用javac编译 HelloWorld.class（字节码文件）---> 运行代码使用Java运行

注意事项：

第一个Java程序建议使用记事本书写
建议代码文件名全英文，首字母大写，满足驼峰模式，源代码文件的后缀必须是 . java
Java程序严格区分大小写

编写代码

1. 新建文件

2. 在记事本中编写代码

第一个程序的代码如下：

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

注意：文件名称必须与代码中的类名称一致。

保存文件：ctrl + s

编译代码、运行代码

1.编译：javac文件名.java

范例：javac HelloWorld.java

2. 运行：java 类名

范例：Java HelloWorld

Java基础知识了解

public 表示公开的。
class 表示定义一个类。
HelloWorld 表示一个类名。
public class HelloWorld 表示定义一个公开的类，起名为HelloWorld。
public static void main (String[] args) Java程序的入口方法，程序将从这里开始执行。
System.out.println("Hello World"); 向控制台打印一条语句。输出语句 Hello World

常见问题解答

HelloWorld案例常见错误

1. Windows 的文件扩展名没有勾选

解决方案：必须勾选文件扩展名，再新建Java文件

2. 代码写对了，但是忘记保存了

3. 文件名和类名不一致

4. 大小写错误，单词拼写错误，存在中文符号，找不到main方法

5. 括号不配对

6. 编译、执行使用不当

### 一个什么错都犯过的程序员，才是真正的程序员！###

Java程序的执行原理、BUG介绍

计算机能认识的机器语言长什么样子？

机器语言：00011100 00110101 ......
计算机底层都是硬件电路，可以通过不通电和通电，表示0、1

注：可以使用机器语言编程来实现呼吸灯效果

机器语言是由什么组成的

0和1

java程序的执行原理是什么样的？

不管是什么样的高级编程语言，最终都是翻译成计算机底层可以识别的机器语言。

编程语言发展历程

机器语言
汇编语言
高级语言

为什么学习高级编程语言？

更简单：使用接近人类自己的语言书写，翻译器再将其翻译成计算机能理解的机器指令。

BUG

原意是臭虫或者虫子，现在用来指代再电脑系统或者程序中隐藏的一些问题或者漏洞。
BUG的创始人：格蕾丝．赫伯

JDK的组成、跨平台原理

JDK的组成

JVM（java Virtual Machine）：Java虚拟机，真正运行Java程序的地方。
核心类库：Java自己写好的程序，给程序员自己写的程序调用的。
JRE（Java Runtime Environment）：Java的运行环境
JDK（Java Development Kit）：Java开发工具包（包括上面所有）。

JRE组成：JVM + 核心类库

JDK组成：JVM + 核心类库 + 开发工具（Java Javac ......）

JDK组成：JRE + 开发工具（Java Javac ......）

java的跨平台、工作原理

一次编译，处处可用。
我们程序只需要开发一次，就可以在各种安装了JVM的系统平台上运行。

Path、JAVA＿HOME环境变量配置

Path环境变量

path环境变量用于记住程序路径，方便在命令行窗口的任意目录启动程序

编译和运行Java程序必须经过两个步骤

1.将源文件编译成字节码。

2.解释执行平台无关的字节码程序。

使用命令行窗口打开qq程序

1. 打开命令行模式 cmd

2. 找到qq程序路径

3. path环境变量位置配置qq程序path

此电脑右键属性高级系统设置高级环境变量 ...的用户变量中path 双击新建复制qq程序路径点击确定点击确定

4.用命令行模式打开qq程序

打开新的命令行窗口输入qq （在命令行窗口的任意一个路径都可打开qq程序）

为Java、javac配置path的注意事项

目前较新的JDK安装时会自动配置java、javac程序的路径到path环境变量中去，因此，Java、javac可以直接使用
注意：以前的老版本的JDK在安装的时没用自动配置Path环境变量的，此时必需要自己配置path环境变量。
建议还是自己配置一下 “path”、“JAVA_HOME”

自行配置Java、javac的path环境变量

1. 找到Java程序和 Javac程序的路径复制路径

jdk ...... bin

2. 打开path环境变量

此电脑右击属性高级系统设置高级环境变量

（注：配置在 .....的用户变量中的path 和配置在系统变量中的path 二者均可行）

（注：配置在 ......的用户变量中的path 只针对当前登录的系统用户有效，不影响其他登录的用户）

（在配置之前建议把之前自动配置的C:\ProgramData\Oracle\Java\javapath删除，用自己配的）

2. 配置Java、javac的path环境变量

此电脑右击属性高级系统设置高级环境变量

...的用户变量下双击path 新建复制 Java程序和 Javac程序的路径点击确定

重新配置了环境变量以后，必须检测是否配置成功

打开命令行窗口，输入javac -version 及 java -version 分别看版本提示

配置Java _home 环境变量

JAVA_HOME :告诉操作系统JDK安装在哪个位置（将来其他技术要通过这个环境变量找JDK）。

注意：较新版本的JDK只是配置了Path，没用自动配置JAVA_HOME。

多学一招：推荐：Path %JAVA_HOME%\bin

1. 找到jdk的位置复制路径

2. 找到环境变量

此电脑右击属性高级系统设置高级环境变量

3. 新建JAVA_HOME

4. Path %JAVA_HOME%\bin

...的用户变量下双击path 新建输入 %JAVA_HOME%\bin

IntelliJ IDEA开发工具概述

之前的开发工具存在一些问题

文本编辑工具：记事本、NotePad＋＋、EditPlus、sublime．．．编写代码时没用错误提醒、没有智能代码提示、需要自己进行编译、执行，功能不够强大。

集成开发环境（IDE，Integrated　Development　Environment）

把代码编写，编译，执行等多种功能综合到一起的开发工具，可以进行代码智能提示，错误提醒，项目管理等等。
常见的Java　IDE工具有：Eclipse、MyEclipse、IntelliJ　IDEA、Jbuilder　、NetBeans等。

IntelliJ　IDEA简介

IntelliJ　IDEA一般简称　IDEA，在代码错误提醒，智能代码补全等多方面表现的都非常优秀，是进行Java开发时，很多企业首选的开发工具。

IDEA的下载、安装

1.　百度搜索　IntelliJ　IDEA－－－＞进入官网　－－－＞　Windows　－－－＞　ULｔｉｍａｔｅ（旗舰版）、　Community（社区版）（社区版功能比旗舰版功能少，旗舰版要付费）　－－－＞DownLoad

（不建议使用最新版本IDEA）

2.　找到应用　双击　

3.　next　更改路径　next

4.　根据情况点击启动图标　next

5.　next

8.　根据自身情况而定

IDEA程序的卸载

找到控制面板　程序　卸载程序　找到IntelliJ　IDEA　右键　卸载　是　勾选　

IDEA开发HelloWorld程序

IDEA管理Java程序的结构

project（项目、工程）
module（模块）
package（包）
class（类）

新建工程

创建模块

新建包

2.　包名　按下回车

编写Java程序

2.　取类名　按下回车

3.编写代码

package com.liu.hello;

public class HelloWorld {
    //输入main直接回车
    public static void main(String[] args) {
        //输入sout 直接回车
        System.out.println("Hello World");
    }
}

4.　运行代码

运行结果

使用idea开发第一个Java程序的步骤　总结

创建工程　ｎｅｗ　project（空工程）
创建模块　ｎｅｗ　Module
创建包　ｎｅｗ　Package
创建类
编写代码、并启动

使用idea开发Java程序的步骤

project　－－－＞　module　－－－＞　package　－－－＞　class
project中可以创建多个module
module中可以创建多个package
package中可以创建多个class

创建的关键字

ｎｅｗ　project／module／package／class

idea中的Java程序是自动编译和执行的，编译后的class文件在工程路径下的一个　ｏｕｔ　文件里。

IDEA的配置、快捷键设置

设置IDEA的主题

file ---> settings ---> appearance & Behavior ---> appearance ---> theme ---> intelliJ Light ---> ok

---> apply

设置字体颜色

file ---> settings ---> editor ---> font ---> size ---> ok ---> apply

设置代码的背景颜色

例如

file ---> settings ---> editor ---> color scheme ---> general ---> text ---> default text ---> background ---> ok ---> apply

IDEA 常用快捷键

组合几个键一起按下来完成某件事，可以提高开发效率。

重新建包演示一下

package com.liu.speedkey;

public class SpeedKeyDemo {
    //输入main直接回车
    public static void main(String[] args) {
        //输入sout 直接回车
        System.out.println("Hello World");
        //直接输入 "Hello World".sout 直接回车
        System.out.println("Hello World"); //此行 按下CTRL+D
        //CTRL + D 复制当前行数据到下一行
        System.out.println("Hello World");
        System.out.println("Hello World");
        System.out.println("Hello World");
        // CTRL + Y 删除所在行，建议 CTRL + X
        // CTRL + X 剪切键 也可删除行
        // CTRL + Z 撤销操作

        //CTRL + ALT + L 格式化代码
        // ALT + SHIFT + 上箭头 ， ALT + SHIFT + 下箭头   上下移动当前代码
        // CTRL + / , CTRL + SHIFT + /  对代码进行注释

    }
}

IDEA的其他操作

删除文件

修改类名称

修改模块

导入模块（方法一，不建议）

找到导入模块的文件路径，复制路径

打开IDEA ，file ，new ， module from existing sources... ，

导入模块（方法二，建议）

（此方法导入的模块会一直在，不会从IDEA的工程中丢失）

找到要导入的模块，复制工程，粘贴到IDEA要使用的工程固定目录下，再使用方法一，进行拷贝

复制路径

打开IDEA ，file ，new ， module from existing sources... ，

导入模块（方法三）

（新建工程）

找到模块，复制路径

打开IDEA ，粘贴，欧克

删除模块（了解）

（只删除了IDEA中的功能模块，并没有彻底删除模块，需要打开电脑中的目录文件）

（彻底删除了）

打开工程

关闭工程

阶段总结：Java概述、快速入门、IDEA使用

Java快速入门、IDEA开发工具的使用

1. Java的概述

Java事sun公司1995年推出，2009年被Oracle收购
Java的爸爸：詹姆斯 . 高斯林
Java是一门高级编程语言，语言风格接近人类的自然语言，写程序简单易懂
Java的流行度高，商业占用度很高
很重要的特性：可移植性
Java能干什么？什么都可以干，但是最被市场认可的是企业级开发：京东、淘宝这样的互联网系统
Java的技术体系：JavaSE 标准版：java技术的核心和基础

JavaEE 企业版：大型互联网企业级解决方案，充分被市场认可

JavaME 小型版：移动应用的解决方案，没有被市场认可

2. Java的产品

jdk Java的开发工具包，必须安装它才可以使用Java
去Oracle官网下载，安装时不要放在空格和中文路径
我们用的是JDK　17，企业中可用JDK　8
LTS：长期支持版：JDK　8　11、、17
JDK中要用的2个重要的程序：Javaｃ　　编译程序

　　　　　　　　　　　　　　　　Java　　执行程序

JDK安装后要验证是否安装成功：打开命令行窗口　Win　＋　R　－－＞ｃｍｄ　回车

　　　　　　　　　　　　　　　　　输入Java　Javaｃ　Java－version．．看提示有没有问题

补充知识：常用命令行命令　ｃｌｓ　清理屏幕

　　　　　　　　　　　　　ｃｄ

　　　　　　　　　　　　　ｄｉｒ

　　　　　　　　　　　　　切盘：盘符

3.　开发一个Java的入门程序：Hello World

（1）、编写代码　

建议全英文名称，首字母大写　后跟一定是Java结尾
代码写啥

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

（2）、编译代码

javac　HelloWorld．java－－－＞　产生class文件：　HelloWorld．class

（3）、执行代码　

java　HelloWorld　　－－－＞输出　HelloWorld

4.　Java程序的执行原理

Java程序最终会翻译，解释成计算机能识别的机器语言：000111．．．这样的形式驱动机器干活
BUG　代表程序出现问题或者漏洞的意思

　　　　　DEBUG　解决问题的意思

5.　path环境变量，JAVA＿HOME

path的作用：记住程序的路径，方便在命令行窗口的任意目录驱动程序
新版本的JDK安装的时候会自动配置ｊａｖａｃ和Java程序的路径到path环境变量中去，所以，ｊａｖａｃ和Java可以在命令行窗口中直接使用了吧
重点注意：老版本的JDK安装的时候是不会自动配置ｊａｖａｃ和Java程序的路径到path环境变量中去

6.　开发工具　ＩｎｔｅｌｌｉJ　IDEA

集成开发工具（IDEA工具）　工程结构话管理项目，有错误提醒，有代码智能补全．．．
IDEA去官网下载安装：傻瓜式安装

IDEA开发第一个Java程序　（1）、必须创建工程project

　　　　　　　　　　　　（2）、必须创建模块module　

　　　　　　　　　　　　（3）、创建一个包　

Java基础语法：注释详解

编写程序时总是需要为程序添加一些注释，用以说明某段代码地作用，或者说明某个类地用途、某个方法地功能，以及该方法的参数和返回值的数据类型及4意义等。

除此之外，添加注释也是调试程序的一个重要方法。如果觉得某段代码可能有问题，可以先把这段代码注释起来，让编译器忽略这段代码，再次编译、运行，如果程序可以正常执行，则可以说明错误就是由这段代码引起的，这样就缩小了错误所在的范围，有利于排错；如果依然出现相同的错误，则可以说明错误不是由这段代码引起的，同样也缩小了错误的范围。

什么是注释

注释是写在程序中对代码进行解释说明的文字，方便自己和其他人查看，以便理解程序的

注释有哪些

单行注释、多行注释、文档注释

单行注释

// 注释内容，只能写一行

单行注释就是在程序中注释一行代码，在Java语言中，将双斜线（ // ）放在需要注释的内容之前就可以了。

多行注释

注释内容1

注释内容2

多行注释是指一次性地将多行代码注释掉，在Java语言中，使用（ “ /* ” 和 “ * / ”）将程序中需要注释地内容包含起来，“ /* ” 表示注释开始，而“ */ ”表示注释结束。

文档注释

文档注释：文档注释的内容是可以提取到一个程序说明文档中去的

开发一个大型软件时，需要定义成千上万的类，而且需要很多人参与开发，每个人都会开发一些类，并在类里定义一些方法、成员变量提供给其他人使用，但其他人怎么知道如何使用这些类和方法呢？这时候就需要提供一份说明文档，用于说明每个类、每个方法的用途。当其他人使用一个类或者一个方法时，他无须关心这个类或方法的具体实现，他只要知道这个类或方法的功能即可，然后使用这个类或方法来实现具体的目的，也就是通过调用应用程序接口（API）来编程。API文档就是用以说明这些应用程序接口的文档。对于Java语言而言，API文档通过详细说明每个类、每个方法的功能及用法等。

文档注释以斜线后紧跟两个星号（/**）开始，以星号后紧跟一个斜线（*/）结束，中间部分都是文档注释，会被提取到API文档中。

/**

注释内容

package com.liu.note;

/**
 * 文档注释
 * 调频
 * 同频
 * 忠诚
 * 唯一
 * 礼物
 */
public class NoteDemo {
    public static void main(String[] args) {
        //单行注释
        //以下是一个打印语句，是往控制台输出内容的
        System.out.println("我开始学习Java程序，happy！");
        //多行注释
        /*
        开心最重要
        你开心就好
         */
        System.out.println("玫瑰");
        System.out.println("玫瑰花");
    }
}

注释的特点

注释不影响程序的执行的
javac命令进行编译，产生 . class 文件
写注释是一个利人利己的好习惯

快捷键进行注释

ctrl + / 单行注释（对当前行进行注释）
ctrl + shift + / 对选中的代码进行多行注释

Java基础语法：字面量详解

字面量

计算机是用来处理数据的，字面量就是告诉程序员：数据在程序中的书写格式

常用数据

package com.liu.literal;

public class LiteralDemo {
    public static void main(String[] args) {
        //目标：掌握常见数据在程序中的书写格式

        //1、整数
        System.out.println(500);

        //2. 小数
        System.out.println(99.5);

        //3. 字符：必须要用单引号围起来，有且只能有一个字符
        System.out.println('a');
        System.out.println('0');
        System.out.println('中');
        //错误写法 中国为字符串 非字符 System.out.println('中国');

        //4. 空字符
        System.out.println(' ');
        //错误写法 单引号里面要有东西 不能什么都不写 System.out.println('');

        //5. 特色字符
        // \n 代表的是换行的意思
        // \t 代表的是一个tab
        System.out.println('\n');//这行代码在执行的时候会换两行
        // \n 代表换行，println代表换行
        System.out.println('饼');
        System.out.println('\n');
        System.out.println('干');
        System.out.println('\t');

        //6. 字符串：必须用双引号围起来，里面的内容其实可以随意
        System.out.println("我爱吃水果");
        System.out.println("我爱吃饼干");
        System.out.println("");
        System.out.println(" ");

        //7. 布尔值：true false
        System.out.println(true);
        System.out.println(false);


    }
}

Java基础语法：变量详解

什么是变量

变量是用来记住程序要处理的数据的

变量的定义格式

数据类型变量名称 = 数据； int age = 18 ;
数据类型：限制盒子中只能存储某种数据形式：例如：int（整数类型）、double（小数类型）
变量名称：首字母建议小写，有意义
= 赋值

为什么要使用变量

使用变量既要处理数据，编写的代码更灵活，管理代码更方便。

变量在计算机中的执行原理

变量就是内存中的一块区域，可以理解成一个盒子，用来装一个数据的！

变量有啥特点

变量中装的数据是可以被替换的

变量有啥应用场景

写程序对数据进行处理就很方便了

package com.liu.variable;

public class VariableDemo1 {
    public static void main(String[] args) {
        //目标：认识变量，掌握使用变量的好处，变量的特点，应用场景

        // 1. 定义一个整型变量记住一个整数
        //数据类型 变量名 = 数据 ；
        // 注意：=在Java中是赋值的意思，从右往左看
        //把18这个数据赋值给左边的变量age装起来
        int age = 18;
        System.out.println(age);

        //2.记住一个人的成绩
        double score = 99.5;
        System.out.println(score);

        System.out.println("-----------------------------------");

        //3. 使用变量的好处： 便于扩展和维护
        int number =  666;
        System.out.println(number);
        System.out.println(number);
        System.out.println(number);

        System.out.println("----------------------------------");

        //4.变量的特点：里面装的数据可以被替换
        int age2 = 20;
        System.out.println(age2);

        age2 = 19; //赋值：从右边往左边执行
        System.out.println(age2);

        age2 = age2 + 1;
        System.out.println(age2);

        //5. 需求：钱包有9.5元，收到了10元红包，有发出去了5元红包，请输出各阶段钱包的情况
        double money = 9.5;
        System.out.println(money);

        //收红包10元
        money = money + 10;
        System.out.println(money);

        //发出去5元
        money = money - 5;
        System.out.println(money);

    }
}

Java基础语法：变量使用时的注意事项

使用变量时有哪些注意点？

变量要先声明，才能使用
什么类型的变量，只能存储什么类型的数据（变量声明后，不要存储其他类型数据）
变量存在访问范围，同一个范围内，多个变量的名字不能一样
变量定义时可以不给赋初始值；但是在使用时，变量里必须有值
变量的有效范围是从　定义　开始到　｝　截止，且在同一个范围内部不能定义２个同名变量

package com.liu.variable;

public class VariableDemo2 {
    public static void main(String[] args) {
        //目标：搞清楚使用变量的几点注意事项
        //1. 变量要先声明才能使用
        int age = 18;
        System.out.println(age);

        //2. 变量是什么类型，就应该用来装什么类型的数据，否则报错
//        age = 9.8;

        //3.变量是从定义开始到 “ } ” 截止的范围内有效，且同一个范围内，定义的多个变量，它们的名称不能一样
        {
            int a = 19;
            System.out.println(a);
        }
//        System.out.println(a);
        System.out.println(age);

        //4. 变量定义的时候可以不赋初始值，但在使用时，变量里必须有值，否则报错
        int number;
        number = 500;
        System.out.println(number);


    }
}

常见的　javac 　标记

＠author：指定Java程序的作者

＠version：指定源文件的版本

＠deprecateｄ：不推荐使用方法

＠param：方法的参数说明信息

＠return：方法的返回值说明信息

＠see：“参见”，用于指定交叉参考的内容

＠exception：抛出异常的类型

＠throws：抛出的异常，和＠exception同义

分隔符

Java语言里面的分号（；）、花括号（｛｝）、方括号（【】）、圆括号（（））、空格、圆点（　．）都具有特殊的分隔作用，因此被统称为分隔符。

分号

Java语言采用分号（；）作为语句的分隔，因此每个Java语句必须使用分号作为结尾。Java程序允许一行书写多个语句，每个语句之间以分号隔开即可，一个语句也可以跨多行，只要在最后结束的地方使用分号结束即可。

花括号

花括号的作用就是定义一个代码块，一个代码块指的就是　“｛”　和　“｝”　所包含的一段代码，代码块在逻辑上是一个整体。对Java语言而言，类定义部分必须放在一个代码块里，方法体部分也必须放在一个代码块里。除此之外，条件语句中的条件执行体和循环语句中的循环体通常也放在代码块了。

花括号一般是成对出现的，有一个　“｛”　则必然有一个　“｝”，反之亦然。

方括号

方括号的主要作用是用于访问数组元素，方括号通常紧跟数组变量名，而方括号里指定希望访问的数组元素的索引。

圆括号

圆括号是一个功能非常丰富的分隔符：定义方法是必须使用圆括号来包含所有的形参声明，调用方法时也必须使用圆括号来传入实参值；不仅如此，圆括号还可以将表达式中某个部分括成一个整体，保证这个部分优先计算；除此之外，圆括号还可以作为强制类型转换的运算符。

空格

Java语言使用空格分隔一条语句的不同部分。Java　语言时一门格式自由语言，所以空格几乎可以出现在Java程序的任何地方，也可以出现任意多个空格，但不要使用空格把一个变量名隔开成两个，这将导致程序出错。

Java语言中的空格包含空格符（Space）、制表符（Tab）和回车（Enter）等。

除此之外，Java源程序还会使用空格来合理缩进Java代码，从而提高更好的可读性。

圆点

圆点（．）通常作为类／对象和它的成员（包括成员变量、方法和内部类）之间的分隔符，表面调用某个类或某个实例的指定成员。

Java基础语法：关键字、标识符

关键字

Java语言自己用到的一些词，有特殊作用的，我们称之为关键字，如：public、class、int、double...
当定义标识符时，不要让标识符和关键字相同，否则将引起错误。即标识符不能用关键字命名。
Java中的所有关键字都是小写的，TRUE、FALSE、NULL都不是关键字。
注意：关键字是Java用了的，我们就不能用来作为：类名、变量名，否则会报错！
ｇｏｔｏ和const　这两个关键字也被称为保留字。

标识符

标识符就是名字，我们写程序时会起一些名字，如类名、变量名等等都是标识符
标识符就是用于给程序中的变量、类、方法命名的符号

标识符的要求

基本组成：由数字、字母、下划线（_)和美元符($)等组成
强制要求：不能意数字开头、不能用关键字和保留字作为名字，但可以包含关键字和保留字、不能包含空格、且是区分大小写的
只能包含美元符（＄），不能包含＠、＃等其他特殊字符。
标识符必须以字母、下划线（＿）、美元符（＄）开头，后面可以跟任意数目的字母、数字、下划线（＿）和美元符（＄）。此处的字母并不局限于２６个英文字母　，而且可以包含中文字符、日文字符等。
正确的命名：bj b2 $2 中国 _2b ak47 Class HelloWorld
错误的命名：2b class #liu

标识符的建议规范

变量名称：满足标识符规则，同时建议用英文、有意义、首字母小写，满足“驼峰模式”，例如：int studyNumber = 500 ；
类名称：满足标识符规则，建议全英文、有意义、首字母大写，满足“驼峰模式”，例如：Hello World，Student

Java语法：变量里的数据在计算机中的存储原理

数据在计算机底层都是怎么存储的？

都是采用二进制：使用0、1，按照逢2进1的规则表示数据来存储。

如何快速的算出一个数据的二进制形式？

除二取余法

二进制

只有0、1，按照逢2进1的方式表示数据：

十进制转二进制的算法

除二取余法

计算机中表示数据的最小单位

计算机表示数据的最小单元：一个字节（byte，简称B，是使用8个二进制位组成的）（8位一组）
字节中的每个二进制位就称为位（bit，简称b），1B = 8b

Java语法：字符，图片，声音的存储说明

字符在计算机中是如何存储的呢？

ASCII编码表：即美国信息交换标准码，规定了现代英语、数字字符和其他西欧字符对应的数字编号。
字符 'A' 对应的数字是65
字符 'a' 对应的数字是97
字符 '0' 对应的数字是48

package com.liu.variable;

public class ASCIIDemo1 {
    public static void main(String[] args) {
        //目标：掌握ASCII编码表的编码特点
        System.out.println('a'+10); //97+10=107
        System.out.println('A'+10); //65+10=75
        System.out.println('0'+10); //48+10=58

    }
}

图片和音频等文件的数据是怎么存储的啊？

也是采用二进制进行存储的

图片数据 - 彩色图

图片就是无数个像素点组成的
每个像素点的数据：用0 ~ 255 * 255 * 255 表示其颜色

声音数据

Java语法：二进制、八进制、十六进制

Java中整数值有4种表示方法：十进制、二进制、八进制和十六进制，其中二进制的整数以0b或0B开头；八进制的整数以0开头；十六进制的整数以0x或者0X开头，其中10~15分别以a~f（此处的a~f不区分大小写）来表示。

在某些时候，程序需要直接使用二进制整数，二进制整数更“真实”，更能表达整数在内存中的存在形式。不仅如此，有些程序（尤其在开发一些游戏时）使用二进制整数会更便捷。

所有数字在计算机底层都是以二进制形式存在的，原码是直接将一个数值转算成二进制数。但计算机以补码的形式保存所有的整数。补码的计算规则：正数的补码和原码完全相同，负数的补码是其反码加1；反码是对原码按位取反，只是最高位（符号位）保持不变。

十进制转二进制的算法

十进制数转二进制数：除二取余法

二进制转十进制数

8421法

八进制、十六进制介绍

为了便于观察和表示二进制，推出了八进制和十六进制。
每3位二进制作为一个单元，最小数是0，最大数是7，共8个数字，这就是八进制（421）

每4位二进制作为一个单元，最小数是0，最大数是15，共16个数字，依次用：0~9 ABCDEF 代表就是十六进制（8421）

注意：Java程序中支持书写二进制、八进制、十六进制的数据，分别需要以0B或者0b、0、0X或者0x开头。

package com.liu.variable;

public class ASCIIDemo1 {
    public static void main(String[] args) {


        //二进制、八进制、十六进制在程序中的写法
        int a1 = 0B01100001;
        System.out.println(a1);

        int a2 = 0141; //0开头的数据当成八进制看待！
        System.out.println(a2);

        int a3 = 0XFA;//0X开头的数据是十六进制
        System.out.println(a3);
    }
}

计算机的数据单位

计算机表示数据的最小组成单元是：字节，1B = 8b
在B的基础上，计算机发展出了KB、MB、GB、TB．．．这些数据单位。
1B＝8ｂ
1 KB = 1024 B
1MB = 1024KB
１GB＝1024MB
１TB＝1024GB

Java语法：数据类型

数据类型的分类

基本数据类型（Primitive Type）
引用数据类型（Reference Type）

基本数据类型

4大类８种
基本类型包括 boolean类型和数值类型
数值类型包括整数类型和浮点类型
整数类型包括 byte、short 、int、long、char（字符类型）
浮点类型包括 float、double

byte：一个byte类型整数在内存里占8位

short：一个short类型整数在内存里占16位

int：一个int类型整数在内存里占32位

long：一个long类型整数在内存里占64位

int是最常用的整数类型，因此在通常情况下，直接给出一个整数值默认就是int类型。除此之外，有如下两种情形必须指出：1.如果直接将一个较小的整数值（在byte或short类型的表数范围内）赋给一个byte或short变量，系统会自动把这个整数值当成byte或者short类型来处理。2. 如果使用一个巨大的整数值（超出了int类型的表数范围）时，Java不会自动把这个数值当成long类型类处理。如果希望系统把一个整数值当成long类型来处理，应在这个整数值后增加英文字母l或者L作为后缀。通常推荐使用L，因为英文字母l'很容易跟数字1混淆。

Java的浮点类型有两种：float和double。Java的浮点类型有固定的表数范围和字段长度，字段长度和表数范围与机器无关。Java的浮点数遵循IEEE 754标准，采用二进制数据的科学计数法来表示浮点数，对于float型数值，第1位是符号位，接下来8位表示指数，再接下开的23位表示尾数；对于double类型数值，第1位也是符号位，接下来的11位表示指数，再接下的52位表示尾数。

double类型代表双精度浮点数，float类型代表单精度浮点数。一个double类型的数值占8字节、64位，一个float类型的数值占4字节、32位。

Java语言的浮点类型默认是double类型，如果希望Java把一个浮点类型值当成float类型处理，应该在这个浮点类型值后紧跟f或F。例如5.12代表一个double类型的值，占64位的内存空间；5.12f或者5.12F才表示一个float类型的值，占32位的内存空间。

布尔型只有一个boolean类型，用于表示逻辑上的“真”或“假”。在Java语言中，boolean类型的数值只能是true或false，不能用0或者非0来代表。其他基本数据类型的值也不能转换成boolean类型。

Java规范并没有强制指定boolean类型的变量所占用的内存空间虽然boolean类型的变量或者值只要1位即可保存，但由于大部分计算机在分配内存时允许分配的最小内存单元式字节（8位），因此bit大部分时候实际上占用8位。

package com.liu.variable;

public class Variabledemo2 {
    public static void main(String[] args) {

        //掌握常见的基本数据类型的使用
        //1. byte short int long
        byte a = 127;//-128~127
//    byte a2 = 128;//越界了

        short s = 13244;
//    short s1 = 93244; //越界了

        int i = 422424;// 默认

        //注意：随便写一个整型字面量默认是int类型的
        // 424242444444虽然没有超过long的范围，但是超过了本身int类型的范围
        //如果希望随便写一个整型自变量默认是long类型的，需要在后面加上L/l
//    long lg = 424242444444; 错误写法
        long lg = 424242444444L;

        //2. float double
        //注意：随便写个小数字面量，默认是double，如果希望小数是float，后面加上F/f
        float f = 3.14F;

        double d = 56.45;

        //3. char 字符型
        char ch = 'a';
        char ch2 = '中';

        //4. boolean
        boolean flag = true;
        boolean flag2 = false;

        //拓展一种引用数据类型，后面要用
        //String 称之为字符串类型，定义的变量可以用于记住一个字符串数据。
        String name = "张三";
        System.out.println(name);

    }
}

字符型

字符型通常用于表示单个的字符，字符型值必须使用单引号（‘）括起来。Java语言使用16位的Unicode字符集作为编码方式，而Unicode被设计成支持世界上所有书面语言的字符，包括中文字符因此Java程序支持各种语言字符。

字符型值有如下三种表现形式：1. 直接通过单个字符来指定字符型值，例如：’A‘、’9‘和’0‘等； 2. 通过转义字符表示特殊字符型值，例如’\n‘、'\t'等； 3.直接使用Unicode值来表示字符型值，格式是’\uXXXX‘,其中XXXX代表一个十六进制的整数。

\b 退格符

\n 换行符

\t 制表符

\“ 双引号

\' 单引号

\\ 反斜杠

char类型的变量、值完全可以参与加、减、乘、除等数学运算，也可以比较大小——实际上都是用该字符对应的编码参与运算。

引用数据类型

String
Java没有提供表示字符串的基本数据类型，而是通过String类来表示字符串，由于字符串由多个字符组成，因此字符串要使用双引号括起来。
引用类型包括类、接口和数组类型，还有一种特殊的null类型。所谓引用数据类型就是对一个对象的引用，对象包括实例和数组两种。实际上，引用类型变量就是一个指针，只是Java语言里不再使用指针这个说法。
空类型（null type）就是null值的类型，这种类型没有名称。因为null类型没有名称，所以不可能声明一个null类型的变量或者转换到null类型。空引用（null）就是null类型变量唯一的值。空引用（null）是null类型变量唯一的值。空引用（null）可以转换为任何引用类型。
在实际开发中，程序员可以忽略null类型，假定null只是引用类型的一个特殊直接量。

随便写的整数、小数字面量，他们默认什么类型？

23，默认是int类型，加上Ｌ／ｌ就是long类型的数据了
23.8，默认是double类型，加上Ｆ／ｆ就是float类型了

Java语法：自动类型转换

什么是自动类型转换，为什么要进行自动类型转换？

类型范围小的变量，可以直接赋值给类型范围大的变量。 byte ---->int
存在不同类型的变量赋值给其他类型的变量

自动类型转换在计算机的执行原理

自动类型转换的其他形式

package com.liu.type;

public class TypeConversionDemo1 {
    public static void main(String[] args) {
       //目标：理解自动类型转换机制
       byte a = 12;
       int b = a;//发生了自动类型转换
        System.out.println(a);
        System.out.println(b);

        int c = 100;
        double d = c;//发生了自动类型转换
        System.out.println(d);

        char ch = 'a';//a=97 ---> 00000000 01100001
        int i = ch;//发生了自动类型转换 00000000 00000000 00000000 01100001

    }
}

Java语法：表达式的自动类型转换

表达式的自动类型转换

在表达式中，小范围类型的变量，会自动转换成表达式中较大范围的类型，再参与运算。

注意事项

表达式的最终结果类型由表达式中的最高类型决定。
在表达式中，byte、short、char是直接转换成int类型参与运算的。

package com.liu.type;

public class TypeConversionDemo2 {
    public static void main(String[] args) {
        //目标：掌握表达式的自动类型转换规则
        byte a = 10;
        int b = 20;
        int c = 30;
        long rs =a + b + c ;
        System.out.println(rs);

        double rs2 = a + b +1.0;
        System.out.println(rs2);

        byte i = 10;
        short j = 30;
        int rs3 = i + j;
        System.out.println(rs3);
        
        //面试笔试题
        byte b1 = 110;
        byte b2 = 80;
        int  b3 = b1 + b2 ;
        System.out.println(b3);

    }
}

Java语法：强制类型转换

默认情况下，强制类型转换：

类型范围大的数据或者变量，直接赋值给类型范围小的变量，会报错。

强制类型转换

强行将其类型范围大的变量、数据赋值给类型范围小的变量
数据类型变量2 = （数据类型）变量1、数据

强制类型转换在计算机中的执行原理

注意事项

强制类型转换可能造成数据（丢失）溢出
浮点型强转成整型，直接丢掉小数部分，保留整数部分返回

package com.liu.type;

public class TypeConversionDemo3 {
    public static void main(String[] args) {
        //目标：掌握强制类型转换
        int a = 20;
        byte b = (byte) a;//alt + 回车键
        System.out.println(a);
        System.out.println(b);

        int i = 1500;
        byte j = (byte) i;
        System.out.println(j);

        double d = 99.5;
        int n = (int) d; //强制类型转换
        System.out.println(n); //丢掉小数部分，保留整数部分


    }
}

Java语法：算术运算符、+符号做连接符

基本的算术运算符

“ + ” 符号可以做连接符的

“ + ” 符号与字符串运算的时候是用作连接符的，其结果依然是一个字符串

独门秘籍：

能算则算，不能算就在一起。（计算机很聪明）

package com.liu.operator;

public class OperatorDemo {
    public static void main(String[] args) {
        //目标：掌握基本的算术运算符的使用
        int a = 10;
        int b = 2;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        System.out.println(5 / 2);//2.5 --->2
        System.out.println(5.0 / 2);//2.5
        int i = 5;
        int j = 2;
        System.out.println(i / j);//2
        System.out.println(1.0 * i / j);//2.5

        System.out.println(a % b);//0
        System.out.println(3 % 2);//1

        System.out.println("------------------------------------");
        
        //目标：掌握使用+符号做连接符的情况
        int a2 = 5;
        System.out.println("abc" + a2);//abc5
        System.out.println(a2 + 5);//10
        System.out.println("liu" + a2 + 'a');//liu5a
        System.out.println(a2 + 'a' + "liu");//5+97=102 //102liu
    }
}

算术运算符有哪些？

+ - * / %

/ 需要注意什么，为什么？

如果两个整数做除法，其结果一定是整数，因为最高类型是整数

+ 除了做基本数学运算，还有哪些功能？

与字符串+运算时会当成连接符，其结果还是字符串
识别技巧：能算则算，不能算就在一起。（计算机很聪明）

Java语法：自增、自减运算符

自增自减运算符

注意：

++ -- 只能操作变量，不能操作字面量。

自增自减的使用注意事项

++ 、-- 如果不是单独使用（如在表达式中或者同时有其他操作），放在变量前后会存在明显的区别

放在变量的前面，先对变量进行+1、-1，再拿变量的值进行运算
放在变量的后面，先拿变量的值进行运算，再对变量的值进行+1、-1

package com.liu.operator;

public class OperatorDemo2 {
    public static void main(String[] args) {
        //目标：掌握自增自减运算符的使用
        int a = 10;
        a ++; //a = a + 1
        System.out.println(a);

        a--;
        System.out.println(a);//a=11-1

   //自增自减只能操作变量，不能操作字面量。
//        2++;
//        System.out.println(2++);

        System.out.println("---------------------------------------------");
        
        int i = 10;
        int rs = ++i;//先加后用
        System.out.println(rs);
        System.out.println(i);
        
        int j = 10;
        int rs2 = j++;//先用后加
        System.out.println(rs2);
        System.out.println(j);
    }
}

Java语法：自增自减（拓展案例）

package com.liu.operator;

public class OperatorDemo2 {
    public static void main(String[] args) {
//拓展
        int m =5;
        int n = 3;
        int result = ++m - --m + m-- - ++n + n-- +3;
        //++m=6 m=6
        //--m=5 m=5
        //m--=5 m=4
        //++n=4 n=4
        //n--=4 n=3
        //6-5+5-4+4+3=9
        System.out.println(result); //9
        System.out.println(m); //4
        System.out.println(n); //3
    }
}

java语法：赋值运算符

基本赋值运算符

就是 “ = ”，从右边往左边看
int a = 10 ; //先看 “ = " 右边，把数据10赋值给左边的变量a存储

扩展赋值运算符

注意

扩展的赋值运算符隐含了强制类型转换。
+= 可以实现数据的累加，把别人的数据加给自己。

package com.liu.operator;

public class OperatorDemo3 {
    public static void main(String[] args) {
        //目标：掌握扩展赋值运算符的使用
        // +=
        // 需求：收红包
        double a = 9.5;
        double b = 520;
        //a =(double)(a + b);
        a +=b;
        System.out.println(a);

        //需求：发红包
        double i = 600;
        double j = 520;
        //i = (double)(i - j);
        i -= j;
        System.out.println(i);

        int m = 10;
        int n = 10;
        m *= n; //等价形式 m = (int)(m*n)
        System.out.println(m);
        m /= n; //等价形式 m = (int)(m/n)
        System.out.println(m);
        m %= n; //等价形式 m = (int)(m%n)
        System.out.println(m);

        System.out.println("-------------");

        byte x = 10;
        byte y = 30;
        //x = x + y;//编译报错
//        x = (byte) (x+y); 正确代码
        x +=y; //等价形式  x = (byte) (x+y);
        System.out.println(x);
    }
}

Java语法：关系运算符

关系运算符

判断数据是否满足条件，最终会返回一个判断的结果，这个结果是布尔类型的值：true 或者 false。

注意：

在Java中判断是否相等一定是 ” == “ ，千万不要把 ” == “ 误写成 ” = “

package com.liu.operator;

public class OperatorDemo4 {
    public static void main(String[] args) {
        //目标：掌握关系运算符的基本使用
        int a = 10;
        int b = 5;
        boolean rs = a > b ;
        System.out.println(rs);

        System.out.println(a >= b);//要么a大于b,要么a=b
        System.out.println(2 >= 2);//true
        System.out.println(a < b);
        System.out.println(a <= b);//false
        System.out.println(2 <= 2);//true
        System.out.println(a == b);//false
        System.out.println(5 == 5);//true
        System.out.println(a = b );//5 //注意了 判断是否相等一定用==，=是用来赋值的
        System.out.println(a != b);//true
        System.out.println(10!=10);//false
    }
}

Java语法：逻辑运算符

逻辑运算符

把多个条件放在一起运算，最终返回布尔类型的值：true、false.

注意：

在Java中，” & “、” | “：无论左边是 false 还是 true，右边都要执行。
由于 &&、|| 运算效率更高、在开发过程中用的更多

package com.liu.operator;

public class OperatorDemo5 {
    public static void main(String[] args) {
        //目标：掌握逻辑运算符的使用
        //需求:要求手机必须满足尺寸大于等于6.95，且内存必须大于等于8
        double size = 6.8;
        int storage = 16;
        //1. & 前后的条件的结果必须都是true，结果才是true
        boolean rs = size >= 6.95 & storage >= 8;
        System.out.println(rs);//false

        //需求:要求手机要么满足尺寸大于等于6.95，要么内存必须大于等于8
        //2. | 只要多个条件中有一个是true，结果就是true
        boolean rs2 = size >= 6.95 | storage >= 8;
        System.out.println(rs2);//true

        // 3. ! 取反的意思
        System.out.println(!true); //false
        System.out.println(!false); //true
        System.out.println(!(2>1)); //false

        //4. ^ 前后的条件结果相同时返回false,不同时返回true
        System.out.println(true ^ true);//false
        System.out.println(false ^ false);//false
        System.out.println(true ^ false);//true
        System.out.println(false ^ true);//true

        //5. 左边为false,右边不执行
        int i = 10;
        int j = 20;
        System.out.println( i > 100 && ++j > 99);
        System.out.println(j);

        //6. || 左边为true，右边就不执行
        int m = 10;
        int n = 30;
        System.out.println(m > 3 || ++n > 40);
        System.out.println(n);
    }
}

Java语法：三元运算符、运算符优先级

三元运算符介绍

格式：条件表达式？值1 ：值2 ；
执行流程：首先计算关系表达式的值，如果值为true，返回值1，如果为false，返回值2

运算符优先级

在表示式中，哪个运算符先执行后执行是要看优先级的，例如 ” *、/ “ 的优先级高于 ” +、- “

package com.liu.operator;

public class OperatorDemo6 {
    public static void main(String[] args) {
        //目标：掌握三元运算符的基本使用
        double score = 98.5;
        String rs = score >= 60 ? "成绩及格":"成绩不及格";
        System.out.println(rs);

        //需求：找出2个整数中的较大值，并输出
        int a = 99;
        int b = 67;
        int max =  a > b ? a : b;
        System.out.println(max);

        //需求:找3个整数中的较大值
        int i = 10;
        int j = 45;
        int k = 34;

        //找到2个整数中的最大值
        int temp = i > j ? i :j;
        //找出temp与k中的较大值
        int max2 = temp > k ? temp : k;
        System.out.println(max2);//45

        System.out.println("---------------------------------------");

        System.out.println(10 > 3 || 10>3 && 10<3);//true
        System.out.println((10 > 3 || 10>3) && 10<3);//false

    }
}

Java语法：API介绍、Scanner：录入用户键盘输入的数据

需求：

请在程序中，提示用户通过键盘输入自己的姓名、年龄，并能在程序中收到这些数据，怎么解觉？答：Java已经写好了实现程序，我们调用即可！

API（Application Programming Interface：应用程序编程接口）

Java写好的程序，咱们程序员可以直接拿来调用。
Java为自己写好的程序提供了相应的程序使用说明书（API文档）。

API文档在哪可以找到？

打开百度
输入Oracle官网
找到products 点击
找到Java 点击
点击 Download Java
点击 JDK17
点击 Documentation Download （文档下载）
找到Download 有个jdk版本文档的下载链接点击下载
同意勾选点击下载

为什么要需学习查看API文档的方法？

API是Java提供的基本编程接口，当使用Java语言进行编程时，不可能把所有的Java类、所有方法全部记下来，当编程遇到一个不确定的地方时，必须通过API文档来查看某个类、某个方法的功能和用法。因此，掌握查看API文档的方法时学习Java的一个最基本的技能。读者可以尝试查阅API文档的String类来掌握String类的用法。

使用Scanner接收用户键盘输入的数据，需要三个步骤：

导包：告诉程序去JDK的那个包中找扫描器技术
抄代码：代表得到键盘扫描器对象（东西）
抄代码：等待接收用户输入数据

注意：

System、String在JDK中的 java.lang 包下。
lang包不需要我们导包，是默认的包。

package com.liu.scanner;
import java.util.Scanner;
public class ScannerDemo1 {
    public static void main(String[] args) {
        //1. 导包:一般不需要我们自己做，idea工具会自动帮助我们导包的
        //2. 抄写代码：得到一个键盘扫描器对象（东西）
        Scanner sc = new Scanner(System.in);
        //3. 开始调用sc的功能，来接收用户键盘输入的数据
        System.out.println("请您输入您的年龄");
        int age = sc.nextInt();//执行到这，会开始等待用户输入一个整数，直到用户按下回车键，才会拿到数据。
        System.out.println("您的年龄是："+ age);

        System.out.println("请输入您的名字：");
        String name = sc.next();//执行到这，会开始等待用户输入一个字符串，直到用户按下回车键，才会拿到数据。
        System.out.println(name +"欢迎您进入系统~~~");


    }
}

阶段总结：类型转换、运算符、案例知识(键盘录入技术)

类型转换

原因：开发中会存在不同类型的变量或者数据赋值给其他类型的变量，也存在不同类型的数据一起运算，其结果类型要确定下来。
自动类型转换的原理：小范围类型的变量可以直接赋值给大范围类型的变量。
自动类型转换的范围信息：
自动类型转换的形式：byte a =20 ; int b = a ;
自动类型转换注意：char ch = ' a ' ; int code = ch (注意这种形式是可以的)
表达式的自动类型转含义：在表示式中，小范围类型的变量会自动提升成大范围运算
表达式的自动类型转换结论：表达式的最终结果数据类型是由表达式中的最高数据类型决定的，最高数类型是什么，其结果数据类型就是什么
表达式的自动类型转换注意：byte 、short、char在表达式中，是直接提升成 int 运算的
表达式的自动类型转换面试笔试：
强制类型转换含义：大范围类型的变量或者数据不能直接赋值给小范围类型的变量，否则报错！必须进行强制类型转换才可以。
强制类型转换格式：数据类型变量 = （数据类型）其他类型的变量/数据
强制类型转换注意：强制类型转换可能出现数据丢失，int a = 1500；byte b = (byte) a;
强制类型转换注意：浮点类型的变量或者数据强制转换成整型，保留整数部分返回的，小数部分直接不要了 double a = 99.5 ; int i = (int) a ; // i =99

运算符（基本运算符、自增自减、赋值、关系、逻辑）

基本算术运算符常见的: + - * / %
基本运算符注意： / 两个整数相除的结果一定是整数例：10/3=3 ， 1.0*10/3=3.333...
+符号做连接符场景：+符号与字符一起运算时，充当连接符，连接后的结果还是一个字符串。
+符号做连接符识别技巧：能算则算，不能算大家连在一起。
自增自减运算符：++对变量进行+1操作， --对变量进行-1操作。
自增自减运算符注意事项：只能操作变量，不能操作字面量。例如：a++；//没毛病的 2++；//没有这种形式，报错； ++ --单独使用，放在变量前后，没有区别例如：a++；++a ； ++ --如果不是单独使用，放在变量前后有明显区别，在变量前面：先+1，-1再使用变量，在变量后面：先使用变量，再对变量+1 -1
赋值运算符：= ，+= ，-= ，*= ，/= , %=
赋值运算符的应用：a +=b;等价于 a=（a的类型)（a+b）
赋值运算符的用处：适合做数据的累加操作 int a = 10； int b = 5；a += b；自带强制转换 byte b1 = 2；byte b2 = 3；byte b3 =（byte）（b1+b2）；---->b1 +=b ；
关系运算符：== != > >= < <=
关系运算符判断是否满足条件，返回true 和 false 例如：int age =19；System.out.println(age >=18);等价于 boolean rs =age >= 18; System.out.println(rs);
逻辑运算符：& && | || ！ ^
逻辑运算符与：&（逻辑与)：且的意思，必须前后都是true，结果才是true， &&（短路与）：且的意思，必须前后都是true，结果才是true，&与&& 的区别：&&如果发现前面是false，后面不执行，直接返回结果，性能较好，用的更多。
逻辑运算符或： |（逻辑或）：或的意思，只要前后有一个true，结果就一定是true，||（短路与）：或的意思，只要前后有一个true，结果就一定是true，|（逻辑或）和 ||（短路与）的区别：||如果发现前面是true，后面不执行，直接返回结果，性能较好一点，用的更多一点。
逻辑运算符取反：！（取反）！false = true ！true = false
逻辑运算符异或：^(异或) 前后一样返回false，前后不一样返回true

运算符（三元运算符）

三元运算符是做分支选择的，关键是格式，条件表达式？值1 ：值2

运算符（运算符优先级）

运算符存在谁先谁后执行的情况：（）优先级最高， * / 高于 + - ， &&优先级高于 ||

案例知识：键盘录入技术

Java自己提供好的程序给程序员调用的
API文档：应用程序编程接口，技术说明书，告诉我们该怎么使用Java程序
键盘录入技术：（1）、导包（自动导）：import java.util.Scanner。(2)、创建一个扫描器对象：Scanner sc = new Scanner(System.in); (3)、等待接收用户的数据：int age = src.nextInt(); (4)、等待接收用的数据：String name = sc.next();

流程控制：分支结构：if、switch、switch穿透性

Java提供了两种常见的分支控制结构：if语句和switch语句，其中if语句使用布尔表达式或布尔值作为分支条件来进行分支控制；而switch语句则用于对多个整型值进行匹配，从而实现分支控制。

if分支

根据条件（真或假）来决定执行某段代码

if分支有三种形式

放在if之后括号里的只能是一个逻辑表达式，即这个表达式的返回值只能是

true或者false。

后面的花括号括起来的多行代码被称为代码块，一个代码块通常被当成一个整体来执行（除非运行过程中遇到return、break、continue等关键字，或者遇到了异常），因此这个代码块也被称为条件执行体。

如果if（）、else if（）和else后的代码块只有一行语句时，则可以省略花括号，因为单行语句本身就是一个整体，无须用花括号来把它们定义成一个整体。

对于任何的 if else语句，表面上看起来else后没有任何条件，或者else if后只有一个条件——但这不是真相：因为else的含义是“否则”——else本身就是一个条件！这也是把if、else后代码块统称为条件执行体的原因，else的隐含条件是对前面条件取反。

package com.liu.branch;

public class IfDemo1 {
    public static void main(String[] args) {
        //目标：需要掌握if分支三种形式的用法和执行流程

        //需求1：测量用户体温，发现体温高于37度就报警
        double t = 36.9;
        if (t>37){
            System.out.println("这个人的温度异常，把他赶紧带着~");
        }
        //需求2 ：发红包，你的钱包余额是99元，现在要发出90元
        //如果钱够，触发发红包的动作，如果钱不够，提升余额不足
        double money = 99;
        if (money>=90){
            System.out.println("发红包成功了~");
        }else {
            System.out.println("余额不足~");
        }
        //需求3：某个公司有一个绩效系统，根据员工的打分输出对应的绩效级别，
        // 【0，60)D，【60，80)C，【80，90)B，【90，100】A
        int score = 78;
        if (score >=0 && score < 60){
            System.out.println("您的绩效级别是：D");
        }else if(score >=60 && score < 80){
            System.out.println("您的绩效级别是：c");
        }else if(score >=80 && score < 90){
            System.out.println("您的绩效级别是：B");
        }else if(score >=90 && score <= 100){
            System.out.println("您的绩效级别是：A");
        }else {
            System.out.println("您录入的分数有毛病~");
        }
    }
}

if的第一种形式

if的第二种形式

if的第三种形式

if使用的几个常见问题

if（条件）{}，（）后不跟 “；” 否则{}种的代码将不受if控制了
如果if语句的{}中只有一行代码的情况，{}可以省略不写（但是不推荐省略）。

switch分支

是通过比较值来决定执行哪条分支。

switch语句由一个控制表达式和多个case标签组成，和if语句不同的是，switch语句后面的控制表达式的数据类型只能是byte、short、chat、int四种整数类型枚举类型和java.lang.String类型（从Java7才允许），不能是boolean类型。

switch语句往往需要在case标签后紧跟一个代码块，case标签作为这个代码块的标识

switch分支的执行流程

先执行表达式的值，再拿着这个值去与case后的值进行匹配
与哪个case后的值匹配为true，就执行哪个case块的代码，遇到break就跳出switch分支
如果全部case后的值与之匹配都是false，则执行default块的代码。

switch分支的导学案例：电子备忘录

周一：埋头苦干，解决bug；周二、；请求大牛程序员帮忙；周三：今晚啤酒 、龙虾、小烧烤
周四:主动帮助新来的女程序解决bug；周五：今晚吃鸡；周六：与王婆介绍的小芳相亲
周日：郁郁寡欢、准备上班

package com.liu.branch;

public class SwitchDemo2 {
    public static void main(String[] args) {
        //目标：掌握switch的写法，理解其执行流程

        //switch分支的导学案例：电子备忘录
        //周一：埋头苦干，解决bug；周二、；请求大牛程序员帮忙；周三：今晚啤酒 、龙虾、小烧烤
        //周四:主动帮助新来的女程序解决bug；周五：今晚吃鸡；周六：与王婆介绍的小芳相亲
        //周日：郁郁寡欢、准备上班
        String week = "周三";
        switch (week){
            case "周一":
                System.out.println("埋头苦干，解决bug");
                break;
            case "周二":
                System.out.println("请求大牛程序员帮忙");
                break;
            case "周三":
                System.out.println("今晚啤酒 、龙虾、小烧烤");
                break;
            case "周四":
                System.out.println("主动帮助新来的女程序解决bug");
                break;
            case "周五":
                System.out.println("今晚吃鸡烤");
                break;
            case "周六":
                System.out.println("与王婆介绍的小芳相亲");
                break;
            case "周日":
                System.out.println("郁郁寡欢、准备上班");
                break;
            default:
                System.out.println("您输入的星期信息肯定是不存在的~");
        }

    }
}

if、switch的比较，以及各自适合什么业务场景？

if在功能上远远强大于switch
当前条件是与一个一个值比较的时候，应该使用if分支
当条件是与一个一个的值比较的时候，switch分支更适合：格式良好，性能较好，代码优雅

使用switch分支的几点注意事项

表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String，不支持double、float、long
case给出的值不允许重复，且只能是字面量，不能是变量
正常使用switch的时候，不要忘记写break，否则会出现穿透现象

package com.liu.branch;

public class SwitchDemo3 {
    public static void main(String[] args) {
        //目标：搞清楚switch使用时的几点注意事项

        //1. 表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String，不支持double、float、long
        int a =10;
        double b = 0.1;
        double b2 = 0.2;
        double c = b+b2;
        System.out.println(c);
        switch (a){

        }
        //2、case给出的值不允许重复，且只能是字面量，不能是变量
        int i = 20;
        switch (i){
            case 20:
                break;
//            case 20:
//                break;
        }

        //3、正常使用switch的时候，不要忘记写break，否则会出现穿透现象
        String week = "周三";
        switch (week){
            case "周一":
                System.out.println("埋头苦干，解决bug");
                break;
            case "周二":
                System.out.println("请求大牛程序员帮忙");
                //break;
            case "周三":
                System.out.println("今晚啤酒 、龙虾、小烧烤");
                //break;
            case "周四":
                System.out.println("主动帮助新来的女程序解决bug");
                break;
            case "周五":
                System.out.println("今晚吃鸡烤");
                break;
            case "周六":
                System.out.println("与王婆介绍的小芳相亲");
                break;
            case "周日":
                System.out.println("郁郁寡欢、准备上班");
                break;
            default:
                System.out.println("您输入的星期信息肯定是不存在的~");
        }

    }
}

switch穿透性在某些情况下可以简化代码

当存在多个case分支的代码相同时，可以把相同的代码放到一个case块中，其他的case块都通过穿透性穿透到该case块执行代码即可，这样可以简化代码。
案例：周一：埋头苦干，解决bug ；周二：请求大牛程序员帮忙；周三：请求大牛程序员帮忙；周四：请求大牛程序员帮忙；周五：自己整理代码；周六：打游戏：周日：打游戏

package com.liu.branch;

public class SwitchDemo4 {
    public static void main(String[] args) {
        //案例：周一：埋头苦干，解决bug ；
        // 周二：请求大牛程序员帮忙 ；周三：请求大牛程序员帮忙 ；周四：请求大牛程序员帮忙 ；
        // 周五：自己整理代码；
        // 周六：打游戏：周日：打游戏
        String week = "周三";
        switch (week){
            case "周一":
                System.out.println("埋头苦干，解决bug");
                break;
            case "周二":
            case "周三":
            case "周四":
                System.out.println("请求大牛程序员帮忙");
                break;
            case "周五":
                System.out.println("自己解决代码");
                break;
            case "周六":
            case "周日":
                System.out.println("打游戏");
                break;
            default:
                System.out.println("您输入的星期信息肯定是不存在的~");
        }

    }
}

流程控制：循环结构：for循环、for循环案例

for循环

控制循环格式

for循环格式

执行流程

package com.liu.loop;

public class ForDemo1 {
    public static void main(String[] args) {
        //目标：需要同学们掌握for循环的书写格式，并理解其执行流程
        //需求：打印三行Hello World
        /*
        流程 ：
        首先会执行初始化：int i= 0 ;
        i = 0,判断循环条件 0<3,返回true，计算机会进入到循环中执行输出第一行 Hello World，
        接着执行迭代语句i++， i = 1,判断循环条件 1<3,返回true，计算机会进入到循环中执行输出第一行 Hello World，
        接着执行迭代语句i++， i = 2,判断循环条件 2<3,返回true，计算机会进入到循环中执行输出第一行 Hello World，
        接着执行迭代语句i++， i = 3,判断循环条件 3<3,不成立，返回false，循环立即结束。
         */
        for (int i = 0;i<3;i++) {
            // i = 0 1 2
            System.out.println("Hello World");
        }
            System.out.println("----------------------------------------");

            for (int i = 1; i <=5;i++){
                //i = 1 2 3 4 5
                System.out.println("Hello World 2");
            }
        System.out.println("----------------------------------------");

            for (int i = 1;i <= 10;i += 2){
                //1 3 5 7 9
                System.out.println("Hello World 3");
            }
    }
}

for循环在开发中的常见应用场景

减少代码的重复编写、灵活的控制程序的执行
批量生成数据

package com.liu.loop;

public class ForDemo2 {
    public static void main(String[] args) {
        //目标：掌握使用for批量产生数据
        for (int i = 0; i <= 100; i++) {
            System.out.println(i);
        }
        System.out.println("--------------------------");

        //需求：1-5之和
        // 2. 定义一个变量用于求和
        int sum1 = 0; //0 1 3 6 10 15
        //1.定义一个循环，先产生1-5，这5个数
        for (int i = 1; i <= 5; i++) {
            // i= 1 2 3 4 5
            sum1 += i; //等价 sum = sum + i;
        }
        System.out.println("1-5的数据和：" + sum1);

        System.out.println("-------------------------------------");

        //需求：1-100之和
        // 2. 定义一个变量用于求和
        int sum2 = 0;
        //1.定义一个循环，先产生1-5，这5个数
        for (int i = 1; i <= 100; i++) {
            sum2 += i; //等价 sum = sum + i;
        }
        System.out.println("1-100的数据和：" + sum2);

        System.out.println("----------------------------------");

        //2. 定义一个变量用于求和
        int sum3 = 0;
        //1. 定义一个循环产生1-100之间的奇数
        for (int i = 1;i < 100;i+=2){
            // i 1 3 5 7 ...
            sum3 +=i;
        }
        System.out.println("1-100之间的奇数和："+sum3);

        System.out.println("-------------------------------------");

        //2.定义一个变量用于累加数求和
        int sum4 = 0;
        //1. 定义一个循环产生1-100之间的每个奇数
        for (int i = 1;i<=100;i++){
            //i = 1 2 3 4 5 6 ... 99 100
            //2. 使用一个if分支，判断i此时记住的数据是否是奇数，是奇数我们才累加给一个变量
            if (i % 2 == 1){
                //1 3 5 7 9 ...99
                sum4 +=i;
            }
        }
        System.out.println("1-100之间的奇数和："+sum4);

    }

}

流程控制：循环结构：while循环、珠穆朗玛峰

while循环

package com.liu.loop;

public class WhileDemo3 {
    public static void main(String[] args) {
        //目标：掌握while循环的书写格式，以及理解其执行流程
        //需求：打印多行Hello World
        int i = 0;
        while (i < 5){
            // i= 0 1 2 3 4
            System.out.println("Hello World");
            i ++;
        }
    }
}

while和for有什么区别？什么时候用for，什么时候用while？

功能上是完全一样的，for能解决的，while也能解决，反正亦然。
使用规范：知道循环几次建议：使用for；不知道循环几次建议使用：while

案例：珠穆朗玛峰

需求：世界最高山峰珠穆朗玛峰高度是：8848.86米=8848860毫米，假如我有一张足够大的纸，它的厚度是0.1毫米。请问：该纸张折多少次，可以折成珠穆朗玛峰的高度？

（一开始不知道要循环多少次，则使用while）

分析：（1）定义变量存储珠穆朗玛峰的高度、纸张的高度；（2）使用while循环来控制纸张折叠，循环条件是（纸张厚度<山峰高度）；（3）循环每执行一次，就表示纸张折叠一次，并把纸张厚度变为原来两倍；（4）循环外定义计数变量count，循环每折叠一次纸张，让count变量 +1。

package com.liu.loop;

public class WhileText4 {
    public static void main(String[] args) {
        //目标：使用while循环解决问题，并理解什么情况下使用while、for

        //1.定义一个变量记住珠穆朗玛峰的高度和纸张的高度
        double peakHeight = 8848860;
        double paperThickness = 0.1;
        //3. 定义一个变量count 用于记住纸张折叠了多少次
        int count = 0;
        //2. 定义while循环控制纸张开始折叠
        while (paperThickness<peakHeight){
            //把纸张进行折叠，把纸张的厚度变为原来的2倍
            paperThickness = paperThickness * 2;
            count ++ ;
        }
        System.out.println("需要折叠多少次："+ count);
        System.out.println("最终纸张的厚度是："+ paperThickness);
    }
}

package com.liu.loop;

public class WhileText4 {
    public static void main(String[] args) {
        //目标：使用while循环解决问题，并理解什么情况下使用while、for

        //1.定义一个变量记住珠穆朗玛峰的高度和纸张的高度
        double peakHeight = 8848860;
        double paperThickness = 0.1;
        //3. 定义一个变量count 用于记住纸张折叠了多少次
        int count = 0;
        //2. 定义while循环控制纸张开始折叠
       for (;paperThickness<peakHeight;count ++){
            //把纸张进行折叠，把纸张的厚度变为原来的2倍
            paperThickness = paperThickness * 2;
        }
        System.out.println("需要折叠多少次："+ count);
        System.out.println("最终纸张的厚度是："+ paperThickness);
    }
}

流程控制：循环结构：do-while

do-while循环

package com.liu.loop;

public class DoWhileDemo5 {
    public static void main(String[] args) {
        //目标：掌握do-while循环的书写格式，执行流程，特点和应用场景
        //需求：打印多行Hello World
        int i = 0;
        do {
            System.out.println("Heool World");
            i ++;
        }while (i  < 3 );

        System.out.println("-----------------------------------");

        //特点：先执行后判断
        do {
            System.out.println("Hello World 2");
        }while (false);
    }
}

do-while循环的特点：

先执行后判断

三种循环的区别小结

三种循环区别

for循环和while循环（先判断后执行)；do...while（先执行后判断）
for循环和while循环的执行流程是一模一样的，功能上无区别，for能做的 while也能做，反之亦然。
使用规范：如果已知循环次数建议使用for循环，如果不清楚要循环多少次建议使用while循环。
其他区别：for循环中，控制循环的变量只在循环中使用。while循环中，控制循环的变量在循环后还可以继续使用。

package com.liu.loop;

public class DoWhileDemo5 {
    public static void main(String[] args) {


        System.out.println("----------------------------------------");

        for (int j = 0; j<3 ; j++){
            System.out.println("Hello World3");
        }
//        System.out.println(j); j变量只能在循环内使用

        int m = 0;
        while (m<3){
            System.out.println("Hello World");
            m++;
        }
        //m变量在循环后还可以继续使用
        System.out.println(m);//3
    }
}

流程控制：死循环，循环嵌套

死循环

可以一种执行下去的一种循环，如果没有干预不会停下来

死循环的写法

package com.liu.loop;

public class EndLessLoopDemon6 {
    public static void main(String[] args) {
        //目标：掌握死循环的写法

        //1.死循环第一种
//        for (int i = 0; ;i++){
//            System.out.println("Hello World");
//        }

//       //2.死循环第二种
//        while (true){
//            System.out.println("Hello World 2");
//        }

        //3.死循环第三种
        do{
            System.out.println("Hello World 3");
        }while (true);

    }
}

死循环的应用场景

做服务器程序

循环嵌套

循环中又包含循环
如果把一个循环放在另一个循环体内，那么就可以形成嵌套循环，嵌套混混既可以是for循环嵌套while循环，也可以是while循环嵌套do while循环········即各种类型的循环都可以作为外层循环，也可以作为内层循环。
当程序遇到嵌套循环时，如果外层循环的循环条件被允许，则开始执行外层循环的循环体，而内层循环将被外层循环的循环体来执行——只是内层循环需要反复执行自己的循环体而已。当内层循环的执行结束，且外层循环的循环体执行结束时，则再次计算外层循环的循环条件，决定是否再次开始执行外层循环的循环体。

package com.liu.loop;

public class LoopNestedDemo7 {
    public static void main(String[] args) {
    //目标：循环嵌套的执行流程

    //场景：假如你有对象，你犯错了，你对象罚你说：3天，每天五句我爱你
        //方法一
//        for (int i = 1;i<=3;i ++){
//            // i = 1 2 3
//            System.out.println("我爱你：" + i);
//            System.out.println("我爱你：" + i);
//            System.out.println("我爱你：" + i);
//            System.out.println("我爱你：" + i);
//            System.out.println("我爱你：" + i);
//            System.out.println("--------------------------------");
//
//        }

        //方法二
        for (int i = 1;i<=3;i ++){
           // i = 1 2 3
            for (int j = 1;j<=5;j++){
                System.out.println("我爱你：" + i);
            }
            System.out.println("我爱你：" + i);
            System.out.println("--------------------------------");
        }

        // 打印三行 ****
        //方法一
        for (int i = 1;i <=3;i++){
            // i = 1 2 3
            System.out.println("****");
        }

        System.out.println("--------------------------------");

        // 打印三行 ****
        //方法二
        for (int i = 1;i <=3;i++){
            // i = 1 2 3
            //定义一个循环控制每行打印多少列*
            for (int j = 1;j<=4;j++) {
                System.out.print("*"); // print 不换行
            }
            System.out.println();//换行
        }

    }

}

循环嵌套的特点

外部循环每循环一次，内部循环会全部执行完一轮。

跳转关键字：break、contine

Java语言没有提供goto语句来控制程序的跳转，这种做法提高了程序流程控制的可读性，但降低了程序流程控制的灵活性。为了弥补这种不足，Java提供了contine和break来控制循环结构。除此之外，return可以结束整个方法，当然也就结束了一次循环。

跳转关键字

break：跳出并结束当前所在循环的执行。
continue：用于跳出当前循环的当次执行，直接进入循环的下一次执行。

注意事项

break：只能用于结束所在循环，或者结束所在switch分支的执行。
continue：只能在循环中进行使用。

package com.liu.loop;

public class BreakAndContinueDemo8 {
    public static void main(String[] args) {
        //目标：掌握break和continue的作用
        //1. break :跳出并结束当前所在循环的执行
        //场景：假如你又有对象了，你犯错了，你对象罚你说：5句我爱你
        //说到第三句的时候心软了，让你别再说了。
        for (int i = 1;i<=5;i++){
            System.out.println("我爱你："+i);
            if (i==3){
                //说明已经说完了第三句了，心软了。
                break;//跳出并结束当前所在循环的执行
            }
        }

        //2、continue：跳出当前循环的当次执行，直接进入循环的下一次执行
        //场景：假如你有对象，你犯错了，你对象罚你洗碗5天。
        //第三天的时候，你表现很好，第三天不用洗碗，但是很快不解，第四天还是要继续的
        for (int i = 1;i<=5;i++){
            if(i==3){
                //已经到了第三天，第三天不用洗的。
                continue;
            }
            System.out.println("洗碗："+i);

        }
    }
}

break用于完全结束一个循环，跳出循环体，不管事哪种循环，一旦在循环体中遇到break，系统将完全结束该循环，开始执行循环之后的代码。
break语句不仅可以结束其所在的循环，还可以直接结束其外层循环。
continue只是忽略本次循环剩下语句，接着开始下一次循环，并不会终止循环。
break则是完全终止循环本身。

流程控制：随机数Random、Random案例

Random

作用：生成随机数

得到0~9的随机数的实现步骤

注意：

nextInt（n）功能只能生成：0 至 n-1 之间的随机数，不包含n。

package com.liu.random;

import java.util.Random;

public class RandomDemo1 {
    public static void main(String[] args) {

    //目标：掌握使用random生成随机数的步骤
    //1、导包
    //2、创建一个random的对象，用于生成一个随机数
    Random r = new Random();
    //3、调用Random提供的功能，nextInt得到随机数
        for (int i = 1;i<=20;i++) {
            int data = r.nextInt(10);//0~9
            System.out.println(data);
        }

    }
}

Random生成指定区间随机数

例如：要生成 1-10 之间的随机数，程序怎么实现？

技巧：减加法

 System.out.println("-----------------------------------------");

        //生成 1-10 之间的随机数
        // 1-10 =》 -1 =》 （0-9）+1
        for (int i = 1;i<=20;i++) {
            int data2 = r.nextInt(10);
            System.out.println(data2);
        }

        System.out.println("--------------------------------------");
        
        // 3-17 =》 -3 =》（0-14）+3
        for (int i =1;i<=20;i++) {
            int data3 = r.nextInt(15)+3;
            System.out.println(data3);
        }

如何生成 65 - 91 之间的随机数？

65 - 91 ==》 -65 ==》（0 - 26）+65
int number = r . nextInt(27) + 65 ;

猜数字游戏

需求：随机生成一个 1- 100 之间的数据，提示用户猜测，猜大提示过大，猜小提示过小，直到猜中结束游戏。
分析： 1、先随机生成一个 1- 100 之间的数据。2、定义一个死循环让用户可以一直猜测。 3、在死循环里，每次都提示用户输入一个猜测的数字，猜大提示过大，猜小提示过小，猜中则结束游戏。

package com.liu.random;

import java.util.Random;
import java.util.Scanner;

public class RandomTest2 {
    public static void main(String[] args) {
        //1、随机产生一个 1- 100 之间的数据，作为中将号码
        Random r = new Random();
        int luckNumber = r.nextInt(100)+1;
        //2、定义一个死循环，让用户不断的猜测数据
        Scanner sc = new Scanner(System.in);
        while (true){
            //提示用户猜测
            System.out.println("请您输入猜测的数据：");
            int guestNumber = sc.nextInt();

            //3、判断用户猜测的数字与幸运号码的大小情况
            if (guestNumber > luckNumber){
                System.out.println("您猜测的数字过大！");
            }else if (guestNumber<luckNumber){
                System.out.println("您猜测的数字过小~");
            }else {
                System.out.println("恭喜您，猜测成功了，可以买单了！");
                break;//结束死循环
            }
        }
    }
}

阶段总结：分支结构、循环结构、跳转关键字：break和continue、随机数Random

程序流程控制

就是控制代码怎么去执行的。
三种结构：顺序结构、分支结构、循环结构
分支结构：if、switch

分支结构

if　的作用：可以判断条件来决定执行哪个分支
if　的格式：
switch　作用：根据表达式的值来进行值匹配选择对应的分支执行
switch　格式：
if　和　switch　的区别：都是做分支操作的；if的功能更强大；如果是值匹配的操作建议用switch，格式清晰，性能较好！
switch　的注意事项：表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String，不支持double、float、long　；case给出的值不允许重复，且只能是字面量，不能是变量　；　正常使用switch的时候，不要忘记写break，否则会出现穿透现象
switch的穿透性的含义：switch中没有写break，遇到了case会一直往下走，直到遇到break才会跳出。
switch的穿透性适合做多个值对应的case块的操作是相同的！可以穿透到一个位置集中处理，这样可以提高开发效率，降低代码重复

循环结构

循环结构的作用：控制一段代码重复的执行多次
for循环格式：
while循环格式：
do—while循环格式：
do—while突出特点：一定会执行一次循环体语句！再判断循环条件
循环结构的区别：for和while都是先判断后执行，do—while第一次是先执行然后再判断，for和while在功能上完全一样，流程也是一样的，如果一开始就知道循环几次用for，如果一开始不知道循环用几次用while。
死循环是一直执行下去：
死循环的写法：

跳转关键字：break和continue

break：跳出并结束当前所在循环的执行。
continue：用于跳出当前循环的当次执行，直接进入循环的下一次执行。
break：只能用于结束所在循环，或者结束所在switch分支的执行。
continue：只能在循环中进行使用。

案例技术：随机数Random类

作用：产生一个随机数
步骤：导包（自动做的：import java.until.Random）；创建随机数对象：Random r = new Random（）；开始得到随机数：int data = r.nextInt()；//0-9
生产指定区间的随机数：(1)、减加发：1-10 ==》-1 ==》（0-9）+1 ； int data = r.nextInt(10)+1; （2）、Java其实给了我们一些功能直接就能得到指定区间的随机数：Random r = new Random；//10-30 ；for（int i= 0；i<100；i++）{int data = r.nextInt(10,31)；System.out.println(data)；}

认识数组

数组是什么

数组就是一个容器，用来存储一批同类型的数据。

例子

有变量，为什么还用数组？

数组的定义和访问

静态初始化数组

定义数组的时候直接给数组赋值。

静态初始化数组的格式：

注意：

“数组类型【】数组名” 也可以写成 “数组类型数组名【】”
什么类型的数组只能存放什么类型的数据

package com.liu.define;

public class ArrayDemo1 {
    public static void main(String[] args) {
        //目标：掌握数组的定义方式一：静态初始化数组

        //1. 数据类型【】 数组名 = new 数据类型【】{元素1，元素2，元素3，······}
        int[] ages = new int[]{12,24,36};
        double[] scores = new double[]{89.8,99.5,59.5,88};

        //2.简化写法
        //数据类型【】 数组名 = {元素1，元素2，元素3，·······}
        int[] ages2 = {12,24,32};
        double[] scores2 = {89.8,99.5,59.5,88};

        //3.数据类型【】 数组名 也可以写成 数据类型 数组名【】
        int[] ages3 = {12,24,36};
        double scores3[] = {89.8,99.5,59.5,88};
        

    }
}

数组在计算机中的基本原理

注意：

数组变量名中存储的是数组在内存中的地址，数组是一种引用数据类型。

package com.liu.define;

public class ArrayDemo1 {
    public static void main(String[] args) {
        //目标：掌握数组的定义方式一：静态初始化数组

        //1. 数据类型【】 数组名 = new 数据类型【】{元素1，元素2，元素3，······}
        int[] ages = new int[]{12,24,36};
        double[] scores = new double[]{89.8,99.5,59.5,88};
        System.out.println(ages);
        System.out.println(scores);

数组的访问

数组名【索引】

数组的长度属性：length

数组的最大索引

数组名.length - 1 //前提：元素个数大于0

如果访问数组时，使用的索引超过了最大索引会出什么问题

执行程序时会出现bug，出现一个索引越界的异常提示。

package com.liu.define;

public class ArrayDemo2 {
    public static void main(String[] args) {
        //目标：掌握数组的访问
        int[] arr = {12,24,36};
                    // 0  1   2
        //1.访问数组的全部变量
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //System.out.println(arr[3]);

        //2. 修改数组中的数据
        arr[0] = 66;
        arr[2] = 100;
        System.out.println(arr[0]);//66
        System.out.println(arr[1]);//24
        System.out.println(arr[2]);//100

        //3. 访问数组元素个数，数组名.length
        System.out.println(arr.length);

        //技巧：获取数据的最大索引
        System.out.println(arr.length-1);

        int[] arr2 ={};
        System.out.println(arr2.length - 1 );


    }
}

数组的遍历

什么是数组遍历：

遍历：就是一个一个数据的访问

为什么要遍历数组？

求和元素搜索找最大值、最小值

package com.liu.define;

public class ArrayDemo3 {
    public static void main(String[] args) {
        //目标：掌握数组的遍历
        int[] ages = {12,24,36};
                      //0   1  2

//        System.out.println(ages[0]);
//        System.out.println(ages[1]);
//        System.out.println(ages[2]);

        for (int i = 0;i < ages.length; i ++){ //ages.fori 回车
            // i= 0 1 2
            System.out.println(ages[i]);
        }

    }
}

案例训练

数组遍历求和-求和

需求：某部门5名员工的销售额分别是：16、26、36、6、100，请计算出他们部门的总销售额。

分析：1.把这5个数据拿到程序中去 ===》使用数组 int【】 money = {16，26，36，6，100}； 2.遍历数组中的每个数据，然后再外面定义求和变量把他们累加起来。

package com.liu.define;

public class ArrayTest4 {
    public static void main(String[] args) {
        //目标：完成对数组的元素求和
        //1. 定义一个数组存储5名员工的销售额
        int[] money = {16,26,36,6,100};
                        //0  1 2  3  4

        //3.定义一个变量用于累加求和
        int sum = 0 ;

        //2.遍历数组中的每个数据
        for (int i = 0;i < money.length;i++){
            //0  1 2  3  4
            sum += money[i];
        }
        System.out.println("员工的销售总额：" + sum);
    }
}

动态初始化数组

数组的动态初始化

定义数组时先不存入具体的元素值，只确定数组存储的数据类型和数组的长度

数组的动态初始化格式：

数据类型【】数组名 = new 数据类型【长度】；

int[] arr = new int[3];

//后赋值

arr[0] = 10;

System.out.println(arr[0]); //10

温馨提示

静态初始化和动态初始化数组的写法时独立的，不可以混用。

int[] arr = new int[3]{30,40,50}; 错误写法

package com.liu.define;

public class ArrayDemo5 {
    public static void main(String[] args) {
        //目标：掌握定义数组的方式而：动态初始化数组
        //1. 数据类型【】 数组名= new 数据类型【长度】
        int[] ages = new int[3]; //ages = [0,0,0]

        System.out.println(ages[0]);
        System.out.println(ages[1]);
        System.out.println(ages[2]);

        ages[0]=12;
        ages[1]=18;
        ages[2]=32;

        System.out.println(ages[0]);
        System.out.println(ages[1]);
        System.out.println(ages[2]);

//        int[] arr = new int[3]{0,20,50}; 错误写法

    }
}

动态初始化数组元素默认值规则：

char[] chars = new  char[3]; // [0,0,0]
        System.out.println((int)chars[0]); //char是字符类型 打印出来的会是底层的字符 ，因此可以转换成int型
        System.out.println((int)chars[2]);

        double[] score = new double[80];
        System.out.println(score[0]);
        System.out.println(score[79]);

        boolean[] flags = new boolean[100];
        System.out.println(flags[0]);
        System.out.println(flags[99]);

        String[] names = new String[80];
        System.out.println(names[0]);
        System.out.println(names[79]);

两种数组定义的方法各自适合什场景？

动态初始化：适合开发不确定具体元素值，只知道元素个数的业务场景。
静态初始化：适合一开始就知道要存入哪些元素值的业务场景。

案例训练

评委打分案例

需求：某歌唱比赛，需要开发一个系统：可以录入6名评委的打分，录入完毕后立即输出平均分做出选手得分。

分析：1. 6名评委的打分是后期录入的，一开始不知道具体的分数，因此定义一个动态初始化的数组存分数。double[] scores = new double[6]; 2.遍历数组中的每个位置，每次提示用户录入一个评委的分数，并存入到数组对应的位置。 3.遍历数组中的每个元素进行求和，最终算出平均分打印出来即可。

package com.liu.define;

import java.util.Scanner;

public class ArrayTest6 {
    public static void main(String[] args) {
        //目标：完成评委打分的案例
        //1.定义一个动态初始化的数组 负责后期存储6个评委的打分
        double[] scores = new double[6];

        Scanner sc = new Scanner(System.in);

        //2.遍历数组中的每个位置，录入评委的分数，存入到数组中去
        for (int i = 0;i < scores.length;i++){
            // i = 0 1 2 3 4 5
            System.out.println("请输入当前第"+(i+1)+"个评委的分数：");
            double score = sc.nextDouble();
            scores[i] = score;
        }

        //3.遍历数组中的每个数进行求和
        double sum = 0 ;
        for (int i= 0;i< scores.length;i++){
            sum += scores[i];
        }
        System.out.println("选手最终得分是："+sum / scores.length);
    }
}

数组在计算机的执行原理

package com.liu.memony;

public class ArrayDemo1 {
    public static void main(String[] args) {
        //目标：掌握普通变量，数组在计算机中的执行原理，Java程序在计算机中的执行过程
        int a = 20;
        System.out.println(a);

        int[] arr = new int[]{11,22,33};
        System.out.println(arr);

        System.out.println(arr[1]);

        arr[0]=44;
        arr[1]=55;
        arr[2]=66;

        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

    }
}

Java内存分配介绍

数组在计算机中的执行原理

总结：

1、运行一个Java程序，住哟看JVM中包含的哪几个部分？

答：方法区、栈内存、堆内存

2、简单说说 int a = 20 ; int [] arr = new int[3] 这两行代码的执行原理？

答：

a是变量，直接放在栈中，a变量中存储的数据就是20这个值

new int[3] 是创建一个数组对象，会在堆内存中开辟区域存储3个整数

arr 是变量，在栈中，arr中存储的是数组对象在堆内存中的地址值

package com.liu.memony;

public class ArrayDemo2 {
    public static void main(String[] args) {

    //目标：认识多个变量面向同一个数组对象的形式，并掌握其注意事项
    int[] arr1 = {11,22,33};

    //把int类型的数组变量arr1赋值给int类型的数组类型变量arr2
    int[] arr2 = arr1;

        System.out.println(arr1);
        System.out.println(arr2);

        arr2[1] = 99;
        System.out.println(arr1[1]);

    }
}

多个变量指向同一个数组

使用数组时常见的一个问题

如果某个数组变量存储的地址是null，那么该变量将不再指向任何数组对象

arr2 = null; //拿到的数组变量中存储的就是null
System.out.println(arr2);

//System.out.println(arr2[0]); //出现报错；空指针异常
//System.out.println(arr2.length); //出现报错，空指针异常

总结：

1、多个数组变量，指向同一个数组对象的原因是什么？需要什么？

答：

多个数组变量中存储的是同一个数组对象的地址

多个变量修改的都是同一个数组对象中的数据

2、如果某个数组变量中存储的null，代表什么意思？需要注意什么？

答：

代码这个数组变量没有指向数组对象

可以输出这个变量，但是不能用这个数组变量去访问数据或者访问数组长度，会报空指针异常：NullPointerException

数组案例：求最大值，反转

求最大值

package com.liu.demo;

public class Test1 {
    public static void main(String[] args) {
        // 目标：掌握数组元素求最值
        //1. 把颜值数据拿到程序中来，用数组装起来
        int[] faceScores = {15,9000,10000,20000,9500,-5};
        //                   0  1     2    3     4    5

        //2.定义一个变量用于最终记住最大值
        int max = faceScores[0];

        //3.从数组的第二个位置开始遍历 i
        for (int i = 0;i<faceScores.length;i++){
            // i = 1 2 3 4 5
            //判断下一个当前遍历的这个数据，是否大于最大值变量max存储的数据，当前遍历的数据需要赋值max
            if (faceScores[i]>max){
                max = faceScores[i];
            }
        }
        System.out.println("最高颜值是：" + max);

    }
}

总结：

求数组中的最大值，我们是如何实现的？

答：

1. 把数据拿到程序中去，用数组装起来

2. 定义一个变量max用于记录最大值，max变量默认存储了第一个元素值作为参照物

3. 从第二个位置开始遍历数组的数据，如果当前元素大于变量存储的数据，则替换变量存储的值为该元素

4. 循环结束后输出max变量即可

数组反转

需求：某个数组有5个数据：10，20，30，40，50，请将这个数组中的数据进行反转

【10，20，30，40，50】反转后【50，40，30，20，10】

分析：

数组反转操作实际上就是：依次前后交换数据即可实现。

package com.liu.demo;

public class Test2 {
    public static void main(String[] args) {

    //目标：实现数组反转
    //1.准备一个数组
    int[] arr = {10,20,30,40,50};
    //           i            j

    //2. 定义一个循环，设计两个变量，一个在前，一个在后
        for (int i = 0,j = arr.length-1;i < j;i++,j--){
            //arr[i]  arr[j]
            //交换
            //1.定义一个临时变量记住后一处位置的值
            int temp = arr[j];
            //2.把前一个位置的值赋值给后一个位置了
            arr[j] =arr[i];
            //3.把临时变量中记住的后一个位置处的值赋值给前一个位置处
            arr[i] = temp;

        }
            //4.遍历数组中的每个数据，看是否反转成功了
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i] + " ");
            }
    }
}

总结：

1.我们如何完成数组的反转的？

答：

使用for循环，控制让数组的前后位置的元素，依次交换

2. 数组如何实现前后元素交换的？

答：

定义一个临时变量记住后一个位置处的元素值

再把前一个位置处的元素值，赋值给后一个位置处

最后把临时变量记住的后一个位置的值赋值给前一个位置处

Java数组：随机排名，debug

随机排名

需求：某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇报。请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。

分析：

在程序中录入5名员工的工号存储起来 -----> 使用动态初始化数组的方式

依次遍历数组中的每个数据

每遍历一个数据，都随机一个索引值出来，让当前数据与该索引位置处的数据进行交换。

输出数据中的内容即可

package com.liu.demo;

import java.util.Random;
import java.util.Scanner;

public class Test3 {
    public static void main(String[] args) {
        //目标：完成随机排名
        //1.定义一个动态初始化的数组用于存储5名员工的工号
        int[] codes = new int[5];
        //[0,0,0,0,0]
        // 0 1 2 3 4

        //2.提示用户录入5名用户的工号
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            // i = 0 1 2 3 4
            System.out.println("请您输入当前第" + (i + 1) + "员工的工号：");
            int code = sc.nextInt();
            codes[i] = code;
        }

        //3.打乱数组中的元素顺序
        // [12,33,54,26,8]
        //   i    index
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
            //code[i]
            //每遍历到一个数据，都随机一个数组索引范围内的值，然后让当前遍历的数据与该索引位置处的值交换
            int index = r.nextInt(codes.length);//0 - 4
            //定义一个临时变量记住index位置的值
            int temp = codes[index];
            //把i位置处的值赋值给index位置处
            codes[index] = codes[i];
            //把index位置处的值赋值给i位置处
            codes[i] = temp;
        }
        //4.遍历数组中的工号输出即可
        for (int i = 0; i < codes.length; i++) {
            System.out.print(codes[i] + " ");
        }
    }

}

随机交换排名的其他使用场景

随机发牌

Debug工具

IDEA自带的断点调试工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况。

Debug工具使用方法

第一步设置断点

第二步右击选择Debug······

补充：可以看详细的过程、详细的代码执行过程

总结：

总结：数组

数组

数组的作用：就是一个数据，用于在程序中存储一批同种类型的数据
数组的定义静态初始化：格式1 数据类型[] 数组名称 = new 数据类型[] {元素1，元素2 ，元素3，······}
数组的定义静态初始化：格式2 数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，元素3，······]
数组的定义静态初始化特点：在定义数组的时候同时为数组确定了数据
数组的定义静态初始化使用场景：一旦确定了数据的具体值，我没就用这种方式存储批量数据
数组的定义动态初始化格式：数据类型[] 数组名称 = new 数据类型[长度]
数组的定义动态初始化特点：一开始值确定数组的类型和长度，不确定具体存入的数据值
数组的定义动态初始化使用场景：适合一开始不能确定具体数据的情况，先定数组，后赋值数据进去
数组的访问格式：数组名称[索引]
数组的访问取值：int data = arr[i]
数组的访问赋值：arr[i] = 22
数组的访问长度：arr.length[]
数组的注意事项：什么类型的数组只能存放什么类型的数据；数据类型[] 变量名称可以写成数据类型变量名称[] ; 数组一旦定义出来，程序执行的过程中，长度、类型就被固定了
动态初始化数组的元素存在默认值：

数组的遍历

什么是遍历：一个一个的访问数据
为什么要遍历：业务开发中都需要用到，统计数据，搜索数
数组如何遍历：

数组的案例

参见代码

数组的内存图

Java的内存分配：方法区：放Class文件的；栈内存：运行的方法，main方法，定义的变量；堆内存：new出来的对象，都在堆内存中

数组使用的常见问题：

不要访问超过数组的最大索引，否则出现数组访问越界异常；
空指针异常问题：int[] arr = null;

Debug工具的使用

找问题并解决：断点调试工具
基本使用步骤：打断点；右键使用Debug使用；控制一行一行的往下执行

Java方法：方法概述

方法是什么

方法是一种语法结构，他可以把一段代码封装成一个功能，以便重复调用。

方法的完整格式

package com.liu.define;

public class MethodDemo1 {
    public static void main(String[] args) {
        //目标：掌握定义方法的完整格式，高清楚使用方法的好处
        //需求：假如现在很多程序员都要进行2个整数的求和操作

        //1.李工程师
        int rs = sum(10,20);
        System.out.println(rs);

        //2. 张工程师
        int rs2 = sum(30,20);
        System.out.println(rs2);
    }

    public static int sum(int a,int b){
        int c = a + b;
        return c;
    }
}

示例：

方法如何执行？

方法定义后，必须调用才可以跑起来，调用格式：方法名（···）；

方法的调用流程：Debug工具

方法定义时几个注意点

方法的修饰符：暂时都使用 public static 修饰
方法申明了具体的返回值类型，内部必须使用 return 返回对应类型的数据
形参列表可以有多个，甚至可以没有；如果有多个形参，多个形参必须使用 ”，“ 隔开，且不能给初始化值。

使用方法的好处？

提高了代码的复用性，提高了开发效率。

让程序的逻辑更清晰

Java方法：方法定义的其他形式，常见问题

方法的其他形式

方法定义时：需要按照方法解决的实际业务需求，来设计合理的方法形式解决问题。

无参数，无返回值

package com.liu.define;

public class MethodDemo2 {
    public static void main(String[] args) {
        //目标：掌握按照方法解决的实际业务需求不同，设计成合理的方法形式来解决问题
        //需求：打印三行hello world
        printHeoolWorld();

        System.out.println("-----------------------------------");

        printHeoolWorld();
    }

    /**
     * 无参数，无返回值的方法
     */
    public static void printHeoolWorld(){
        for (int i = 0; i < 3; i++) {
            System.out.println("Hello World");
        }
    }
}

有参数，有返回值

package com.liu.define;

public class MethodDemo2 {
    public static void main(String[] args) {
        //目标：掌握按照方法解决的实际业务需求不同，设计成合理的方法形式来解决问题
        //需求：打印多行hello world
        printHeoolWorld(3);

        System.out.println("-----------------------------------");

        printHeoolWorld(6);
    }

    /**
     * 有参数，无返回值的方法
     */
    public static void printHeoolWorld(int n){
        for (int i = 0; i < n; i++) {
            System.out.println("Hello World");
        }
    }
}

注意事项

如果方法不需要返回数据，返回值类型必须申明成void（无返回值申明），此时方法内部不可以使用return返回数据。
方法如果不需要接收数据，则不需要定义形参，且调用方法时也不可以传数据给方法了
没有参数，且没有返回值类型（void）申明方法，称为无参数、无返回值的方法，依次类推。

总结：

如果方法不需要接收数据处理，不需要返回数据，应该怎么办？要注意什么

方法不需要接收数据，则形参列表可以不写；方法不需要返回数据，则申明返回值类型为void
方法没有申明返回值类型（void），内部不能使用return返回数据
方法如果没有形参列表，调用的时候则不能传入参数值，否则报错

方法使用时的常见问题：

方法在类中的位置放前放后无所谓，但一个方法不能定义在另一个方法里面
方法的返回值类型写void（无返回申明）时，方法内不能使用return返回数据，如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据
return语句的下面，不能编写代码，属于无效的代码，执行不到这儿
方法不调用就不会执行，调用方法时，传给方法的数据，必须严格匹配方法的参数情况
调用有返回值的方法有三种方式：1.可以定义变量接收结果 2. 或者直接输出调用 3. 甚至直接调用；
调用无返回值的方法，只有一种：1. 只直接调用

Java方法：方法的案例

设计方法的技巧，主要关注三方面：

方法是否需要接收数据进行处理？
方法是否需要返回数据？
方法要处理的业务（编程能力）

案例：计算1-n的和

需求：求1-n的和

分析：

1.方法是否需要接收数据进行处理？

需要接收n具体的值，因此形参声明为：int n

2.方法是否需要返回数据？

需要返回1-n的求和结果，因此返回值类型声明为int

3.方法内部的业务：

完成求1-n的和并返回

package com.liu.define;

public class MethodTest4 {
    public static void main(String[] args) {
        //目标：掌握设计方法的技巧
        int rs = add(5);
        System.out.println("1-5的和是：" + rs);

        int rs2 = add(100);
        System.out.println("1-100的求和是：" + rs2);

    }
    public static int add(int n){
        int sum = 0 ;
        for (int i = 1; i < n; i++) {
           // i = 1 2 3 ```` n
            sum +=i;
        }
        return sum;
    }
}

案例：判断一个整数是奇数还是偶数

需求：判断一个整数是奇数还是偶数，并把判断的结果输出来

分析：

1. 方法是否需要接收数据进行处理？

需要接收一个整数来判断，因此形参声明为：int number

2. 方法是否需要返回数据？

方法内部判断完后直接输出结果即可，无需返回，因此返回值类型声明为：void

3. 方法内部的业务：

通过if语句判断number是奇数还是偶数，并输出结果

package com.liu.define;

public class MethodTest4 {
    public static void main(String[] args) {
        //目标：掌握设计方法的技巧
        int rs = add(5);
        System.out.println("1-5的和是：" + rs);

        int rs2 = add(100);
        System.out.println("1-100的求和是：" + rs2);

        System.out.println("-------------------------------");

        judge(10);
        judge(7);
    }

    public static void judge(int number){
        if (number % 2 == 0){
            System.out.println(number + "是一个偶数！");
        }else{
            System.out.println(number + "是一个奇数！");
        }
    }

    public static int add(int n){
        int sum = 0 ;
        for (int i = 1; i < n; i++) {
           // i = 1 2 3 ```` n
            sum +=i;
        }
        return sum;
    }
}

总结：

1.定义方法重点关注的是哪几点？

方法是否需要接收数据？也就是是否需要定义形参列表

方法是否需要返回数据？也就是是否需要声明具体的返回值类型

2. 如何设计方法完成1-n的求和？

3. 我没如何设计方法判断一个整数是奇数还是偶数的？

Java方法：方法在计算机中的执行

方法在计算机中的执行原理

方法被调用的时候，是进入到栈内存中运行。

总结：

1.方法的运行区域在哪里？

栈内存

2. 栈有什么特点？方法为什么要在栈中运行自己

先进先出

保证一个方法调用完另一个方法后，可以回来

Java方法：方法参数传递

Java的参数传递机制都是：值传递

所谓值传递：指的是在传输实参给方法的形参的时候，传输的是实参变量中存储的值的副本
实参：在方法内部定义的变量
形参：定义方法时 “（···）” 中所声明的的参数

基本类型的参数传递：

package com.liu.parameter;

public class MethodDemo1 {
    public static void main(String[] args) {
        //目标：理解方法的参数传递机制：值传递
        int a = 10;
        change(a); //change(10);
        System.out.println("main:" + a); //10
    }

    public static void  change(int a){
        System.out.println("change1:" + a); //10
        a= 20;
        System.out.println("change2:" + a); //20
    }
}

引用类型的参数传递

package com.liu.parameter;

public class MethodDemo2 {
    public static void main(String[] args) {
        //目标：理解引用类型的传递机制
        int[] arrs = new  int[]{10,10,30};
        change(arrs);
        System.out.println("main:"+ arrs[1]);
    }
    public  static  void change(int[] arrs){
        System.out.println("方法内1：" + arrs[1]);
        arrs[1] = 222;
        System.out.println("方法内2 ："+ arrs[1]);
    }
}

总结：基本类型和引用类型的参数在传递的时候有什么不同？

都是值传递
基本类型的参数传输传输存储的数据值
引用类型的参数传输存储的地址值

Java方法：参数传递的案例

案例：打印int类型的数组内容

需求：输出一个int类型的数组内容，要求输出格式为：【11，22，33，44，55】

分析：1.方法是否需要接收数据进行处理？需要接收一个ingt类型的数组，因此形参声明为：int[] arr 2. 方法是否需要返回数据？方法内部直接输出数组内容即可，无需返回，因此返回值类型声明为：void 3. 方法内部的业务：遍历数组，并输出相应的内容

package com.liu.parameter;

public class MethodTest3 {
    public static void main(String[] args) {
        //目标：完成打印int类型的数组你内容
        int[] arr = new int[]{10,30,50,70};
        printArray(arr);
    }
    public static void printArray(int[] arr){
        System.out.print("[");
        //直接遍历接到的数组元素
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length-1){
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i]+",");
            }
        }
        System.out.println("]");
    }
}

package com.liu.parameter;

public class MethodTest3 {
    public static void main(String[] args) {
        //目标：完成打印int类型的数组你内容
        int[] arr = new int[]{10,30,50,70};
        printArray(arr);
    }
    public static void printArray(int[] arr){
        System.out.print("[");
        //直接遍历接到的数组元素
        for (int i = 0; i < arr.length; i++) {
//            if(i == arr.length-1){
//                System.out.print(arr[i]);
//            }else {
//                System.out.print(arr[i]+",");
//            }
            System.out.print(i == arr.length-1 ? arr[i]:arr[i] + ",");
        }
        System.out.println("]");
    }
}

package com.liu.parameter;

public class MethodTest3 {
    public static void main(String[] args) {
        //目标：完成打印int类型的数组你内容
        int[] arr = new int[]{10,30,50,70};
        printArray(arr);

        int[] arr2 = null;
        printArray(arr2);

        int[] arr3 ={};
        printArray(arr3);
    }

    public static void printArray(int[] arr){

        if (arr == null) {
            System.out.println(arr);//null
            return;//跳出当前方法
        }

        System.out.print("[");
        //直接遍历接到的数组元素
        for (int i = 0; i < arr.length; i++) {
//            if(i == arr.length-1){
//                System.out.print(arr[i]);
//            }else {
//                System.out.print(arr[i]+",");
//            }
            System.out.print(i == arr.length-1 ? arr[i]:arr[i] + ",");
        }
        System.out.println("]");
    }
}

案例：比较两个int类型的数组是否一样，返回true或者false

需求：如果两个int类型的数组，元素个数，对应位置的元素内容都是一样的则认为这2个数组是一模一样的

分析：1.方法是否需要接收数据进行处理？需要接收两个int类型的数组，因此，形参声明为：int[] arr1,int[] arr2 2. 方法是否需要返回数据？方法判断完后需要返回：true、false，因此，返回值类型声明为boolean类型 3.方法内部的业务：判断两个数组内容是否一样。

package com.liu.parameter;

public class MethodTest4 {
    public static void main(String[] args) {
        //目标：完成判断两个类型的数组是否一样
//        int[] arr1 = null;
        int[] arr1 = {10,20,30,40};
        int[] arr2 ={10,20,30};
        System.out.println(equals(arr1,arr2));
    }

    public static boolean equals(int[] arr1,int[] arr2) {
        //1.判断啊arr1和arr2是否都是null
        if (arr1 == null && arr2 == null) {
            return true;//相等的
        }

        //2.判断arr1是null，或者arr2是null
        if (arr1 == null || arr2 == null) {
            return false;//不相等
        }
        //3. 判断2个数组传递长度是否一样，如果长度不一样直接返回false
        if (arr1.length != arr2.length) {
            return false; //不相等
        }

        //4. 两个数组的长度是一样的，接着比较它们的内容是否一样
        //arr1 = [10,20,30]
        //arr2 = [10,20,30]
        for (int i = 0; i < arr1.length; i++) {
            //判断当前位置2个数组的元素是否都一样，不一样直接返回false
            if (arr1[i] != arr2[i]) {
                return false; //不相等
            }
        }
        return true;//两个数组是一样的

    }
}

Java方法：方法重载，return关键字

方法重载

一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。

package com.liu.overload;

public class MethodOverLoadDemo1 {
    public static void main(String[] args) {
        //目标：认识方法重载并掌握其应用场景
        test();
        test(100);

    }
    public static void  test(){
        System.out.println("==test1==");

    }
    public static  void test(int a){
        System.out.println("==test2==" +a);
    }
}

方法重载的注意注意事项：

一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如：修饰符，返回值类型是否都无所谓）。
形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称。

方法重载的应用场景

开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的

案例导学

开发武器系统，功能需求如下：

1. 可以默认发一枚武器

2. 可以指定地区发射一枚武器

3. 可以指定地区发射多枚武器

package com.liu.overload;

public class MethodTest2 {
    public static void main(String[] args) {
        //目标：掌握方法重载的应用场景
        fire();
        fire("米国",999);
    }

    public static void fire(){
        fire("岛国");
    }

    public static void fire(String country){
       fire(country,1);
    }

    public static void fire(String country,int number){
        System.out.println("发射了" + number + "枚武器给" + country);
    }
}

return关键字在方法中单独使用

return：可以用在无返回值的方法中，作用是：立即跳出并结束当前方法的执行

package com.liu.returnDemo;

public class ReturnDemo1 {
    public static void main(String[] args) {
        //目标：掌握return单独使用；
        //return：在无返回值方法中的使用，跳出并立即结束当前方法的执行
        System.out.println("程序开始...");
        chu(10,0);
        System.out.println("程序结束...");
    }

    public static void chu(int a,int b){
        if (b == 0){
            System.out.println("您的数据有问题，不能除0");
            return;//跳出并结束当前方法的执行
        }
        int c = a / b;

    }
}

return：跳出并立即结束所在方法的执行

break：跳出并结束当前所在循环的执行

continue：结束当前所在循环的当次继续，进入下一次执行

总结：方法

方法的作用：封装一段代码的语法结构，可以被重复调用，以此提高代码的复用性，提高开发效率，让程序逻辑更清晰
方法的完整定义格式：
方法的其他定义格式：如果方法中没有结果数据需要返回，返回值类型声明为：void
方法的调用：必须调用方法，方法才可以跑起来；有返回值类型声明的方法的调用：（1）、赋值调用：定义变量接收方法的结果（2）、输出调用：放在输出语句中调用（3）、直接调用：方法还是会执行的，只是返回的结果我们不要了；无返回值的方法调用：直接调用一下。
方法的注意事项：如果方法不需要返回数据，返回值类型必须申明成void（无返回值申明），此时方法内部不可以使用return返回数据。方法如果不需要接收数据，则不需要定义形参，且调用方法时也不可以传数据给方法了。没有参数，且没有返回值类型（void）申明方法，称为无参数、无返回值的方法，依次类推。
方法的参数传递机制：值传递你传输实参给方法的形参，传输的不是实参本身，而是实参中存储的数据的值的一个副本；无论是基本数据类型还是引用数据类型的参数，都是满足值的传递，基本类型的参数传输的是存储的数据，引用类型的参数传输的是存储的地址值。
方法重载：同一个类中，方法名称相同，形参列表必须不同，才是方法重载。
方法重载的好处：方法名相同标记是同一个功能，可读性好！形参列表不同，体现功能的差异话，这是专业设计，还可以提高开发效率。
识别方法重载的技巧：形参列表不同：形参个数，类型，顺序不同。不关心形参变量的名称：(int a, int b) ( int c, int d,int e )。。
return：跳出并立即结束当前方法的执行。

Java案例：买飞机票

喜欢的东西买了吧

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础知识笔记

技术体系：Java　EE（Java Enterprise Edition）：企业版。技术体系：Java SE（Java　Standard　Edition）：标准版。技术体系：Java ME（Java　Micro　Edition）：小型版。说明：企业级应用开发的一套解决方案。说明：针对移动设备应用的解决方案。说明：Java技术的核心和基础。
复制链接

扫一扫

Java基础知识笔记

初识Java

Java背景知识

Java技术体系（Java有哪些技术平台）

JDK的选择安装和下载

搭建Java开发环境

JRE

JDK的发展史

如何获取JDK

如何安装JDK

如何验证JDK是否成功

如何卸载JDK

前置知识：了解JDK中的Java、Javac的基本作用

安装JDK 组件了解

Development Tools

Source Code

JDK安装路径下的文件路径

bin

db

include

jre

lib

javafx-src

src.zip

掌握DOS窗口常见命令的使用

补充几个命令行窗口的常用命令

Java程序运行机制

高级语言的运行机制

编译型语言

解释型语言

伪编译型语言

Java程序的运行机制

JVM

JVM的统一标准

开发HelloWorld程序

Java程序开发的三步骤

注意事项：

编写代码

编译代码、运行代码

Java基础知识了解

常见问题解答

HelloWorld案例常见错误

Java程序的执行原理、BUG介绍

计算机能认识的机器语言长什么样子？

机器语言是由什么组成的

java程序的执行原理是什么样的？

编程语言发展历程

为什么学习高级编程语言？

BUG

JDK的组成、跨平台原理

JDK的组成

java的跨平台、工作原理

Path、JAVA＿HOME环境变量配置

Path环境变量

编译和运行Java程序必须经过两个步骤

使用命令行窗口打开qq程序

为Java、javac配置path的注意事项

自行配置Java、javac的path环境变量

重新配置了环境变量以后，必须检测是否配置成功

配置Java _home 环境变量

IntelliJ IDEA开发工具概述

之前的开发工具存在一些问题

集成开发环境（IDE，Integrated Development Environment）

IntelliJ IDEA简介

IDEA的下载、安装

IDEA程序的卸载

IDEA开发HelloWorld程序

IDEA管理Java程序的结构

新建工程

创建模块

新建包

编写Java程序

使用idea开发第一个Java程序的步骤 总结

使用idea开发Java程序的步骤

创建的关键字

IDEA的配置、快捷键设置

设置IDEA的主题

设置字体颜色

设置代码的背景颜色

IDEA 常用快捷键

集成开发环境（IDE，Integrated　Development　Environment）

IntelliJ　IDEA简介

使用idea开发第一个Java程序的步骤　总结

导入模块（方法一，不建议）

导入模块（方法二，建议）

导入模块（方法三）

常见的　javac 　标记

常见的　javac 　标记