Java笔记（入门篇）

一、Java简述

1、Java的历史

• Java是美国Sun公司在1995年推出的一门计算机高级编程语言。

• 它初期叫做Oak(橡树)，但是注册商标的时候发现已经有人注册了，后来就改成 Java (印度尼西亚爪哇岛)；

• Java之父：詹姆斯·高斯林 (James Gosling)。

• 在2009年，Sun公司被Oracle甲骨文以74亿美元收购，这就意味着Java属于Oracle了。

  

2、为什么要使用Java？

• 世界上最流行的编程语言之一，在国内使用最为广泛的编程语言。

• 可移植性(跨平台)、安全可靠、性能较好。

• 开发社区最完善、功能最丰富。

3、Java可以做什么？

• 桌面端应用开发，例如 Eclipse、IDEA等等
• 移动端应用开发，例如 Android
• 大数据开发，例如 Hadoop
• 企业级应用开发，例如 微服务、大型互联网应用
• 游戏开发，例如 我的世界
• 物联网（用python或者c/c++用的多）
• 爬虫

4、Java的技术体系

Java SE（Java Standard Edition）：Java标准版，Java技术的核心与基础。

Java EE（Java Enterprise Ediiton）：Java企业版，企业级应用开发的一套解决方案。

Java ME（Java Micro Edition）Java微型版，针对移动设备应用的解决方案。

Java主要擅长分布式系统开发、大数据开发、Android应用开发三个方向，学好Java有饭吃；

根据市场的就业形势，一般人都会选择分布式系统开发(Web应用开发)，然后积累2-3年以上工作经验以后可以转向大数据开发方向。

二、Java环境搭建

1. JDK

---

JDK（Java开发工具包）是学Java的第一步，不管是学习Java编程，还是要搭建JavaWeb开发环境，或者是搞Android开发环境都离不开它。

1.1 JDK介绍

---

• JDK (Java Development Kit) Java开发工具包，JDK包含Java开发工具(javac，java，javadoc，jar等)以及JRE；
• JRE (Java Runtime Environment) Java运行环境，JRE包含了开发Java程序时需要类库(时间日期、集合、并发、IO、网络、反射等) 和 JVM(Java虚拟机，真正运行Java程序的地方)；

JDK体系结构：

JDK的发展史：

• LTS（long-term support）：长期支持版
• 目前最新版本JDK18
• 企业常用的是JDK8

1.2 下载JDK

---

Java官网地址：https://www.oracle.com/java/

Java下载地址：https://www.oracle.com/java/technologies/downloads/

Java历史版本下载地址：https://www.oracle.com/java/technologies/oracle-java-archive-downloads.html

目前Oracle官方提供了3个长期版本的JDK：（选择jdk的时候一定选择官方长期支持的版本）

• Java8 (Oracle官方支持到2030年12月)，企业目前都用Java8(JDK8)开发Java项目，也是目前最主流的JDK版本
• Java11 (Oracle官方支持到2026年9月)
• Java17 (Oracle官方支持到2024年9月)

Windows版JDK8下载

---

JDK8也叫做Java8

1、我们根据自己电脑配置下载对应的JDK，这里我们下载Windows64位版本的JDK

2、选择Windows

3、同意许可协议并且登录Oracle账号，然后点击下载

下载成功后本地会出现一个jdk-8uxxx-windows-x64.exe文件。

注：jdk-8u202是最后一个免费商用版本，Oracle于 2019-01-15 停止免费商用更新。

1.3 安装JDK

---

1、双击JDK的安装包（如：jdk-8u201-windows-x64.exe）,进入安装界面，然后一直下一步即可。

2、设置JDK的安装路径（可选）

3、设置JRE的安装路径（可选）

4、安装成功后点击关闭即可

JDK目录结构

• bin目录，包含一些用于开发Java程序的工具，例如：编译工具(javac.exe)、运行工具 (java.exe) 、打包工具 (jar.exe)等；
• include目录，C语言的头文件，用于支持Java程序设计；
• jre目录，Java运行时环境；
• db，这是一个纯 Java 实现、开源的数据库管理系统（DBMS），源于 Apache 软件基金会（ASF）名下的项目 Derby；
• jie\bin目录，包含Java平台所使用工具和类库的可执行文件和DLL文件。
• jre\lib目录，Java运行时环境所使用的核心类库；
• lib目录，包含开发Java程序所使用的类库文件；
• src.zip压缩包，归档的Java源代码。

jdk/bin目录下可执行文件

• java：这个可执行程序其实就是JVM，运行Java程序，就是启动JVM，然后让JVM执行指定的编译后的代码；
• javac：这是Java的编译器，它用于把Java源码文件（以.java后缀结尾）编译为Java字节码文件（以 .class 后缀结尾）；
• jar：用于把一组.class文件打包成一个.jar文件，便于发布；
• javadoc：用于从Java源码中自动提取注释并生成文档；
• jdb：Java调试器，用于开发阶段的运行调试。

查阅Java文档

Java8官方文档：Java Platform Standard Edition 8 Documentation (oracle.com)

Java8官方文档可能不够直观，我们可以切换Java11和Java17的官方文档：

java11官方文档：JDK 11 Documentation - Home (oracle.com)

java17官方文档：JDK 17 Documentation - Home (oracle.com)

1.4 配置环境变量

---

鼠标右键 “我的电脑”—>“属性”—>“高级”—>“环境变量”。

1、新建一个系统变量

变量名：  JAVA_HOME
变量值：  D:\Program Files\Environment\Java\jdk1.8.0_201 （jdk所在目录）

为什么需要配置JAVA_HOME:

• JAVA_HOME本质就是JDK的绝对路径D:\Program Files\Environment\Java\jdk1.8.0_201
• 后期Java开发会使用很多工具和组件（比如 Tomcat、Maven、Jmeter等），他们会依赖这个JAVA_HOME目录，如果没有的话这些程序会无法运行；

2、然后将%JAVA_HOME%\bin 填加到系统变量的Path变量中

%JAVA_HOME%\bin

之后一直点确定来保存我们的配置。

3、查看是否配置成功

按快捷键win+r打开运行窗口，然后输入cmd并回车打开指令控制台：

)

在命令提示符窗口中输入javac -version或者java -version：

ok出现上述结果，表示我们已经配置成功了。

1.4 卸载JDK

---

