Javase(一) 基础语法篇

标识符

标识符概念

标识符是Java语言中用来命名变量、类、方法、包等字符序列。

标识符命名规则

• 标识符可以用 字母、数字、下划线(_)、美元$组成，不能使用其他符号。
• 不能以数字打头 如 abc123 是可以的，但不能是123abc。
• 不能使用Java中的关键字；如 public、class等。
• 区分大小写，studentScore 和 studentscore是不同的两个标识符。
• 标识符没有长度限制。

标识符命名规范

• 标识符没有长度的限制，但建议使用有意义的，见名知意的名字，如 student_Score 一眼就能看出这个是学生的成绩，提高可读性和可维护性。
• 建议使用驼峰命名法。
• 类名、接口名、枚举名、注解名首个单词首字母大写，后面的单词首字母大写；如UserService。
• 变量名和方法名首个单词小写，后面单词首字母大写；如studentScore。
• 常量单词全部大写，单词之间用下划线连接；如 MATH_PI。
• 包名全部小写。

关键词

关键词概念

Java关键词是事先预定义好的具有特殊含义的单词，不能被用作标识符，而是在语法中具有特殊含义或者限制 如：public int double......

字面量

字面量即Java中的值。

• 整数类型：1、-1
• 浮点类型：1.0、-2.0
• 字符类型：'a'、'1'、'牛'
• 字符串类型："爱坤TV"
• 布尔类型：true、false

加号运算符（+）

• 如果两边都是数字，则是求和：1 + 1 返回 2
• 而如果是两边均是字符串或一边是是字符串一边是数字，则是拼接，返回的还是字符串，如："勇敢牛牛" + "不怕困难" 返回 "勇敢牛牛不怕困难" 或者 "abc" + 123 也会返回 "abc123"。

变量

变量是计算机内存的一块空间

变量的分类：

• 局部变量
• 成员变量

• • 1.静态变量
  • 2.实例变量

变量由三个方面组成 变量数据类型 变量名 = 变量值

Java中有以下数据类型：

• 基本数据类型：直接存储值

• • 数字类型：

• • • 整数类型： byte(1 字节)、 short(2 字节)、 int(4 字节)、 long(8 字节)
    • 单精度浮点类型：float(4 字节)
    • 双精度浮点类型：double(8 字节)

• • 布尔类型 ：boolean
  • 字符类型：char(2 字节)

• 引用数据类型：不直接存储值，而是存储引用 ("地址")

• • 类：class
  • 接口：interface
  • 字符串类型：String
  • ......

变量的细节：

• 由于Java执行程序是从上到下执行，所以需要先定义再使用。
• 在同一个作用域中变量名不能重名。
• 变量值的数据类型和定义的数据类型要相同或者能转型。

变量作用域

• 很简单就是出了大括号就不认了
• 作用域的出现是因为变量有其自己的生命周期：内存开辟----->内存释放
• Java符合就近原则

二进制

二进制概念

计算机底层只能识别二进制。计算机底层只识别二进制是因为计算机内部的电子元件只能识别两种状态，即开和关，或者高电平和低电平。二进制正好可以用两种状态来表示数字和字符，因此成为了计算机最基本的表示方法。在计算机内部，所有的数据都被转化为二进制形式进行处理和存储。虽然计算机可以通过不同的编程语言和程序来处理不同的数据类型和格式，但最终都需要将其转化为二进制形式才能被计算机底层识别和处理。

我们日常生活中使用的十进制：

1	1	0
10^2	10^1	10^0

所以 110 代表 0 * 10^0 + 1 * 10^1 + 1 * 10^2 = 110

同理二进制就是

1	1	0
2^2	2^1	2^0

在二进制中 110 就代表了 0 * 2^0 + 1 * 2^1 + 1 * 2^2 = 6 (十进制)

进制之间的转换

十进制转换为二进制

