JavaSE基础语法

Ying_526_2023-11-08 19:38

文章目录

概述

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，但是到了今天这个版本基本上已经很少使用了。

环境安装

推荐使用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方法

Java 复制代码 
public class HelloWorld{
	public static void main(String[] args){
		System.out.println("Hello,world");
	}
}

Java程序是如何运行的？

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

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

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

注释

Java的注释有以下三种：

  • 行注释： / / // //开头，注释一行
  • 块注释： / ∗ /* /∗ ... ∗ / */ ∗/ 注释一个区域，不支持嵌套
  • 文档注释： / ∗ ∗ /** /∗∗ ... ∗ / */ ∗/
Java 复制代码 
package Demo01_BasicGrammar;
// 注释
public class D1_Annotation {
    /**
     * 我是文档注释
     * @param args
     */
    public static void main(String[] args) {
        // 我是行注释
        // int a = 0;

       /*
        我是块注释
        int b = 0;
        int c = 0;
        */
    }
}

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

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

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

标识符

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

命名规则：硬性规则

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

命名规范：软性建议

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

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

关键字

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

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

数据类型与变量

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

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

四类八种基本类型

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

注意事项：

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

常量

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

Java 复制代码 
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);
        }
}

变量

概念

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

定义

类型 变量名 = 值;

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);
    }
}

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

类型转换

自动类型转换

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

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

强制类型转换

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

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

注意：

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

类型提升

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

  1. int与long之间：int会被提升为long
Java 复制代码 
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. byte与byte的运算
Java 复制代码 
byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);

结论: byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.

由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short这种低于 4 个字节的类型, 会先提升成 int, 再参与计算。

总结：

  1. 不同类型的数据混合运算, 范围小的会提升成范围大的.

  2. 对于 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. 整形转字符串
Java 复制代码 
// 方法1
String str1 = num + ""; 
// 方法2
String str2 = String.valueOf(num);
  1. 字符串转整形
Java 复制代码 
String str = "100";
int num = Integer.parseInt(str);

运算符

算数运算符

算数运算符有+、-、*、/、%

这里我们只介绍一些取余运算符 % 其它的都很简单不作过多的介绍。

Java 复制代码 
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
    }
}

注意：

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

增量运算符

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

Java 复制代码 
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

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

自增自减运算符

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

关系运算符

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

Java 复制代码 
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

逻辑运算符

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

逻辑与 &&

真值表

Java 复制代码 
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); // 左为假 且 右为假 则结果为假

逻辑或 ||

真值表

Java 复制代码 
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); // 左为假 且 右为假 则结果为假

逻辑非 !

真值表

Java 复制代码 
int a = 1;
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true

短路求值

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

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

位运算

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

按位与 &

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

Java 复制代码 
// 示例：
int a = 10;
int b = 20;
System.out.println(a & b);// 0

按位或 |

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

Java 复制代码 
// 示例：
int a = 10;
int b = 20;
System.out.println(a | b);// 30

按位取反 ~

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

Java 复制代码 
// 示例：
int a = 10;
System.out.println(~a);// -11

按位异或 ^

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

性质：

  • a a a ^ a a a = 0 0 0;
  • a a a ^ 0 0 0 = a a a;
  • a a a ^ b b b = b b b ^ a a a
Java 复制代码 
// 示例：
int a = 10;
int b = 20;
System.out.println(a ^ b);// 30

移位运算

左移 <<

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

Java 复制代码 
// 示例：
int a = 10;
System.out.println(a << 1);// 20

右移 >>

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

Java 复制代码 
// 示例：
int a = 10;
System.out.println(a >> 1);// 5

无符号右移 >>>

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

条件运算符

条件运算符只有一个:
表达式1 ? ? ? 表达式2 : : : 表达式3

当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;

当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.

Java 复制代码 
// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

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

运算符的优先级

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

逻辑控制

顺序结构

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

Java 复制代码 
System.out.println(1);
System.out.println(2);
System.out.println(3);
// 运行结果
1
2
3

分支结构

if else

语法：

Java 复制代码 
if(表达式1) {
// ...
} else if(表达式2) {
// ...
} else {
// ...
}

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

Java 复制代码 
if (score >= 80) {
   	System.out.println("良好");
} else if (score >= 60 && score < 80) {
   	System.out.println("及格");
} else {
   	System.out.println("不及格");
}

switch case

语法：

Java 复制代码 
switch(表达式){
	case 常量值1:{
		语句1;
		[break;]
	}
	case 常量值2:{
		语句2;
		[break;]
	}
	default:{
		内容都不满足时执行语句;
		[break;]
	}
}

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

  1. 先计算表达式的值
  2. 和case依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到break时结束
  3. 当表达式的值没有与所列项匹配时，执行default