JDK和我们日常用的软件卸载方式类似，卸载后删除文件和环境变量即可。

1.5 编写第一个Java程序

---

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

1、开启系统扩展名

2、在桌面空白处新建一个文本文档文件，并命名为：HelloWord.java。

3、编辑文本文件：

public class HelloWord {
    //main方法是程序执行的入口
	public static void main(String[] args){
		System.out.println("hello Java!!!");
	}
}

4、Ctrl + S保存文件

5、按快捷键win+r然后输入cmd回车打开指令控制台

6、javac (java文件的绝对路径 ) 编译 ，例如：javac HelloWord.java

7、会在原java文件的位置生成一个HelloWorld.class (字节码文件)

8、 java -xxx (执行目标文件) ，例如：java HelloWorld

执行过程：xxx.java(源文件) -javac.exe(编译器)-> xxx.class字节码文件 -java.exe(执行/翻译)-> JVM(java虚拟机) -(解释成机器码并运行) --> 操作系统。

1.6 Java 跨平台原理

---

Java程序是运行在JVM（Java Virtual Machine）之上，这就是Java跨平台的本质原因，而且由于Java是开放的，有越来越多的编程语言开发的程序也可以运行在JVM之上，例如 大数据开发的Scala、安卓开发的Kotlin以及脚本语言Grovvy等。

2. IntelliJ IDEA

---

IDEA（全称：IntelliJ IDEA）是 JetBrains 公司的产品，IntelliJ IDEA 在业界被公认为最好用的 Java 集成开发工具，结合智能编码辅助与符合人体工程学的设计，让开发不仅高效，更成为一种享受。

安装地址：https://blog.csdn.net/qq_46921028/article/details/124209921

三、注释

注释用来对代码进行解释说明，被注释的内容会被编译器忽略掉。

Java中注释有三种写法：单行注释、多行注释、文档注释

// 单行注释    快捷键:ctrl + /

/*多行注释*/    多行注释也可以写在方法的参数列表中 ,  快捷键:ctrl + shift + /

/**
  文档注释
 */

查看编译后的class字节码文件（发现注释已经被被编译器忽略掉了）：

四、变量

1、字面量

在Java程序中直接写出来的数据叫字面量/常量/直接量。

常见数据在程序中书写格式：

常用数据	生活中的数据	程序中的写法	说明
整数	-128，127	-128，127	写法一致
小数	3.14，2.718	3.14，2.718	写法一致
字符	男，女，可	‘男’，‘女’，‘可’	程序中必须使用单引号，有且仅能一个字符
字符串	HelloWorld	“HelloWorld”	程序中必须使用双引号，内容可有可无
布尔	真、假	true、false	只有两个值: true:代表真，false: 代表假
空值		值是：null	一个特殊的值，空值

package com.baidou.literal;

/**
 * 字面量
 *
 * @author 白豆五
 * @version 2022/6/16 8:19
 * @since JDK8
 */
public class LiteralDemo {
    public static void main(String[] args) {
        // 1、整数
        System.out.println(666);

        // 2、小数
        System.out.println(3.14);

        // 3、字符
        System.out.println('a');
        System.out.println(' ');//空字符
        /*
            转义字符：\n 换行  , \t 一个tab缩进
         */

        // 4、字符串
        System.out.println("你好Java");

        // 5、布尔值，只有两个值，真true、假false
        System.out.println(true);
        System.out.println(false);
    }
}

2、变量

• 变量可以理解为存储数据的容器，它里面存储的数据是可以变化的。

• 使用的时候，系统会自动为变量在内存中开辟一个区域，然后我们只需要通过变量名就可以获取它里面的数据啦。

​

3、变量定义的格式

• 数据类型 变量名称 = 初始值;
• 数据类型：强制限制盒子中存储数据的形式。例如: int ( 整数类型)、double(小数类型)等
• 变量名称：取名字(首字母小写)，之后通过变量名我们可以访问它对应的数据。
• 初始值：存的初始数据。

/**
 * 变量的使用
 *
 * @author 白豆五
 * @version 2022/6/16 8:44
 * @since JDK8
 */
public class VariableDemo {
    public static void main(String[] args) {
        // 变量定义的格式:数据类型 变量名 = 初始值;
        int age = 18;
        System.out.println("age = " + age);

        age =25;
        System.out.println("age = " + age);
    }
}

4、变量使用的注意事项

• 变量要先声明再使用；
• 同一个作用域范围内的变量不能重复定义；
• 变量只能在定义的作用域范围内使用；
• 什么类型的变量只能存储什么类型的数据；
• 变量定义的时候可以没有初始值,但是使用的时候必须给初始值。

5、按照声明的位置不同，变量可分为两种：

• 在类内方法体外声明的变量叫做成员变量（也叫做属性）；
• 在方法体内声明的变量叫做局部变量；

6、常见的计算机信息存储单位