• 将十进制数除以2，得到商和余数。
• 将余数记录下来，然后将商作为新的十进制数，重复步骤1，直到商为0为止。
• 将记录的余数从下往上排列，得到的就是对应的二进制数。

二进制转化为十进制

1	1	0
2^2	2^1	2^0

在二进制中 110 就代表了 0 * 2^0 + 1 * 2^1 + 1 * 2^2 = 6 (十进制)

八进制和十六进制

八进制是满8进1，十六进制是满16进1(1016 用 af(大小写均可) 表示)

八进制与其他进制的转化

八进制转换十进制

同二进制原理，每一位的底数由2变为8

十进制转为八进制

同二进制，除以2改为除以8

二进制转为八进制

因为 2^3 = 8，所以是每三位转为一位八进制

八进制转为二进制

每一位转为三位二进制

十六进制与其他进制的转化

十六进制转换十进制

同二进制原理，每一位的底数由2变为16

十进制转为十六进制

同二进制原理，除以2改为除以16

二进制转为十六进制

因为2^4=16，所以每四位转为一位十六进制

十六进制转为二进制

每一位转为四位二进制

原码反码补码

byte和bit

byte（字节）是计算机存储和处理数据的基本单位，通常由8个比特（bit）组成。每个比特（bit）是计算机中最小的存储单位，只能存储0或1两个状态。因此，一个字节（byte）可以存储8个比特（bit）的数据。

两者之间的关系是，1 byte = 8 bit，即8个比特（bit）组成一个字节（byte）。

在计算机中，数据通常以字节（byte）为单位进行存储和传输，而比特（bit）则是用来表示数据的最小单位。

1KB = 1024byte

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

正数的原码反码补码

正数的原码反码补码三码合一

如 127 = 0111 1111

负数的原码反码补码

负数的原码最高位为符号位

如 -127 = 1111 1111

反码则是除符号位以外，所有位取反 1111 1111 ----> 1000 0000

补码则等于 反码 + 1 1000 0000 + 1 ----> 1000 0001 = -128 + 1 = -127

底层计算以及为什么要设计出反码补码

计算机内部存储和运算用的是补码，人看到的数值，是解释后的结果（不是原码本身）

如：1 + -1 = 0000 0001 + 1111 1111 = 1 0000 0000 ----> 0000 0000

假设只有原码的话 1 + -1 = 0000 0001 + 1000 0001 = 1000 0010 ----> -2 就错了，因为原码不能直接用普通加法器来计算，要将符号位与数值位分开，先判断符号，再决定加减。非常的麻烦，所以就引入了反码的概念 1 + -1 = 0000 0001 + 1111 1110 = 1111 1111 ----> 1000 0000 = -0，这样就能解决原码计算的问题，但是却引入了 0 还分 -0 和 +0 的情况，这时候就引入了补码，即 补码 = 反码 + 1；这时候 1 + -1 = 0000 0001 + 1111 1111 = 0000 0000 = 0。

这里再补充一点，反码 的循环进位 问题，对于 1 + -1 没有循环进位所以没有问题，但如果是 3 + （-2）= 0000 0011 + 1111 1101 = 1 0000 0000 会丢失掉最高位，所以要 +1 到最低位，称为循环进位，补码 = 反码 + 1 就提前将这个坑给填了，所以底层才会采用补码来进行存储和计算，是非常精妙的。

补码的本质：把减法统一成加法，同时消除符号位带来的复杂性。

数据类型

整数类型

十进制：int num = 6

二进制：int num = 0b110 (0b=开头)

八进制：int num = 011 (0开头)

十六进制：int num = 0x1f（0x开头）

在Java中整数字面量的数据类型都是int 如 int i = 10，10的类型是int

所以 long i = 2147483648 （int 最大为 2147483647）会报错，原因是在赋值前，int 不能存大于2147483647的值，所以报错，应该用 2147483647L 或 2147483647l 大小写均可。