Java 复制代码 
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;
        }
    }
}

注意：

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

条件表达式

在运算符中介绍过了。

循环结构

while 循环

语法：

Java 复制代码 
while(循环条件){
循环语句;
}

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

Java 复制代码 
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. break：跳出循环
  2. continue: 跳过本次循环

for 循环

语法：

Java 复制代码 
for(表达式1;布尔表达式2;表达式3){
	表达式4;
}
  • 表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次
  • 表达式2: 循环条件，满则循环继续，否则循环结束
  • 表达式3: 循环变量更新方式
Java 复制代码 
// 示例：打印 1 - 10
for (int j = 1; j <= 10; j++) {
  	System.out.print(j + " ");
}

do while循环

语法：

Java 复制代码 
do{
循环语句;
}while(循环条件)

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

Java 复制代码 
// 示例 打印1 - 10
i = 1;
do{
    System.out.print(i + " ");
    i++;
}while(i <= 10);

从键盘读入

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

Scanner scanner = new Scanner(System.in);

int a = scanner.nextInt();

猜数字

Java 复制代码 
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();
    }
}

方法

什么是方法？

方法就是一个可以完成特定功能的代码片段，类似于 C 语言中的 "函数"。

使用方法的好处：

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

方法的定义

Java 复制代码 
修饰符 返回值类型 方法名(参数列表){
    逻辑代码...
    return 返回值;
}

示例：

Java 复制代码 
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 + ... + n的公式为sum(n) = n × ( n + 1 ) / 2 {n\times(n + 1)}/{2} n×(n+1)/2。Java中方法的形参就相当于sum函数中的自变量n，用来接收sum函数在调用时传递的值的。形参的名字可以随意取，对方法都没有任何影响，形参只是方法在定义时需要借助的一个变量，用来保存方法在调用时传递过来的值。

方法的重载

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

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)
    }
}

方法签名（重载原理）

在同一个作用域中不能定义两个相同名称的标识符。比如：方法中不能定义两个名字一样的变量，那为什么类中就可以定义方法名相同的方法呢？

方法签名即：经过编译器编译修改过之后方法最终的名字。具体方式：方法全路径名+参数列表+返回值类型，构成方法完整的名字。

就拿上面的例子举例

递归

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

Java 复制代码 
// 示例 求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. 每个空间有自己的编号，其实位置的编号为0，即数组的下标。

数组的定义

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

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

动态初始化

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

Java 复制代码 
int[] arr = new int[n];

静态初始化

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

Java 复制代码 
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. fori遍历
Java 复制代码 
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. foreach遍历
Java 复制代码 
int[] arr = {1, 2, 3};
for (int num : arr) {
   	System.out.print(num + " ");
}

二维数组

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

语法：

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

Java 复制代码 
int[][] arr = new int[2][3];

不规则的二维数组

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

Java 复制代码 
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};
    }
}

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

相关推荐
枫叶_v28 分钟前
【SpringBoot】20 同步调用、异步调用、异步回调
java·spring boot·后端
鸣弦artha34 分钟前
蓝桥杯——杨辉三角
java·算法·蓝桥杯·eclipse
大波V543 分钟前
设计模式-参考的雷丰阳老师直播课
java·开发语言·设计模式
计算机-秋大田1 小时前
基于微信小程序的平安驾校预约平台的设计与实现(源码+LW++远程调试+代码讲解等)
java·spring boot·微信小程序·小程序·vue·课程设计
《源码好优多》1 小时前
基于Java Springboot旅游信息推荐系统
java·spring boot·旅游
岁月无声code1 小时前
Spring Boot 牛刀小试 org.springframework.boot:spring-boot-maven-plugin:找不到类错误
java·spring boot·github
Elastic 中国社区官方博客1 小时前
开始使用 Elastic AI Assistant 进行可观察性和 Microsoft Azure OpenAI
大数据·人工智能·elasticsearch·microsoft·搜索引擎·全文检索·azure
不爱学习的YY酱1 小时前
【计网不挂科】计算机网络第二章＜ 物理层 ＞习题库（含答案）
java·数据库·计算机网络
南城花随雪。2 小时前
Spring框架之装饰者模式 (Decorator Pattern)
java·开发语言·装饰器模式
编程、小哥哥2 小时前
设计模式之装饰器模式(SSO单点登录功能扩展，增加拦截用户访问方法范围场景)
java·设计模式·装饰器模式
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04智能车联网安全发展形势、挑战05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07Python数据分析案例31——中国A股的月份效应研究(方差分析，虚拟变量回归)08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10怎样让音频速度变慢？请跟随以下方法进行操作