• 位(bit) 计算机信息存储最小单位，位只有两种形式0和1(因为计算机只有高低电压两种状态，所以就用0和1表示)
• 字节(Byte) 计算机的基本存储单位，字节是由8个比特位组成的， 1Byte=8bit (也叫做比特/比特位)
• 千字节(KB) 1KB=1024B
• 兆字节(MB）1MB=1024KB
• 吉字节(GB) 1GB=1024MB
• 太字节(TB) 1TB=1024GB

五、关键字、保留字、标识符

1. 关键字

---

• 关键字就是被Java语言赋予了特殊的含义，用作特殊用途的单词。(是程序员和编译器的一个约定)

• 关键字的特点就是单词都是小写字母。

Java关键字介绍：https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html

2. 保留字

---

保留字就是现有Java版本尚未使用，但是可能以后的版本会作为关键字使用，例如 const、goto就是Java语言中的保留字。

3. 标识符

---

在写Java程序的时候凡是需要取名字的地方就是标识符。

如 项目名、包名、类名(接口名、枚举名、注解名)、方法名、变量名和常量名。

标识符的命名规则

• 标识符由字母、数字、下划线_、美元符$、中文字符组成。
• 不能用数字开头，推荐以字母开头。
• 不能把java关键字和保留字作为标识符。如：break、case、if、char、int、for等等
• 标识符对大小写敏感。
• 各操作系统存在文件名长度限制。 (名字不要取太长)

一些常用规范

• 项目、包：小写。
• 类、抽象类、接口、注解：大驼峰命名法，如HelloWorld、@Data。
• 变量、方法：小驼峰命名法 ，如 userName、getUserName()。
• 常量、枚举：大写(多个单词之间用下划线_分割)，如 USER_SESSION；

扩展：内存与硬盘

• 内存存储临时数据(断电数据就会消失)，硬盘存储长期数据。
• 硬盘便宜，内存较贵。
• 硬盘存储速度慢，内存存储速度快。

「突发小技巧」如果你的笔记本受卡槽的限制、或者主板镶嵌的原因无法扩展内存，可以通过修改虚拟内存手段来缓解部分内存压力。（缺点：容易损伤硬盘）

六、数据类型

数据类型就是约束变量存储数据的形式（包括申请内存空间的大小以及存储什么类型的数据）。

1. 整数类型

---

整型是日常生活中经常使用的类型，例如描述人的年龄、书本的页数、班级的人数、楼房的栋数等。

Java语言中整数类型按照占据内存空间大小以及表数范围分成如下四种：byte、short、int、long。

数据类型	内存占用(字节数)	默认值	取值范围
byte	1	0	-128~127
short	2	0	-32768~32767
int (默认)	4	0	-2147483648~2147483647（10位数，大约21亿）
long	8	0l	-9223372036854775808~9223372036854775807（19位数）

1Byte= 8 bit （比特位）

使用程序查看整型的表数范围和所占字节大小：

package com.baidou.java.syntax.primitivetype;

/**
 * @ClassName: IntegerLimitsTest
 * @Description: 查看四种整数类型的表数范围和占据内存的字节数
 * @Author: baidou [email protected]
 * @Date: 2022/4/28 07:26
 * Version: 1.0
 */

public class IntegerLimitsTest {
    public static void main(String[] args) {
        //%d 表示该格式为整数
        //第一个%d会被Byte.MAX_VALUE替换
        //第二个%d会被Byte.MIN_VALUE替换
        //第三个%d会被Byte.Bytes替换
        System.out.printf("byte所能存储的最大值是%d,byte所能存储的最小值是%d,byte占据的字节数是%d \n",Byte.MAX_VALUE,Byte.MIN_VALUE,Byte.BYTES);

        //%d 表示该格式为整数
        //第一个%d会被Short.MAX_VALUE替换
        //第二个%d会被Short.MIN_VALUE替换
        //第三个%d会被Short.Bytes替换
        System.out.printf("short所能存储的最大值是%d,short所能存储的最小值是%d,short占据的字节数是%d \n",Short.MAX_VALUE,Short.MIN_VALUE,Short.BYTES);

        //%d 表示该格式为整数
        //第一个%d会被Int.MAX_VALUE替换
        //第二个%d会被Int.MIN_VALUE替换
        //第三个%d会被Int.Bytes替换
        System.out.printf("int所能存储的最大值是%d,int所能存储的最小值是%d,int占据的字节数是%d \n",Integer.MAX_VALUE,Integer.MIN_VALUE,Integer.BYTES);

        //%d 表示该格式为整数
        //第一个%d会被Long.MAX_VALUE替换
        //第二个%d会被Long.MIN_VALUE替换
        //第三个%d会被Long.Bytes替换
        System.out.printf("long所能存储的最大值是%d,long所能存储的最小值是%d,long占据的字节数是%d \n",Long.MAX_VALUE,Long.MIN_VALUE,Long.BYTES);
    }
}

运行结果如下：

注：在使用整数类型时，需要考虑该数是否在表数范围内，如果不在表数范围内程序会发生错误。

整数类型的使用

• 在Java程序中直接写出来的整数类型的数据叫字面量/常量/直接量，默认类型是int；

• 如果想要表示long类型的整数字面量，需要在整数字面量的后面加上L后缀；

• 日常开发中使用的整数是byte、int、long以及对应的包装类（Byte、Integer、Long）；

• 如果想要使用比long更大的整数，可以使用java.math.BigInteger类；

整数字面量的四种进制表示

在Java语言中，整数字面量支持四种进制表示方式：

• 二进制，以0b或者是0B开头，二进制的字面量由0和1组成，例如 0b1101；
• 八进制，以0开头，八进制的到字面量由0-7之间的8个数字组成，例如 017；
• 十进制，十进制的到字面量由0-9之间的10个数字组成，整数字面量的默认进制表示；
• 十六进制，以0x或者0X开头，十六进制的字面量由0-9之间的10个数字以及a-f或者A-F之间的6个字母组成，例如 0x1F；

示例代码：

package com.baidou.java.syntax.primitivetype;

/**
 * @ClassName: IntegerRadixTest
 * @Description: 整数字面量的四种进制表示
 * @Author: baidou [email protected]
 * @Date: 2022/4/28 08:34
 * Version: 1.0
 */
public class IntegerRadixTest {
    public static void main(String[] args) {
        //二进制的整数字面量
        byte binary = 0b1101;  //二进制转十进制:1*2^3 + 1*2^2 + 0*2 +1*2^0 = 13
        // System.out.println()打印输出四种进制的整数字面量的结果都是十进制的
        System.out.println("binary = " + binary);

        //八进制的整数字面量
        int octal = 017; //1*8+7*8^0=15
        System.out.println("octal = " + octal);

        //十进制的整数字面量
        int number = 10;
        System.out.println("number = " + number);

        //十六进制的整数字面量
        int hex = 0x1f; //1*16+15*16^0=31
        System.out.println("hex = " + hex);
    }
}

运行结果如下：

整数字面量使用下划线

如果Java源文件中存在着很长的整数字面量值，不易阅读，此时可以使用JDK7以后新增的特性：数值字面量使用下划线来分割数值，使得数值更加容易阅读。

我们可以在整数和浮点数的数值之间使用下划线，但是编译器在编译的时候会自动过滤掉该下划线；

2. 浮点类型

---

浮点类型就是生活中的小数，例如 银行的利率、员工的薪资、圆周率3.14等。

Java中浮点类型分为单精度的char和双精度的double两种。

• float占据4个字节(byte)，也就是32位（bit）
• double占据8个字节（byte），也就是64位（bit）

由于浮点数的存储机制和整数存储不一样，Java的浮点类型遵守IEEEZ54标准，采用二进制的科学计数法表示浮点数。

对于float，第1位是符号位，接下来8位表示指数位，后面的23位表示尾数位。

对于double，第1位是符号位，接下来11位表示指数位，后面的52位表示尾数位。

float所能存储的数值范围大于占据8个字节的long；

package com.baidou.java.syntax.primitivetype;

/**
 * @ClassName: FloatLimitsTest
 * @Description: Java两种浮点类型的表示范围和占据内存字节数
 * @Author: baidou [email protected]
 * @Date: 2022/5/11 14:07
 * Version: 1.0
 */
public class FloatLimitsTest {
    public static void main(String[] args) {
        // float表示范围和占据内存字节数
        // %f表示该格式为浮点数  %.10f表示小数点后10位
        // %d表示该格式为整数
        // %e表示该格式用科学计数法表示
        System.out.printf("float所能存储的最大值是%f,float所能存储的最小值是%e,float所占据的字节数是%d \n",Float.MAX_VALUE,Float.MIN_VALUE,Float.BYTES);
        System.out.printf("long所能存储的最大值是%d,long所能存储的最小值是%d,long所占据的字节数是%d \n",Long.MAX_VALUE,Long.MIN_VALUE,Long.BYTES);
        System.out.printf("double所能存储的最大值是%f,double所能存储的最小值是%f,double所占据的字节数是%d \n",Double.MAX_VALUE,Double.MIN_VALUE,Double.BYTES);

    }
}

浮点类型的使用

在Java程序中直接写出来的浮点类型数据叫字面量/常量/直接量。

浮点类型的字面量可以使用十进制的浮点数和科学计数法两种方式表示。

浮点类型的字面量默认是double类型，如果需要表示float类型的字面量，需要在float类型字面量的结尾添加F或f。

package com.baidou.java.syntax.primitivetype;

/**
 * @ClassName: FloatVariableTest
 * @Description: 浮点类型的使用
 * @Author: baidou [email protected]
 * @Date: 2022/5/11 14:49
 * Version: 1.0
 */
public class FloatVariableTest {
    public static void main(String[] args) {
        // 十进制双精度浮点数
        double dblVal = 120.0;
        System.out.println("dblVal:" + dblVal);

        // 科学计数法双精度浮点数
        dblVal = 1.2E2; //1.2*10^2
        System.out.println("dblVal:" + dblVal);


        //float fltVal = 3.14; 不兼容的类型: 从double转换到float可能会有损失
        float fltVal = 3.14f;
        System.out.println("fltVal = " + fltVal);

        double PI = 31415926E-7;  //31415926*10^-7
        System.out.println("PI = " + PI);
    }
}

浮点类型的精度问题

我们在使用float或者double的时候就会遇到精度问题；如果想要浮点数的结果是完全精确的，也就是不允许有误差，可以使用java.math.BigDecimal类型替换float和double。

package com.baidou.java.syntax.primitivetype;

import java.math.BigDecimal;

/**
 * @ClassName: FloatPrecisionTest
 * @Description: 浮点类型的精度问题
 * @Author: baidou [email protected]
 * @Date: 2022/5/11 15:01
 * Version: 1.0
 */
public class FloatPrecisionTest {
    public static void main(String[] args) {
        float fltVal = 3.1415926f;
        System.out.println("fltVal = " + fltVal); //3.1415925

        float floatLeft = 2.0f;
        float floatRight = 1.2f;
        float floatResult = floatLeft - floatRight;
        System.out.println("floatResult = " + floatResult); //0.79999995

        double doubleLeft = 0.1;
        double doubleRight = 0.2;
        double doubleResult = doubleLeft + doubleRight;
        System.out.println("doubleResult = " + doubleResult); //0.30000000000000004

        // 解决问题的实现方式
        BigDecimal double1 = new BigDecimal(Double.toString(0.1)); //使用String方式传入
        BigDecimal double2 = new BigDecimal(Double.toString(0.2));
        BigDecimal sum = double1.add(double2);
        System.out.println("sum = " + sum.doubleValue()); //0.3
    }
}

3. 字符类型

---

字符类型就是用于描述单个字符的数据类型，在Java语言中使用 ’ ‘一对单引号将字符字面量包裹起来，例如 ‘男’、’\n’、'\u4e2d’等。

在Java语言中使用char关键字表示字符类型，char占据2个字节内存空间，并且char没有符号位，表示范围是0~65535。

由于现实生活中很少数据使用字符去描述，因此以后在开发中更多使用字符串，字符串的字面量使用双引号包裹起来，字符串类型使用java.lang.String表示。

String name = "李雷";
String address = "河南省昆明市";

计算机底层只能识别0和1组成的二进制序列，对于’男’、‘\n’、'\u4e2d’等字符不能满足该规则，因此字符数据不能直接在计算机中存储，但是现实生活中又有这个需求，为了能够让这些字符数据存储在计算机中，可以给这些字符指定一个编号，这个编号就是ASCII；

• 字符 ‘a’ 对应的ASSCII编码是97
• 字符 ‘A’ 对应的ASSCII编码是65
• 字符 ‘0’ 对应的ASSIC编码是48
• 字符 空格 对应的ASSIC编码是32
• 字符换行符对应的ASSIC编码是10

字符类型的使用

package com.baidou.java.syntax.primitivetype;

import java.nio.charset.Charset;

/**
 * @ClassName: CharacterASCIITest
 * @Description: ASCII字符集的使用
 * @Author: baidou [email protected]
 * @Date: 2022/5/11 19:40
 * Version: 1.0
 */
public class CharacterASCIITest {
    public static void main(String[] args) {
        char aVal = 'a';
        System.out.println("aVal = " + aVal);
        System.out.println("字符a对应的编码是" + (int) aVal); //97
        // UTF-8兼容ASCII码
        System.out.println("当前JVM采用的编码是 " + Charset.defaultCharset()); //UTF-8
    }
}

Unicode字符集的概念和使用

Java的字符类型是采用Unicode字符集，每套字符集都至少有一套编码，例如Unicode字符集有UTF-8、UTF-16等。

Unicode字符集是国际组织指定可以容纳世界上所有国家的文字和符号的字符集解决方案，因此Java程序可以支持各种语言的字符。

package com.baidou.java.syntax.primitivetype;

/**
 * @ClassName: CharacterUnicodeTest
 * @Description: Unicode
 * @Author: baidou [email protected]
 * @Date: 2022/5/11 19:40
 * Version: 1.0
 */
public class CharacterUnicodeTest {
    public static void main(String[] args) {
        //Unicode编码支持中文
        char chinese = '\u4e2d';
        System.out.println("chinese = " + chinese);
        System.out.println("该字符对应的UTF-8编码的编号是 " + (int)chinese);
    }
}

转义字符的使用

在日常生活中会使用以下的转义字符：

• \n 换行
• \t 制表符(tab)
• \\ 路径转义
• \’ 转义单引号
• \" 转义双引号

4. 布尔类型

---

布尔类型是用于描述真假信息的，布尔类型boolean的字面值取值只能是true或者false。

布尔类型占据一个字节的内存空间；

package com.baidou.java.syntax.primitivetype;

/**
 * @ClassName: CharacterUnicodeTest
 * @Description: Unicode
 * @Author: baidou [email protected]
 * @Date: 2022/5/11 19:40
 * Version: 1.0
 */
public class CharacterUnicodeTest {
    public static void main(String[] args) {
        //Unicode编码支持中文
        char chinese = '\u4e2d';
        System.out.println("chinese = " + chinese);
        System.out.println("该字符对应的UTF-8编码的编号是 " + (int)chinese);
    }
}

5. 数据类型转换

---

按精度排序：byte -> short/char -> int -> long -> float -> double (小->大)
隐式（自动类型转换），显示（需要强制类型转换）精度会丢失。

注：自动数据类型转换不代表不会发生精度丢失。

示例：强制类型转换

short a = 1;
short b = 2;
short c = (short)a+b; //（强转:大->小）
// 因为JVM虚拟机把byte、short的运算都转成int了。

示例：精度丢失

double d1 = 0.1;
double d2 = 0.2;
double d3 = d1 + d2; //0.30000000000000004
//基本数据类型不适合做高精度运算，如 航天、医疗、金融等（解决方案：使用高精度数字BigDecimal)

七、运算符

运算符用于指明对操作数的运算方式，在Java程序中运算符有算数运算符、关系运算符、逻辑运算符、赋值运算符、三目运算符、位运算符。

1. 算数运算符

---

算数运算符有：+(加)、-（减）、*（乘）、/（除）、%（取模/求余数）、++（自增）、--（自减）。

先乘除后加减，可以使用小括号 () 改变运算优先级。

对于字符串也可以使用 + 进行字符串连接操作。

2. 赋值运算符

---

• 赋值：= （将右侧的数据赋值给左侧）

• 加等于：+=

• 减等于：-=

• 乘等于：*=

• 除等于：/=

• 模等于：%=

3. 关系运算符

---

>   大于
<   小于
==  等于
!=  不等于
>=  大于等于 
<=  小于等于
instanceof(用于测试左边的对象是否是它右边类的实例)。

4. 逻辑运算符

---

• 逻辑与(&)：运算符前后的操作数都必须是true，运算结果返回true，否则返回false。
• 短路与(&&)：运算符前后的操作数都必须是true，运算结果返回true，否则返回false，附加了短路的特性。
• 逻辑或( | )：运算符前后的操作数只有一个为true，运算结果返回true，否则返回false。
• 短路或( || )：运算符前后的操作数只有一个为true，运算结果返回true，否则返回false，附加了短路的特性。
• 逻辑非(!)：取反，比如 操作数为true时逻辑非的运算结果为false，逻辑非只有一个操作数。
• 逻辑异或(^)：当两个操作数不同的时候返回true，当两个操作数相同的时候返回false。

日常开发中经常使用的逻辑运算符是：短路与(&&)、短路或( || )、逻辑非( ! )。

逻辑运算符的操作数都是布尔类型的，例如布尔类型的字面量啊、变量、表达式。

逻辑运算符的运算结果也是布尔类型的true或者false。

逻辑运算符的短路特性

逻辑运算符的短路特性：当已经明确逻辑运算的最终结果，就不会再执行剩余的表达式，这样可以提升程序的性能。

1、短路与

package com.baidou.java.operator.logic;

/**
 * @ClassName: ShortCircuitAnd
 * @Description: 短路与
 * @Author: baidou [email protected]
 * @Date: 2022/5/12 08:43
 * Version: 1.0
 */
public class ShortCircuitAnd {
    public static void main(String[] args) {
        int left = 10;
        int right = 20;
        /*
            left++>10 false left=11
            因为短路与前面的表达式结果为false,根据短路特性( right-- < 20就不会执行) 所以right=20
         */
        boolean result = left++ > 10 && right-- < 20;
        System.out.println("result = " + result); //false
        System.out.println("left = " + left);   // 11
        System.out.println("right = " + right); // 20
    }
}

2、短路或

package com.baidou.java.operator.logic;

/**
 * @ClassName: ShortCircuitOr
 * @Description: 短路或
 * @Author: baidou [email protected]
 * @Date: 2022/5/12 09:12
 * Version: 1.0
 */
public class ShortCircuitOr {
    public static void main(String[] args) {
        int left = 10;
        int right = 20;
        boolean result = ++left > 10 || right-- < 20;
        System.out.println("result = " + result); //false
        System.out.println("left = " + left);   // 11
        System.out.println("right = " + right); // 20
    }
}

逻辑运算符判断四位数

四位数：大于等于1000 And 小于等于 9999

package com.baidou.java.operator.logic;

/**
 * @ClassName: ShortCircuitAndTest
 * @Description: 逻辑运算符判断四位数
 * @Author: baidou [email protected]
 * @Date: 2022/5/12 09:20
 * Version: 1.0
 */
public class ShortCircuitAndTest {
    public static void main(String[] args) {
        int num = 8888;
        System.out.println("num>=1000 && num<=9999 = " + (num >= 1000 && num <= 9999));
        num = 888;
        System.out.println("num>=1000 && num<=9999 = " + (num >= 1000 && num <= 9999));
    }
}

5. 三目运算符

---

语法: <表达式1>?<表达式2>:<表达式3>;  //用来简化if-else的使用

6. 位运算符

---

• 按位与(&)：按照二进制位进行与运算，同1为1，否则为0 （1&0->0，0&0->0）；

• 按位或(|)：按照二进制位进行或运算，同1为1，同0为0

• 按位取反(~)：按照二进制位取反，1为0，0为1

• 按位异或(^)：按照二进制位进行异或运算，相同为0，不同为1

• 左移(<<)： 例如：<<1，左移1位相当于乘2

• 右移(>>)： 例如：>>1，右移1位相当于除以2

八、Scanner

1. 如何学习Java API？

---

学习方法：阅读 Java API文档 或者 查看 Java API源码 。

Java API 的介绍

我们学习Java语言主要是学习Java提供的日常开发Java项目中经常使用的API(如类、接口、枚举、注解)。

在IntelliJ IDEA的编译器中按住Ctrl键然后选中类名，便会自动跳转对应的源代码文件。

Java API源文件位于src.zip文件中，Java API字节码文件位于rt.jar文件中。

Java常用的包：

• java.io IO操作
• java.lang 语言基础、反射
• java.math 数学运算
• java.net 网络编程
• java.nio 异步IO编程
• java.sql 数据库编程
• java.text 文本格式化
• java.time 日期/时间
• java.util 集合、并发、函数式编程、Stream编程、正则表达式、日志

Java API文档的使用

通过阅读Java API文档的方式学习它的使用。

Java8 API文档：https://docs.oracle.com/javase/8/docs/api/index.html

Java API文档使用JDK提供的javadoc工具生成的。

以java.lang包下的String类为例：

Java API源码的使用

使用INtellij IDEA查看Java API源码的步骤：

1、双击shift打开搜索框，然后搜索对应的API （ 源文件*.java）

2、点击左下角的Structure查看该类的结构（m方法、f字段）

如果想要查找某个具体的方法，可以按Ctr+F12列出当前类中所有的方法，然后搜索你想要的方法即可！

2、Scanner的使用

---

Scanner用于接收键盘输入数据，使用前需要导包：import java.util.Scanner;

语法如下：

// 创建扫描器对象
Scanner in = new Scanner(System.in);
in.next();      接收字符串,不接收空格
in.nextLine();  接收字符串,识别空格
in.nextInt();   接收数字
......

九、程序流程控制

程序的执行流程分为三种结构：顺序结构、分支结构、循环结构。

除此之外还提供了break和continue关键字来控制循环结构；

1. 分支结构

---

目的：满足某些条件的时候才执行某段代码(代码块)。

Java中支持两种分支结构：if 、switch 。if 用的最多，可以代替 switch 。

IF 语句

---

第一种 IF:

if(条件表达式){
   语句块; 
}

• 语句块可以是单行语句，也可以是复合语句；
• 如果是单行语句，{}可以省略，但最好不要省略；
• 整个 if 是一个逻辑语句，因此不能直接在 if 后面加分号。

示例：if语句的使用

int age = 19;
if(age>18){
    System.out.println("你成年了！");
}

第二种 IF :

if((条件表达式){
  	语句1;
}else{
    语句2;
}   

示例：if-else的使用

int score = 80;
if (score >= 60) {
   	 	System.out.println("合格");
    } else {
  	 	 System.out.println("尚未合格");
	}
}

第三种 IF:

if((条件表达式1){
    语句1;
}else if(表达式2){
    语句2;
}
...
else{
    语句n;
}    

有点像一给我里giao giao，那鬼东西。

示例：if-else if-else的使用

int score = 80;

if (score <60){
    System.out.println("不及格");    
} else if(score>= 60&& score <70 ){
    System.out.println("及格");
}else  if (score>=70&&score<80){
    System.out.println("一般");
}else  if (score>=80&&score<90) {
    System.out.println("中等");
}else{
    System.out.println("优秀");
}

IF 嵌套：

if((条件表达式1){
    if((条件表达式2){
        语句1;
    }else{
        语句2;
    }
}else{
     语句3;
}

SWITCH 语句

---

switch(条件表达式) {
    case 条件1:
        语句1;
        break;
    case 条件2:
        语句2;
        break;
        ...
    default:
        语句;
}

• switch语句中支持的变量类型有byte、short、int或者char。
• 从jdk7开始，switch语句支持字符串String类型了，同时 case 标签必须为字符串常量或字面量。

2. 循环结构

---

根据循环条件判断来重复执行某段代码(代码块)，Java中支持四种循环结构，分别是for循环、while循环、do-while循环以及JDK5.0以后新增的foreach。

WHILE循环

---

while(条件表达式){
    循环体
}

先判断条件表达式，如果条件表达式为ture就会执行循环体，执行完循环体会再次判断条件表达式......，直到条件表达式为false时结束循环。

例如：while循环的使用

// 从10数到0
int i = 10;
while (i>=0)
{
    System.out.println("白豆五"+i);
    i--;
}
System.out.println("while结束");

控制台输出如下:
白豆五10
白豆五9
白豆五8
白豆五7
白豆五6
白豆五5
白豆五4
白豆五3
白豆五2
白豆五1
白豆五0
while结束

// 统计0到10的和
int j = 0;
int sum = 0; //创建一个临时变量用于加和操作
while (j <= 10)
{
    sum += j;
    j++;
}
System.out.println(sum); //55


// 用while循环实现：从5打印到11
int y = 5;
while(y <= 11)
{
    System.out.println(y);
    y++;
}

do-while 循环：

do{
    循环体    
}while(条件表达式);

两者的区别：while先判断后执行，do-while是先执行后判断。

FOR循环

---

既 WHILE 何生 FOR

• while 、do…while 、for 都可以实现循环，可以互换。
• 不同的需求，用不同语法难易程度不同。
• 使用频率：for > while > do…while 。

for 循环语法如下：

for(表达式1;表达式2;表达式3)
{
    循环体;
}

(1)先执行表达式1,它只会执行一次。
(2)执行表达式2,如果该表达式2结果为真,执行循环体,然后执行下面第(3)部。如果为假,直接结束for循环。   
(3)执行表达式3,然后跳到第(2)步重新执行。

用while表示for：

表达式1;
while(表达式2)
{
    循环体;
    表达式3;
}    

示例：for循环的使用

// 打印10个数
for (int i=1;i<=10;i++){
    System.out.print(i+"\t"); // 1 2 3 4 5 6 7 8 9 10
}

// 第二种声明
int j = 0;  //将之前for循环内部的局部变量,丢到循环体外面相当于提权,然后都可以调用这个变量。
for(;j<=3;j++){
    System.out.println(j);
}

// 用while等价for
int i = 0;
while (i <= 10) 
{
    System.out.println(i);
    i++;
}


// 从10倒数到0
for (int i = 10; i >= 0; i--) {
    System.out.print(i + "\t");
}

// 统计0到10的和
int sum = 0;
for (int i = 0; i <= 10; i++) {
    sum += i;
}
System.out.println(sum);

// 打印2 4 6 8 10
for (int y = 2; y <= 10; y = y + 2) {
    System.out.println(y);
}

for-each语句：

for(数据类型type  变量x : 遍历对象obj){
	引用变量x的java语句;
}

循环嵌套

---

循环嵌套：就是循环里套着循环。此套娃非彼套娃。嵌套循环可以嵌套n层，一般也就用两层。

三种循环(while、do…while、for)可以相互嵌套，不过使用最多的是for循环嵌套。

示例：使用嵌套循环打印99乘法表

for (int i = 1; i <= 9; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.print(j + "*" + i + "=" + (i * j) + "\t");
    }
    System.out.println();
}

示例：力扣27

// 力扣27题通过双指针来移除数组中的元素
/*
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

*/
public int removeElement(int[] nums, int val) {
    if (nums == null || nums.length == 0) {
        return 0;
    }
    int l = 0;
    int r = nums.length - 1;
    while (l < r) {
        while (l < r && nums[l] != val) {
            l = l + 1;
        }
        while (l < r && nums[r] == val) {
            r = r - 1;
        }
        int temp = nums[l];
        nums[l] = nums[r];
        nums[r] = temp;
    }
    System.out.println(Arrays.toString(nums));
    return nums[l] == val ? l : l + 1;
}

// 优解
public int removeElement(int[] nums, int val) {
    if (nums == null || nums.length == 0) {
        return 0;
    }
    int j = 0;
    for(int i= 0;i<nums.length;i++){
        if(nums[i]!=val){
            int temp = nums[i];
            nums[i]=nums[j];
            nums[j]=temp;
            j++;
        }
    }
    return j;
}

BREAK和CONTINUE

---

• break 和 continue都可以和while、do…while、for 一起用。
• break：强制结束循环。
• continue：不再执行本次循环后面的代码，然后继续进行下一次循环。

示例：break和continue的使用

//break
for (int i=0;i<=5;i++){
    if (i==3){
        break;
    }
    System.out.println(i);
}
打印结果：
0
1
2

// continue    
for (int i=0;i<=5;i++){
    if (i==3){
        continue;
    }
    System.out.println(i);
}
打印结果：    
0
1
2
4
5    

十、随机数Random

作用：产生一个随机数

1、导包： import java.util.Random;

2、创建随机数对象：Random r = new Rabdom();

3、获取随机数：r.nextInt(n); // nextInt(n)功能只能生成: [0,n）之间的随机数，包含0，不包含n。

示例：猜数小游戏

package com.baidou.random;
// 导包
import java.util.Random;
import java.util.Scanner;

/**
 * 猜数小游戏
 *
 * @author 白豆五
 * @version 2022/6/17 8:55
 * @since JDK8
 */
public class RandomDemo {
    public static void main(String[] args) {
        // 创建随机数对象
        Random random = new Random();
        // 生成1-100之间的随机数
        int ranNumber = random.nextInt(100) + 1;
        // 创建键盘输入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("=======欢迎使用猜数游戏=======");
        while (true) {
            System.out.println("请输入你要猜的数字(1~100):");
            int inNumber = sc.nextInt();
            if (inNumber > ranNumber) {
                System.out.println("猜大了");
            } else if (inNumber < ranNumber) {
                System.out.println("猜小了");
            } else {
                System.out.println("猜对了");
                break;
            }
        }
        System.out.println("========程序结束========");
    }
}

十一、数组

1. 数组的定义

---

数组是一种数据结构（存数据的一种方式），它会在连续的内存空间中存储一批相同类型的元素。

例如：向数组中存储一批数据

int[] arr = {1,2,3,4,5};

String[] = {"张三","李四","王五"};

**数组的优点：**它会自动给数组中的元素从0开始编号,方便操作这些元素。（下标从0开始）

1.1 静态初始化数组

---

静态初始化数组的定义格式：

//完整版
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3,...};
例如: int[] scores = new int[]{55,66,77,88,99};

//简化版
数据类型[] 数组名 = {元素1,元素2,元素3,...};
例如: int[] scores = {55,66,77,88,99};
System.out.println(scores); //[I@4c873330

注：数组变量名中存储的是数组在内存中的地址,数组是引用类型。

1.2 动态初始化数组

---

动态初始化：定义数组的时候只确定元素的类型和数组的长度，之后在存入具体的数据。

1、动态初始化数组的定义格式：

数据类型[] 数组名 = new 数据类型[元素个数或数组长度];

2、动态初始化元素默认值规则：

数据类型	明细	默认值
基本类型	byte、short、int、long	0
	float、double	0.0
	boolean	false
引用类型	类、接口、数组、String	null

示例：动态初始化数组的定义和使用

public class ArrayDemo2 {
    public static void main(String[] args) {
        //动态初始化数组的定义
        int[] scores = new int[3];  //int类型数组默认值: [0,0,0]

        System.out.println(scores[0]);
        System.out.println(scores[1]);
        System.out.println(scores[2]);
        System.out.println("-----------------");
        //赋值
        scores[0]=99;
        scores[1]=88;
        scores[2]=77;

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

3、数组的几个注意事项：

• 数据类型[] 数组名 也可以写成 数据类型 数组名[]。
• 什么类型的数组只能存放什么类型的数据，否则报错。
• 数组一旦定义出来之后，它的类型和长度就固定了。

2. 数组的访问

---

访问数组中的元素：数组名称[索引]；

获取数组的长度：数组名称.length。

数组的最大索引：**数组名称.length - 1 **（前提：元素个数大于0）

示例：数组的访问

public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33};
        // 取值,  格式: 数组名称[索引]
        System.out.println(arr[0]); //11

        // 赋值,  格式: 数组名称[索引]=数据;
        arr[0] = 111;
        System.out.println(arr[0]); //111

        System.out.println("数组长度为:"+arr.length); //元素个数:3
    }
}

3. 数组的遍历

---

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

为什么要遍历？搜索、数据统计等等都需要用到遍历。（如果数据量过多，手动获取就太麻烦了）

• 方式一：使用for循环

• 方式二：使用foreach（jdk1.5新特性）

示例1：计算 11,22,33,44,55，这5个数的总和。

int[] arr = {11,22,33,44,55};
int sum = 0;
for (int i = 0; i < arr.length; i++) {
    sum+=arr[i];
}
System.out.println("sum = " + sum); //165

示例2：查找数组中最大值。

System.out.println("-------begin--------");
int[] nums = {3, 1, 2, 9, 8, 7};
int max = 0;
for (int i = 0; i < nums.length; i++) {
    int n = nums[i];
    if (n > max) {
        System.out.println(n+"比目前的最大值大"+max+",因此更新最大值为"+n);
        max = n;
    }else {
        System.out.println(n+"不比目前的最大值"+max+"大");
    }
}
System.out.println(max);
System.out.println("-------end--------");

示例3：逐位计算两个数组，并将值赋给第三数组。

System.out.println("-------begin--------");
int[] nums1 = {9, 8, 7};
int[] nums2 = {3, 1, 2};
int[] nums3 = new int[nums1.length];
for (int i = 0; i < nums1.length; i++) {
    nums3[i] = nums1[i] + nums2[i];
}
System.out.println(Arrays.toString(nums3));
System.out.println("-------end--------");

4. 数组的排序

---

所谓的数组排序，就是元素按照升序(由小到大)或者降序( 由大到小)的操作。

数组排序的技术：冒泡排序、选择排序、快速排序、插入排序等等。

数组搜索相关的技术：二分搜索、分块查找、哈希表查找等等。

4.1 冒泡排序

---

1、冒泡排序的思想：

• 从头开始两两比较，把较大的元素与较小的元素进行交换。
• 每轮把当前最大的一个元素放到数组的尾部。

2、冒泡排序实现的步骤：

• 确定总共需要做几轮：数组的长度 - 1。
• 每轮比较几次：数组长度 - 1 - i 。

public class BubbleSortDemo1 {
    public static void main(String[] args) {
        // 定义一个数组,存储一些数据
        int[] arr = {1, 3, 2, 66, 23, 11};
        // 1、定义一个循环控制比较的轮数,i=0、1、2、3
        for (int i = 0; i < arr.length - 1; i++) {

            // 2、定义一个循环控制每轮比较的次数，第i轮比较len-i次,j=4、3、2、1
            /*
                第一轮   4次
                第二轮   3次
                第三轮   2次
                第四轮   1次
             */
            for (int j = 0; j < arr.length - 1 - i; j++) {
                // 3、交换相邻元素位置
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        // 遍历数组
        for (int arrs : arr) {
            System.out.println(arrs);
        }
    }
}

5 Java内存结构

---

我们的数据都是存放在内存中，Java内存大体可以分为寄存器、堆、栈、方法区、常量池。
程序=数据结构+算法，数据结构存在堆中，算法存在方法区中。

• 堆： 由线程共享，存放 new 出来的对象或者数组，是垃圾回收器的主要工作区域。

• 栈： 线程私有，分为 Java 虚拟机栈和本地方法栈，存放局部变量表、操作栈、动态链接、方法出口等信息，方法的执行对应着入栈到出栈的过程。

• 方法区： 线程共享，存放已被加载的类信息、常量、静态变量、即时编译器编译后的代码等信息，JDK 1.8 中方法区被元空间取代，使用直接内存。

• **本地方法栈：**Native关键字，凡是被Native修饰的方法，都会去调用底层的C语言的库，会调JNI接口（本地方法接口），比如，java驱动打印机打印 （ JNI的作用，就是为了拓展Java的使用，融合不同的语言为Java所用）

6. 数组内存结构图

---

1、变量和数组在内存中表示：

public class ArrayMemoryDemo1 {
    public static void main(String[] args) {
        int a = 66; // 基本数据类型存储的是数据本身
        System.out.println("a = " + a);

        int[] arr = {11,22,33}; // 引用类型存储的是对象的地址
        System.out.println("arr = " + arr);

        arr[0] = 10;
        arr[1] = 11;
        arr[2] = 100;

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

    }
}

2、两个数组变量指向同一个数组对象：

public class ArrayMemoryDemo2 {
    public static void main(String[] args) {
        
        int[] arr1 = {11, 22, 33};
        int[] arr2 = arr1;

        System.out.println("arr1 = " + arr1); // [I@1b6d3586
        System.out.println("arr2 = " + arr2); // [I@1b6d3586

        System.out.println("arr1[0] = " + arr1[0]); // 11
        System.out.println("arr2[0] = " + arr2[0]); // 11
    }
}

7. 使用数组常见的问题

---

• 问题一：如果访问元素的位置超过最大索引，执行时会出现： 数组索引越界异常ArrayIndexOutOfBoundsException。
• 问题二：如果数组变量中没有存储数组的地址，而是null , 在访问数组信息时会出现：NullPointerException (空指针异常)。

8、Debug工具的使用

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

Debug工具基本使用步骤：

1、点击指定代码行的左侧, 形成断点。（设置断点）

2、选择使用Debug方式启动程序，启动后程序会在断点处暂停。

3、控制代码一行一行的往下执行。

思维导图：

十二、方法

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

我们设计方法的时候，最好保持方法的原子性，也就是说一个方法只完成一个功能，这样利于我们后期的扩展。

12.1 方法的组成

---

方法：由方法名、参数、返回值组成。

• 方法名：是别人调用本"命令"的标识符。
• 参数：是调用方法的时候传递的数据。方法可能没有参数，可能有1个或多个参数。
• 返回值：是方法调用完成的结果。方法可能没有返回值，对于有返回值的方法，我们也可以忽略返回值。

修饰符 返回值类型 方法名([参数列表]){
    方法体(需要执行的功能代码)
    [return 返回值;]
}

// 如果方法没有返回值,则把"返回值类型"改写为"void",然后把"return xxx;"去掉。

例如：

// 两个数的加和
public int printA(int a,int b){ //这里的a和b指的是形参,用来接收数据
    return a+b;
}

12.2 方法重载

---

方法重载：就是在一个类中，有相同的函数名称，但形参不同的函数。

方法重载规则：

• 方法名称必须相同；
• 参数列表必须不同 (个数不同，类型不同，参数排列顺序不同)；
• 方法的返回类型可以相同也可以不同；
• 仅仅返回类型不同不足以成为方法重载；

12.3、方法的调用

---

1、java静态方法调用有两种方式：

• 使用对象来调用 ，如：new Student().getName();
• 可以直接用类名来调用，如：Arrays.toString();

2、非静态方法 (没有static修饰，也不是构造方法) 或者叫成员方法：

• 通过对象的方式来调用它。