类型转换

自动类型转换

byte < short < int < long < float < double

char < int < long < float < double

char short 不能自动转换，由于 char 是无符号，而 short 是1有符号，范围不兼容

小容量可以给大容量赋值，这里注意有一个整型提升，所有的小整数计算会自动提升到 int 级别

byte i = 1;
short j = 2;
short num = i + j; (X) 报错

强制类型转换

Java中大容量是无法直接转换成小容量的。因为这种操作可能会导致精度损失，所以这种行为交给了程序员来决定，当然这种后果自然是程序员自己去承担。因此在代码中需要程序员自己亲手加上强制类型转换符，程序才能编译通过

强制类型转换时，底层二进制是如何变化的？原则：砍掉左侧多余的二进制。

强制类型转换时，精度可能会损失，也可能不会损失，这要看具体的数据是否真正的超出了强转后的类型的取值范围。

如：byte i = (byte) 150 // i 会变成多少

150 ----> 00000000 00000000 00000000 10010110

强制类型转换为 byte ----> 10010110 ----> -106

注意如果赋值给 short 或者 byte 没有超出范围

byte i = 127 //(✔) 无需强制类型转型
byte i = (byte)128 //(×) 需要强制类型转型 i 会变成 -128

浮点数类型

浮点数字面量默认为double类型

float f = 3.0; //(X)
float f = 3.0f //3.0F (√)

浮点类型数据的表现形式

• double d = 0.123
• double d = 123E-2 ----> 1.23
• double d = 0.123E2 ----> 12.3

浮点类型数据的存储形式

只需要知道由 符号位 + 指数位 + 尾数位 组成

所以会有精度缺失，如果有要判断相等时不要 用 ==

double a = 0.1;
double b = 0.2;
System.out.println(a + b == 0.3);

会输出令人意外的 false !

double a = 0.1;
double b = 0.2;
if (a + b - 0.3 < 0.00001) { // 写业务中能接受的误差即可
    System.out.println("true");
} else {
    System.out.println("false");
}

字符类型

占用两个字节，0~65535，和short容量相同，但char可以取更大的整数（无符号）

单个字符，使用单引号括起来，不能是多个字符

转义字符

• \n：换行
• \t：表示制表符，相当于按下 Tab 键
• \：表示一个 \
• '：表示一个单引号
• "：表示一个双引号

字符编码

字符编码是人为规定的文字与二进制之间的转换关系。

在早期计算机系统中，字符编码主要采用的是 ASCII 编码，采用1个字节编码。最多可以表示256个字符。（实际上ASCII码表只用了128个。），程序员需要记住这几个:

• a 对应ASCII码 97（b是98，以此类推）
• A 对应ASCII码 65（B是66，以此类推）
• 0 对应ASCII码 48（1是49，以此类推）

字符在计算机系统中，解码（Decoding）和编码（Encoding）是两个常用的概念，分别表示将二进制数据转换为字符和将字符转换为二进制数据。

（注：这里解码和编码都是ASCII码，且都支持这些字符不会出现乱码的情况）

乱码是指在字符编码和解码的过程中，由于编码和解码所采用的字符集不一致，或者编码和解码所采用的字符集不支持某些字符，导致最终显示的字符与原始字符不一致。为了避免乱码的问题，我们需要统一使用一个字符集，并且在进行字符编码和解码时要保持一致。

常见的字符编码

• ANSI 编码（American National Standards Institute：美国国家标准协会）：采用1个字节编码，支持英文、拉丁文等字符。两个ANSI码可以表示一个汉字。
• Unicode 编码：可表示所有语言的字符。采用了十六进制表示，占用 2 个字节或 4 个字节，最多可表示超过一百万个字符。 （使用这种方式是有点浪费空间的，例如英文字符'a'其实采用一个字节存储就够了。）
• UTF-8 编码（Unicode Transformation Format，8-bit）：基于 Unicode 编码的可变长度字符编码，能够支持多语言和国际化的需求，使用 1~4 个字节来表示一个字符，是目前 Web 开发中最常用的字符编码方式。 （一个英文字母1个字节，一个汉字3个字节。）
• GBK 编码（Guo Biao Ku）（中）：是针对中文设计的一个汉字编码方式，使用 2 个字节来表示一个汉字，能够表示中国内地的所有汉字。

