JavaSE基础语法

概述

java是一门优秀的程序设计语言，它具有令人赏心悦目的语法和易于理解的语义。

什么是编程语言（程序设计语言）？

答：编程语言可以简单的理解为一种计算机和人都能识别的语言。一种计算机语言让程序员能够准确地定义计算机所需要使用的数据，并精确地定义在不同情况下所应当采取的行动。说人话，就是让人和计算机交流的语言，通过和计算机进行交互，完成一些特定的功能的语言就是编程语言。

java也是一门有着一系列计算机软件和规范形成的技术体系的高级语言。

什么是高级语言？

答：要想了解什么是高级语言，就要先了解机器语言，由于计算机只能直接识别0 1这样的二进制序列，在CPU设计的时，就会设计一些指令来完成一些基本功能，通过这些基本功能的组合来完成一些复杂的计算。（下面的指令只是举例）

• 机器语言：直接用过CPU指令和计算机进行交互，由于二进制序列不方便记忆，所以使用起来非常麻烦，经常需要查手册，但是机器语言直接和CPU打交道，运行速度特别快。
  

• 汇编语言：由于二进制指令不方便记忆，汇编语言使用助记符，汇编器会将对应的助记符解析成二进制指令，进而由计算机执行。
  

• 高级语言：是一种独立于机器，面向过程或对象的语言。高级语言是参照数学语言而设计的近似于日常会话的语言。高级语言会先被编译器转换为汇编语言，再经过汇编器转换成机器指令。

高级语言和汇编与机器指令（机器码 machine code）相比，只需要更低的学习和使用成本，更接近于人类交互的方式。

那么汇编语言和高级语言比较，我们就不需要去阅读特定CPU的汇编码，我只需要写通用的高级语言的源代码就可以实现程序的编写，我们用将更偏机器实现的汇编语言称为低级语言，与汇编相比之上的语言，我们称之为高级语言，综上是什么是高级语言；

发展历程

java 语言源于 1991 年 4 月，Sun 公司 james Gosling(祖师爷)博士 领导的绿色计划(Green Project) 开始启动，此计划最初的目标是开发一种能够在各种消费性电子产品(如机顶盒、冰箱、收音机等)上运行的程序架构。这个就是java的前身： Oak (得名与java创始人james Gosling办公室外的一棵橡树)，但由于这些智能化家电的市场需求没有预期的高，智能家居在那时太过超前，Sun公司放弃了该项计划。随着1995年代互联网的发展，Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以java的名称正式发布，并提出“Write once, Run anywhere" 的口号。

什么是Write once, Run anywhere?

Write once, Run anywhere 一次编译，到处运行。这是java语言跨平台特性的一个体现，只需要将一个java源文件（xxx.java）进行编译后得到字节码文件（xxx.class）后，就可以在其它装有java环境的设备上运行。

发展历程：

版本

• javaSE（java Standard Edition），即java标准版，可以用于开发一些简单的程序，如桌面应用，嵌入式等待…
• javaEE(java Enterprise Edition），即java企业版，早些年也称作j2EE。企业版可以增加开发效率，是在SE的基础上构建的，通常用于企业级开发。
• javaME（java Micro Edition），即java用于开发嵌入式的版本，之前也称作j2ME，但是到了今天这个版本基本上已经很少使用了。

环境安装

• windows环境请点我！！！！
• Linux 环境请点我！！！！
• Mac 环境请点我
• java相关软件含jDK请点我！！！提取码: mcbd

推荐使用IDEA集成开发环境。

jDK、jRE、jVM是什么?

答：

• jDK java 软件开发包
• jRE java 运行时环境
• java java 虚拟机

java程序都是跑在java虚拟机上的，jRE中包含了java运行所需的核心类库。jDK里面则是开发者软件包。关系：jDK包含jRE，jRE包含jVM。

main方法

java程序的结构由如下三个部分组成：

1. 源文件（扩展名为*.java)：源文件带有类的定义。类用来表示程序的一个组件，小程序或许只会有一个类。类的内容必须包含在花括号里面。
2. 类：类中带有一个或多个方法。方法必须在类的内部声明
3. 方法：在方法的花括号中编写方法应该执行的语句

注意，在一个源文件中只能有一个public修饰的类，而且源文件名字必须与public修饰的类名字相同。

java main方法

public class HelloWorld{
	public static void main(String[] args){
		System.out.println("Hello,world");
	}
}
1
2
3
4
5

java程序是如何运行的？

首次书写HelloWorld程序时的易错点：