字符的计算方式

字符的计算会当作 int 整数来计算。char的本质就是一个无符号整数 （2个字节 0~65535）

布尔类型

boolean 只存在 true 和 false 两种值 不存在 0 和 1等其他值。

通常用于表示一些逻辑上的真假值，并在程序中进行逻辑控制。

运算符

• 算术运算符：+、-、*、/、%、++、--
• 关系运算符：==、!=、>、>=、<、<=
• 逻辑运算符：&、|、!、&&、||
• 按位运算符：&、|、^、~、<<、>>、>>>
• 赋值运算符：=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=、>>>=
• 条件运算符：?:
• instanceof运算符：instanceof
• new运算符：new
• .运算符：.

注意：运算符有优先级，关于优先级不需要记忆，不确定的添加小括号，添加小括号的优先级高，会先执行

接受键盘输入

import java.util.Scanner;
public class Solution {
    public static void main() {
        Scanner myScanner = new Scanner(System.in);

        byte b = myScanner.nextByte();
        short s = myScanner.nextShort();
        int i = myScanner.nextInt();
        long l = myScanner.nextLong();
        char c = myScanner.next().charAt(0);
        boolean boo = myScanner.nextBoolean();
        float f = myScanner.nextFloat();
        double d = myScanner.nextDouble();
        String str = myScanner.next();
    }
}

算术运算符

// + 加号
int i = 1;
int j = 2;
System.out.print(i + j); // -----> 3
// - 减号
int i = 1;
int j = 2;
System.out.print(i - j); // -----> -1
// * 乘号
int i = 1;
int j = 2;
System.out.print(i * j); // -----> 2
// / 除号
int i = 1;
int j = 2;
System.out.print(i / j); // -----> 0
// % 取模
int i = 1;
int j = 2;
System.out.print(i % j); // -----> a % b = a - a / b * b;
// ++ 自加
int i = 1;
i++;
System.out.print(i); // -----> 2
//--------
int i = 1;
System.out.println(i++); // -----> 1 i++是先用之后再加
System.out.println(i); // -----> 2 i++是先用之后再加
// ++i 则是先加之后再用
// -- 自减 同理自加，只是改为-1；

关系运算符

关系运算符又叫做比较运算符。包括：>、 >=、 <、 <=、 ==、 !=

所有关系运算符的运算结果都是布尔类型，不是true，就是false。

逻辑运算符

逻辑运算符：&（逻辑与）、 |（逻辑或）、 !（逻辑非）、^（逻辑异或）、 &&（短路与）、 ||（短路或）

逻辑运算符特点：逻辑运算符两边的操作数要求必须是布尔类型，并且最终运算结果也一定是布尔类型。

逻辑与&：两边操作数都是true，结果才是true。

逻辑或|：两边操作数只要有一个是true，结果就是true。

逻辑非!： !false就是true，!true就是false。

逻辑异或^：两边不一样，结果就是true。

短路与&&：和逻辑与&的运算结果相同。只是存在一种短路现象。如果左边是false 就不会判断右边。

短路或||：和逻辑或|的运算结果相同。只是存在一种短路现象。如果左边为true，就不会判断右边。

位运算

<<：左移运算符

int i = 2; 
i<<1; 
// 0000 0010 ----> 0000 0100 = 4 左移一位，相当于将数值乘以2的n次方
// 右边补0

>>：右移运算符

int i = 2; 
i>>1; 
// 0000 0010 ----> 0000 0001 = 4 左移一位，相当于将数值除以2的n次方
// 左边补符号位
int j = -1;

>>>：无符号右移

计算方式同右移运算符，但是左边补不管正负都是0

&：按位与

将两个整数的二进制表示按位进行与运算，只有当相应的二进制位都为1时，结果才为1，否则结果为0

应用一下：请使用按位与运算符判断某个数字是否为奇数？

只需要判断最右边那一位是否为1。

// 找到 1~10的奇数
public class Solution {
    public static void main(String[] args) {
        for(int i = 1; i <= 10; i++) {
            if((i & 1) == 1) {
                System.out.println(i);
            }
        }
    }
}

|：按位或

将两个整数的二进制表示按位进行或运算，只有当相应的二进制位都为0时，结果才为0，否则结果为1。

应用：请将0这个数字中从右往左数第4位的二进制位设置为1

public class Solution {
    public static void main(String[] args) {
        // 0000 0000
        // 0000 1000
        // 0000 1000
        int i = 0;
        int j = (1 << 3);
        i = i | j;
        System.out.println(i);
    }
}

^：按位异或

将两个整数的二进制表示按位进行异或运算，只有当相应的二进制位不同，结果才为1，否则结果为0。

应用：

Leetcode 136

给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。

// 核心代码模式
class Solution {
    public int singleNumber(int[] nums) {
        int res = nums[0];
        for (int i = 1; i < nums.length; i++) {
            res = res ^ nums[i];
        }
        return res;
    }
}

~：按位取反

将整数的二进制表示按位进行取反运算，即0变为1，1变为0。

应用一下：位清除操作（将某个二进制位中指定位清除为0）；例如有这样一个二进制：0b01101101，将第4个低位清除为0。

int num = 0b01101101;
int flag = 1 << 3;
int res = num & (~flag);

赋值运算符

基本赋值运算符

= 等号右边先执行，将直接结果赋值给左边的变量

扩展赋值运算符

+=、-=、*=、/=、%=、&=、|=、^=、>>=、<<=、>>>=

以 += 为例。i += 3; 表示 i = i + 3;

对于扩展赋值运算符来说，有一个非常重要的运算规则需要注意：就是自带强制类型转换

如：

byte num1 = 1;
num1 = num1 + 1; // 会报错，因为 1 是 int 类型

// ------
byte num1 = 1;
num1+=1; // 就是对的，自带了类型转换】【

条件运算符

Java 语言中的条件运算符由 ? 和 : 组成，也被称为三元运算符。它的语法格式为：

布尔表达式 ? 表达式1 : 表达式2

如果布尔表达式为真，则返回 表达式1；如果为假，则返回 表达式2；

// 示例：找到 a 和 b 中的最大值
int a = 7;
int b = 8;
int max = a > b ? a : b;

控制语句

分支语句

if 语句

// 第一种写法
/*
if(布尔表达式){
分支语句;
}
*/
int num1 = 2;
int num2 = 1;
if (num1 > num2) {
    System.out.println(num1);
}
// 原理：如果括号中的布尔表达式为真，则执行{}中的分支语句

// 第二种写法
/*
if(布尔表达式){
分支1;
}else{
分支2;
}
*/
// 原理：如果括号中的布尔表达式为真，则执行分支1，否则执行分支2；

// 第三种写法
/*
if(布尔表达式){
分支1;
}else if(布尔表达式){
分支2;
}else if(布尔表达式){
分支3;
}
*/
/* 原理，先判断第一个布尔表达式，为真，则执行分支1，之后的都不执行，
否则依次判断后面的else if 的布尔表达式
如果都为假，则执行else的分支3。
*/

注意事项

• 对于任何一个if语句来说，最多只能有一个分支执行
• 分支中如果只有一条Java语句，大括号可以省略。
• 在if选择结构中还可以嵌套别的选择结构或循环结构。

switch语句