1. 源文件名后缀不是.java
2. 类名与文件名不一致
3. main方法名字写错：mian
4. 类没有使用public修饰
5. 方法中语句没有以分号结尾
6. 中文格式的分号
7. jDK环境没有配置好，操作系统不能识别javac或者java命令

从这里开始，就开始分享java的基础语法了。会介绍高级语言基本上相同的部分。介绍注释、标识符、数据类型、运算符、选择、循环、方法…

注释

java的注释有以下三种：

• 行注释： $//$开头，注释一行
• 块注释：$/\ast$ … $\ast /$ 注释一个区域，不支持嵌套
• 文档注释： $/\ast \ast$ … $\ast /$

package Demo01_BasicGrammar;
// 注释
public class D1_Annotation {
    /**
     * 我是文档注释
     * @param args
     */
    public static void main(String[] args) {
        // 我是行注释
        // int a = 0;

       /*
        我是块注释
        int b = 0;
        int c = 0;
        */
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

无论是哪种注释都是不参与编译的，在编译前会被去掉，即编译后的字节码文件（.class）中不会包含注释信息。

注释是为了我们更好的理解程序，并且能够提高协同和开发效率，在写代码时写好注释是一个良好的习惯。注释的一些规范：

1. 内容准确: 注释内容要和代码一致， 匹配, 并在代码修改时及时更新
2. 篇幅合理: 注释既不应该太精简， 也不应该长篇大论
3. 使用中文: 一般中国公司都要求使用中文写注释, 外企另当别论
4. 积极向上: 注释中不要包含负能量

标识符

标识符即：在程序中由用户给类名、方法名或者变量所取的名字

命名规则：硬性规则

• 只能由字母、数字以及 下划线和 $ 符号组成
• 不能以数字开头
• 不能和关键字冲突，且严格区分大小写。

命名规范：软性建议

• 类名：每个单词的首字母大写(大驼峰)
• 方法名与变量名：首字母小写，后面每个单词的首字母大写(小驼峰)
• 包名：全部小写

一个大型程序，往往是由多名工程师，或多个部门共同协作完成，如果随意命名会降低代码的可读性，增加维护成本。如果大家都遵循一定的命名规范那么写出代码可读性就会很好。

关键字

关键字是java以及定义好的、具有特殊含义的具有特殊含义的标识符，或者保留字。

这些高亮的就是关键字。这里给出关键字表，不用记忆，学习后多使用就能记住了。

数据类型与变量

java语言的数据类型分为两大类：

• 基本数据类型：包括 整型 、 浮点型 、 字符型 、 布尔型
• 引用数据类型：包括 类、 数组 、 接口等

四类八种基本类型

• 整形
  • byte 字节型 占$1$个字节 取值范围 $-128$ ~ $127$
  • short 短整型 占$2$个字节 取值范围 $-32768$ ~ $32767$
  • int 整形 占$4$个字节 取值范围 $-2^{3}1$ ~ $2^{31}-1$
  • long 长整形占$8$个字节 取值范围 $-2^{63}$ ~ $2^{63}-1$
• 浮点型（IEEE754标准）
  • float 单精度浮点型 占$4$个字节
  • double 双精度浮点型占$8$个字节1$
• 字符型 char 占$2$个字节 取值范围$0$ ~ $65535$
• 布尔类型 boolean
  • java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在Oracle公司的虚拟机实现中，boolean占$1$个字节
  • 取值为 true、false

注意事项：

1. 不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节（跨平台）
2. 整形和浮点型都是带有符号的
3. 整型默认为int型，浮点型默认为double
4. 字符串属于引用类型

常量

常量即程序运行期间，固定不变的量称为常量。

package Demo01_BasicGrammar;
// 常量
public class D2_Constant {
        public static void main(String[] args){
            // 字符串常量
            System.out.println("hello world!");
            // 整形常量
            System.out.println(100);
            // 浮点型常量
            System.out.println(3.14);
            // 字符型常量
            System.out.println('A');
            // 不二型常量
            System.out.println(true);
            System.out.println(false);
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

变量

概念

变量就是可以改变的量，变量会在内存中申请一块儿内存，存放变量的值，这个值是可以改变的。java是一门强类型的语言，定义变量时，必须要指明其类型。

定义

类型 变量名 = 值;

package Demo01_BasicGrammar;

public class D03_Variate {
    public static void main(String[] args) {
        // 字节型
        byte a = 100;
        System.out.println(a);
        // 短整型
        short b = 101;
        System.out.println(b);
        // 整型
        int c = 102;
        System.out.println(c);
        // 长整型
        long d = 103L;
        System.out.println(d);
        // 单精度浮点型
        float e = 5.2F;
        System.out.println(e);
        // 双精度浮点型
        double f = 8.5D;
        System.out.println(f);
        // 布尔型
        boolean g = false;
        System.out.println(g);
        // 字符型
        char h = 'A';
        System.out.println(h);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

注意，java 中的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true， 0 表示 false 这样的用法。

类型转换

自动类型转换

自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。

• 数据范围小和数据范围大的进行运算时，数据范围小的会自动转为数据范围大的，再进行计算，这个转换是编译器自动进行。

强制类型转换

强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。

• 数据范围大的转成数据范围小的，不安全，需要进行强转。在数据范围前加上（要强转的类型） 比如 (int)3.3

注意：

1. 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型
2. 如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失
3. 将一个字面值常量进行赋值的时候, java 会自动针对数字范围进行检查
4. 强制类型转换不一定能成功，不相干的类型不能互相转换

类型提升

不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。

1. int与long之间：int会被提升为long

int a = 10;
long b = 20;
int c = a + b; // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
long d = a + b; // 编译成功：a + b==>int + long--->long + long 赋值给long
1
2
3
4

2. byte与byte的运算

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
1
2
3
4

结论: byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.
由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short这种低于 4 个字节的类型, 会先提升成 int, 再参与计算。

总结：
3. 不同类型的数据混合运算, 范围小的会提升成范围大的.
4. 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算.

字符串类型

String类型是一种引用数据类型，可以存储一段连续的字符串。

package Demo01_BasicGrammar;

public class D04_String {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1);
        System.out.println(s2);
        // s1+s2表示：将s1和s2进行拼接
        System.out.println(s1+s2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

这里简单介绍两个方法

1. 整形转字符串

// 方法1
String str1 = num + ""; 
// 方法2
String str2 = String.valueOf(num);
1
2
3
4

2. 字符串转整形

String str = "100";
int num = Integer.parseInt(str);
1
2

运算符

算数运算符

算数运算符有+、-、*、/、%
这里我们只介绍一些取余运算符 % 其它的都很简单不作过多的介绍。

package Demo01_BasicGrammar;

public class D05_Remainder {
    public static void main(String[] args) {
        System.out.println(10 % 3); // 1
        System.out.println(10 % -3);// 1
        System.out.println(-10 % 3);// -1
        System.out.println(-10 % -3);// -1
        System.out.println(11.5 % 2);// 1.5
    }
}
1
2
3
4
5
6
7
8
9
10
11

注意：

• 做除法和取模时，右操作数不能为0
• % 不仅可以对整型取模，也可以对double类型取模，但是没有意义，一般都是对整型取模的

增量运算符

增量运算符有+=、-=、*=、/=、%=等，这种操作符运算完成后，会将操纵的结果赋值给左操作数。

int a = 1;
a += 2; // 相当于 a = a + 2
System.out.println(a); // 输出3
a -= 1; // 相当于 a = a - 1
System.out.println(a); // 输出2
a *= 3; // 相当于 a = a * 3
System.out.println(a); // 输出6
a /= 3; // 相当于 a = a / 3
System.out.println(a); // 输出2
a %= 3; // 相当于 a = a % 2
System.out.println(a); // 输出2
1
2
3
4
5
6
7
8
9
10
11

只有变量才能使用增量运算符，常量不能使用。

自增自减运算符

自增运算符++ ，自减运算符 --。注意区分前置还是后置。前置是先++再使用，后置是先使用再++。

关系运算符

关系运算符有== != > < >= <=等，其运算结果为布尔值，true 或 false。

int a = 10;
int b = 20;
// 在java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false
1
2
3
4
5
6
7
8
9

逻辑运算符

逻辑运算符主要有 && || ! ，运算结果为布尔值，true 或 false

逻辑与 &&

真值表

int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假
1
2
3
4
5
6

逻辑或 ||

真值表

int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2); // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假
1
2
3
4
5
6

逻辑非 !

真值表

int a = 1;
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true
1
2
3

短路求值

&& 和 || 遵守短路求值的规则。

• 对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.
• 对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.
• & 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值.

位运算

位运算符主要有四个 & | ~ ^ ，除 ~ 是一元（一个操作数）运算符外，其余都是二元（两个操作数）运算符。

按位与 &

如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.

// 示例：
int a = 10;
int b = 20;
System.out.println(a & b);// 0
1
2
3
4

按位或 |

如果两个二进制位都是 0, 则结果为 0, 否则结果为 1

// 示例：
int a = 10;
int b = 20;
System.out.println(a | b);// 30
1
2
3
4

按位取反 ~

如果该位为 0 则转为 1, 如果该位为 1 则转为 0

// 示例：
int a = 10;
System.out.println(~a);// -11
1
2
3

按位异或 ^

如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1(简单记忆为无进位相加)
性质：

• $a$ ^ $a$ = $0$;
• $a$ ^ $0$ = $a$;
• $a$ ^ $b$ = $b$ ^ $a$

// 示例：
int a = 10;
int b = 20;
System.out.println(a ^ b);// 30
1
2
3
4

移位运算

左移 <<

最左侧位不要了, 最右侧补 0 （左移以为相当于 $\times$ 2）

// 示例：
int a = 10;
System.out.println(a << 1);// 20
1
2
3

右移 >>

最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)，右移一位相当于$/2$

// 示例：
int a = 10;
System.out.println(a >> 1);// 5
1
2
3

无符号右移 >>>

最右侧位不要了, 最左侧补 0

条件运算符

条件运算符只有一个:
表达式1 $?$ 表达式2 $:$ 表达式3
当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;
当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
1
2
3
4

表达式不能单独存在，其产生的结果必须要被使用。

运算符的优先级

在一条表达式中，各个运算符可以混合起来进行运算，但是运算符的优先级不同，比如：* 和 / 的优先级要高于 +和 - ，有些情况下稍不注意，可能就会造成很大的麻烦。我们在不需要去记忆这些运算符的优先级，没有把握时加上括号就可以了

逻辑控制

顺序结构

顺序结构比较简单，按照代码书写的顺序一行一行执行

System.out.println(1);
System.out.println(2);
System.out.println(3);
// 运行结果
1
2
3
1
2
3
4
5
6
7

分支结构

if else

语法：

if(表达式1) {
// ...
} else if(表达式2) {
// ...
} else {
// ...
}
1
2
3
4
5
6
7

表达式1为真执行①，表达式2为真执行②，否则执行③

if (score >= 80) {
   	System.out.println("良好");
} else if (score >= 60 && score < 80) {
   	System.out.println("及格");
} else {
   	System.out.println("不及格");
}
1
2
3
4
5
6
7

switch case

语法：

switch(表达式){
	case 常量值1:{
		语句1;
		[break;]
	}
	case 常量值2:{
		语句2;
		[break;]
	}
	default:{
		内容都不满足时执行语句;
		[break;]
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

通过表达式的值来寻求走哪个分支。

1. 先计算表达式的值
2. 和case依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到break时结束
3. 当表达式的值没有与所列项匹配时，执行default

package Demo01_BasicGrammar;

public class D06_Choice {
    public static void main(String[] args) {
        int day = 1;
        switch (day) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期日");
                break;
            default:
                System.out.println("输入有误");
                break;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

注意：

• 多个case后的常量值不可以重复
• switch的括号内只能是以下类型的表达式：
  • 基本类型：byte、char、short、int，注意不能是long类型
  • 引用类型：String常量串、枚举类型
• switch的括号内不能是 float、double、long

条件表达式

在运算符中介绍过了。

循环结构

while 循环

语法：

while(循环条件){
循环语句;
}
1
2
3

循环条件为 true, 则执行循环语句; 否则结束循环

package Demo01_BasicGrammar;
// while 打印 1 - 10 之间的数字
public class D07_While {
    public static void main(String[] args) {
        int i = 1;
        while(i <= 10) {
            System.out.print(i + " ");
            i++;// 改变量
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

1. break：跳出循环
2. continue: 跳过本次循环

for 循环

语法：

for(表达式1;布尔表达式2;表达式3){
	表达式4;
}
1
2
3

• 表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次
• 表达式2: 循环条件，满则循环继续，否则循环结束
• 表达式3: 循环变量更新方式

// 示例：打印 1 - 10
for (int j = 1; j <= 10; j++) {
  	System.out.print(j + " ");
}
1
2
3
4

do while循环

语法：

do{
循环语句;
}while(循环条件)
1
2
3

先执行循环语句, 再判定循环条件，循环条件成立则继续执行，否则循环结束。(至少执行一次)

// 示例 打印1 - 10
i = 1;
do{
    System.out.print(i + " ");
    i++;
}while(i <= 10);
1
2
3
4
5
6

从键盘读入

使用 Scanner 读取字符串/整数/浮点数

Scanner scanner = new Scanner(System.in);
int a = scanner.nextInt();

猜数字

package Demo01_BasicGrammar;

import java.util.Scanner;

public class D08_Guess {
    public static void guessGame() {
        // [1,100]
        int random = (int) (Math.random() * 100 + 1);
        int number = 0;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请猜数字(1~100)->");
        while (true) {
            number = scanner.nextInt();
            if (number < random) {
                System.out.println("猜小了");
            } else if (number > random) {
                System.out.println("猜大了");
            } else {
                System.out.println("猜对了!!! exit");
                break;
            }
        }
    }

    public static void main(String[] args) {
        guessGame();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

方法

什么是方法？

方法就是一个可以完成特定功能的代码片段，类似于 C 语言中的 “函数”。
使用方法的好处：

1. 是能够模块化的组织代码(当代码规模比较复杂的时候)
2. 防止代码冗余
3. 让代码更好理解更简单

方法的定义

修饰符 返回值类型 方法名(参数列表){
    逻辑代码...
    return 返回值;
}
1
2
3
4

示例：

package Demo01_BasicGrammar;
// 方法
public class D09_Method {
    public static int add(int a,int b) {
        return a + b;
    }
    public static void main(String[] args) {
        int c = add(1,4);
        System.out.println(c);// 5
    }
}
1
2
3
4
5
6
7
8
9
10
11

方法的调用过程

调用方法—>传递参数—>找到方法地址—>执行被调方法的方法体—>被调方法结束返回—>回到主调方法继续往下执行

实参和形参

方法的形参相当于数学函数中的自变量，比如：1 + 2 + 3 + … + n的公式为sum(n) = $n\times (n+1)/2$。java中方法的形参就相当于sum函数中的自变量n，用来接收sum函数在调用时传递的值的。形参的名字可以随意取，对方法都没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。

方法的重载

在java中，如果多个方法的名字相同，参数列表不同，则称该几种方法被重载了。

package Demo01_BasicGrammar;

public class D10_Overload {
    public static int add(int x, int y) {
        return x + y;
    }

    public static double add(double x, double y) {
        return x + y;
    }
    public static double add(double x, double y, double z) {
        return x + y + z;
    }
    public static void main(String[] args) {
        add(1, 2); // 调用add(int, int)
        add(1.5, 2.5); // 调用add(double, double)
        add(1.5, 2.5, 3.5); // 调用add(double, double, double)
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

方法签名（重载原理）

在同一个作用域中不能定义两个相同名称的标识符。比如：方法中不能定义两个名字一样的变量，那为什么类中就可以定义方法名相同的方法呢？
方法签名即：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。
就拿上面的例子举例

递归

一个方法在执行过程中调用自身, 就称为 “递归”

// 示例 求N！
// 0! = 1,1! = 1
// N! = N * (N  - 1) * ... * 3 * 2 * 1;
package Demo01_BasicGrammar;

public class D11_Fac {
    public static int fac(int n) {
        if (n == 1) {
            return 1;
        }

        return n * fac(n - 1);
    }

    public static void main(String[] args) {
    	fac(5);
        System.out.println(fac(5));// 120
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

调用过程：

数组

数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。

1. 数组中存放的元素其类型相同
2. 数组的空间是连续的
3. 每个空间有自己的编号，其实位置的编号为0，即数组的下标。
   

数组的定义

T[] 数组名 = new T[N];

• T：类型
• T[ ]：数组的类型
• N：数组的长度

动态初始化

动态初始化，只指定数组的长度，由系统为数组的每个元素分配初始值；

int[] arr = new int[n]; 
1

静态初始化

静态初始化，创建数组时，显式的指定数组元素的初始值，数组的长度由系统根据元素的格式来决定；

int[] arr=new int[]{1,2,3,4,5,6,7,8,9	};
// 或者
int[] arr = {1,2,3,4,5,6,7,8,9};
1
2
3

数组的遍历

1. fori遍历

int[] arr = {1,2,3,4,5,6,7,8,9};
for(int i = 0;i < arr.length;i++){
	System.out.print(arr[i] + " ");
}
1
2
3
4

2. foreach遍历

int[] arr = {1, 2, 3};
for (int num : arr) {
   	System.out.print(num + " ");
}
1
2
3
4

二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组。
语法：

数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };

int[][] arr = new int[2][3];
1

不规则的二维数组

如果不指定列，那么这个二维数组就是一个不规则的二维数组。

package Demo01_BasicGrammar;

public class D12_Array {
    public static void main(String[] args) {
        int[][] arr = new int[3][];
        arr[0] = new int[]{1};
        arr[1] = new int[]{1,2};
        arr[2] = new int[]{1,2,3};
    }
}
1
2
3
4
5
6
7
8
9
10

本小节到这里就结束了，如果对你有帮助，请点赞，评论，转发，你的支持是我创作的动力。