// 第一种写法
switch(表达式) {
    case value1:
    // 当表达式的值等于 value1，那么执行这里的代码；
    break;
    case value2:
    // 当表达式的值等于 value2，那么执行这里的代码；
    break;
    case value3:
    // 当表达式的值等于 value3，那么执行这里的代码；
    break;
    ...
    defalut：
    // 前面的都不执行则执行这路的代码 default可写可不写
}

注意事项

• switch 语句适用于判断固定值。if语句适用于判断范围或区间时使用。switch能做的if肯定能做，if能完成的switch不一定能完成。
• JDK7之前，switch只支持int类型、枚举类型，在JDK7之后，增加了对字符串类型的支持。
• case 语句中的值必须是字面量，不能是变量。
• case 语句中的值必须和switch后面的值是同一类型，或者能够相互转换。
• case可以合并。
• 在每个 case 分支中要加上 break 语句，以避免case穿透现象。

// 穿透现象
public class Solution {
    public static void main(String[] args) {
        // 找到 a 和 b 中的最大值
        switch(1){
            case 1:
                System.out.println(1);
            case 2:
                System.out.println(2);
                break;
            case 3:
                System.out.println(3);
        }
    }
}

上面的代码 case1 之后没有 break 则会穿透到 case 2 也会执行。

• 在 switch 语句中，一般都应该有一个 default 分支，用于处理一些特殊情况，以避免程序出错。 （当然，default语句不写，也不会编译报错。）

Java 12 的 switch 新特性

switch(x){
    case 1 -> System.out.println(1);
    case 2 -> System.out.println(2);
    default -> System.out.println("default");
}
switch(x){
    case 1, 2, 3 -> System.out.println("123");
}
switch(x){
    case 1 -> {
        System.out.println(1);
        System.out.println(1);
    }
}

循环语句

for循环

当某代码片段需要频繁多次执行时，可以采用循环语句

// 我是一个狂热的粉丝，要对坤坤说十遍爱他
System.out.println("我爱坤坤");
System.out.println("我爱坤坤");
System.out.println("我爱坤坤");
System.out.println("我爱坤坤");
System.out.println("我爱坤坤");
System.out.println("我爱坤坤");
System.out.println("我爱坤坤");
System.out.println("我爱坤坤");
System.out.println("我爱坤坤");
System.out.println("我爱坤坤");
// 非常麻烦，而且不要加要减或者要改都非常麻烦，可以用for循环
for (int i = 0; i < 10; i++) {
    System.out.println("我爱坤坤");
}

for(初始化表达式1; 布尔表达式2; 更新表达式3) {

执行代码；

}

2(true) ---> 执行代码 ---> 3 重复到 2(false)

for循环练习题：

• 输出1~10

public class Solution {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(i + 1);
        }
    }
}

• 输出1~100中的偶数

public class Solution {
    public static void main(String[] args) {
        for (int i = 1; i <= 100; i++) {
            if ((i & 1) != 1) {
                System.out.println(i);
            }
        }
    }
}

• 输出1~100内奇数的和

public class Solution {
    public static void main(String[] args) {
        int res = 0;
        for (int i = 1; i <= 100; i++) {
            if ((i & 1) == 1) {
                res+=i;
            }
        }
        System.out.println(res);
    }
}

• 计算n的阶乘（n = 10）

public class Solution {
    public static void main(String[] args) {
        int n = 10;
        int res = 1;
        for (int i = n; i >= 1; i--) {
            res *= i;
        }
        System.out.println(res);
    }
}

for循环内还可以嵌套for循环

for 循环嵌套 for 循环指的是在一个 for 循环的循环体中再嵌套另一个 for 循环。通过嵌套 for 循环，可以在外层循环的每次迭代中执行内层循环若干次。

例如，以下代码使用 for 循环嵌套打印九九乘法表：

public class Solution {
    public static void main(String[] args) {
        for(int i = 1; i < 10; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + " x " + i + " = " + i * j + "\t");
            }
            System.out.println();
        }
    }
}

while循环

while循环语法格式：
while(布尔表达式){
循环体;
}

执行原理：只要布尔表达式为true就会一直循环，直到布尔表达式结果为false，循环结束。

while循环体的执行次数可能是：0 - n次。

for循环适用于循环次数固定的。while循环适用于循环次数不固定的。

do while循环

do while循环语法格式：
do{
循环体;
}while(布尔表达式);

执行原理：先执行一次循环体，再判断布尔表达式，为true继续循环，直到布尔表达式结果为false，循环结束。

do while循环体的执行次数可能是：1 - n次。

do while循环比较适合用在不管条件是否成立，第一次必须要执行的业务。

跳转语句

break;

出现在switch语句用来终止switch语句的执行。

出现在循环中，用来终止循环的执行。

break;终止离它最近的循环。

break 循环标记; 用来终止指定的循环。

基本语法：

label:(标签) 每个for 循环前都可以加标签
for (...) {
    for (...) {
        if (条件) {
            break label;
        }
    }
}

continue;

终止当前本次循环，直接进入下一次循环继续执行。

continue; 终止当前本次循环，直接进入离它最近的循环继续。

continue 循环标记; 终止当前本次循环，直接进入指定的循环继续。（同break）

break;与return;

break;终止循环。

return;终止方法。

方法

方法就是可以重复利用的代码片段。一个方法一般都是一个独立的功能。在C语言中叫做函数（Function）。

语法格式：
[修饰符列表] 返回值类型 方法名(形式参数列表){
    方法体;
}

修饰符列表：可选项。

返回值类型：用来指定方法返回值的数据类型（方法执行结束后的结果类型）。只要是Java合法的数据类型，都可以

方法名：只要是合法的标识符即可。但最好见名知意。方法通常反映行为，所以方法名一般为动词。

形式参数列表：简称形参。用来接收数据。参数个数0~N个。如果有多个，使用逗号隔开。

每个方法都有方法体，方法体是一对大括号。在大括号中编写Java语句。

方法的调用：如果修饰符列表中static关键字，采用“类名.方法名(实际参数列表);”调用方法。

• 调用者和被调用者在同一个类中，“类名.”可以省略。
• 实际参数列表：简称实参，实参和形参要一一对应，个数对应，数据类型对应。

用方法，如果方法执行结束后有返回值，可以采用变量接收该返回值。当然，也可以选择不接收。

方法执行时的内存变换

方法重载

方法重载（overload）：编译阶段的一种机制（静态多态）

什么情况下构成方法重载？

• 在同一个类中
• 方法名相同
• 参数列表不同

什么时候我们考虑使用方法重载？

在同一个类中，如果功能相似，建议使用方法重载。

递归

什么是方法的递归调用？

就是方法自己调用自己。

递归时，内存是如何变化的？

虚拟机栈先进后出。

递归使用注意事项？

递归必须要有结束条件。

递归必须要有结束条件。

包机制

包机制作用：便于代码管理。

怎么定义包：在java源码第一行编写 package 语句。注意：package语句只能出现在java代码第一行。

包名命名规范中要求是全部小写。

包名命名规范：公司域名倒序 + 项目名 + 模块名 + 功能名。

如果带包编译：

javac -d 编译后的存放目录 java源文件路径

javac -d . Hello.java (. 代表当前目录下)

有了包机制后，完整类名是包含包名的，例如类名是：com.javase.chapter01.PackageTest

import

import语句用来引入其他类。

A类中使用B类，A类和B类不在同一个包下时，就需要在A类中使用import引入B类。

java.lang包下的不需要手动引入。

import语句只能出现在package语句之下，class定义之前。

import语句可以编写多个。

import语句可以模糊导入：java.util.*;

import静态导入：import static java.lang.System.*;