java语法基础,java语法基础知识 收藏 0

写给小白看的入门级 Java 基本语法

文章来源：https://mp.weixin.qq.com/s/tJ8ata36rogJTwgoRyGHAQ

作者：沉默王二

有一句留言深深地刺痛了我：

培训班学习半年，工作半年，我现在都看不懂你这篇文章，甚至看不下去，对于我来说有点深。

从表面上看，这句话有点讽刺我的文章写得不够通俗易懂的意味，但我心胸一直如大海一般开阔，你了解的。所以，我回他，“你还不如把培训费给我，哈哈。”怎么样，你也能体会到我的幽默，以及无情吧？当然了，是时候写一篇文章（也许是一个系列哦）照顾一下顾小白群体的情绪了，帮他们入入门或者回炉再造下。

众所周知，Java 是一门面向对象的编程语言。它最牛逼的地方就在于它是跨平台的，你可以在 Windows 操作系统上编写 Java 源代码，然后在 Linux 操作系统上执行编译后的字节码，而无需对源代码做任何的修改。

Java 有 2 种数据类型，一种是基本数据类型，一种是引用类型。

基本数据类型用于存储简单类型的数据，比如说，int、long、byte、short 用于存储整数，float、double 用于存储浮点数，char 用于存储字符，boolean 用于存储布尔值。

不同的基本数据类型，有不同的默认值和大小，来个表格感受下。

引用类型用于存储对象（null 表示没有值的对象）的引用，String 是引用类型的最佳代表，比如说 String cmower = \”沉默王二\”。

要声明一个变量，必须指定它的名字和类型，来看一个简单的示例：

count 和 name 在声明后会得到一个默认值，按照它们的数据类型——不能是局部变量（否则 Java 编译器会在你使用变量的时候提醒要先赋值），必须是类成员变量。

也可以在声明一个变量后使用“=”操作符进行赋值，就像下面这样：

我们定义了 2 个变量，int 类型的 age 和 String 类型的 name，age 赋值 18，name 赋值为“沉默王二”。

每行代码后面都跟了一个“;”，表示当前语句结束了。

在 Java 中，变量最好遵守命名约定，这样能提高代码的可阅读性。

• 以字母、下划线（_）或者美元符号（$）开头
• 不能使用 Java 的保留字，比如说 int 不能作为变量名

数组在 Java 中占据着重要的位置，它是很多集合类的底层实现。数组属于引用类型，它用来存储一系列指定类型的数据。

声明数组的一般语法如下所示：

type 可以是任意的基本数据类型或者引用类型。来看下面这个例子：

数组的索引从 0 开始，第一个元素的索引为 0，第二个元素的索引为 1。为什么要这样设计？感兴趣的话，你可以去探究一下。

通过变量名[索引]的方式可以访问数组指定索引处的元素，赋值或者取值是一样的。

关键字属于保留字，在 Java 中具有特殊的含义，比如说 public、final、static、new 等等，它们不能用来作为变量名。为了便于你作为参照，我列举了 48 个常用的关键字，你可以瞅一瞅。

1. abstract： abstract 关键字用于声明抽象类——可以有抽象和非抽象方法。
2. boolean： boolean 关键字用于将变量声明为布尔值类型，它只有 true 和 false 两个值。
3. break： break 关键字用于中断循环或 switch 语句。
4. byte： byte 关键字用于声明一个可以容纳 8 个比特的变量。
5. case： case 关键字用于在 switch 语句中标记条件的值。
6. catch： catch 关键字用于捕获 try 语句中的异常。
7. char： char 关键字用于声明一个可以容纳无符号 16 位比特的 Unicode 字符的变量。
8. class： class 关键字用于声明一个类。
9. continue： continue 关键字用于继续下一个循环。它可以在指定条件下跳过其余代码。
10. default： default 关键字用于指定 switch 语句中除去 case 条件之外的默认代码块。
11. do： do 关键字通常和 while 关键字配合使用，do 后紧跟循环体。
12. double： double 关键字用于声明一个可以容纳 64 位浮点数的变量。
13. else： else 关键字用于指示 if 语句中的备用分支。
14. enum： enum（枚举）关键字用于定义一组固定的常量。
15. extends： extends 关键字用于指示一个类是从另一个类或接口继承的。
16. final： final 关键字用于指示该变量是不可更改的。
17. finally： finally 关键字和 try-catch 配合使用，表示无论是否处理异常，总是执行 finally 块中的代码。
18. float： float 关键字用于声明一个可以容纳 32 位浮点数的变量。
19. for： for 关键字用于启动一个 for 循环，如果循环次数是固定的，建议使用 for 循环。
20. if： if 关键字用于指定条件，如果条件为真，则执行对应代码。
21. implements： implements 关键字用于实现接口。
22. import： import 关键字用于导入对应的类或者接口。
23. instanceof： instanceof 关键字用于判断对象是否属于某个类型（class）。
24. int： int 关键字用于声明一个可以容纳 32 位带符号的整数变量。
25. interface： interface 关键字用于声明接口——只能具有抽象方法。
26. long： long 关键字用于声明一个可以容纳 64 位整数的变量。
27. native： native 关键字用于指定一个方法是通过调用本机接口（非 Java）实现的。
28. new： new 关键字用于创建一个新的对象。
29. null： 如果一个变量是空的（什么引用也没有指向），就可以将它赋值为 null。
30. package： package 关键字用于声明类所在的包。
31. private： private 关键字是一个访问修饰符，表示方法或变量只对当前类可见。
32. protected： protected 关键字也是一个访问修饰符，表示方法或变量对同一包内的类和所有子类可见。
33. public： public 关键字是另外一个访问修饰符，除了可以声明方法和变量（所有类可见），还可以声明类。main() 方法必须声明为 public。
34. return： return 关键字用于在代码执行完成后返回（一个值）。
35. short： short 关键字用于声明一个可以容纳 16 位整数的变量。
36. static： static 关键字表示该变量或方法是静态变量或静态方法。
37. strictfp： strictfp 关键字并不常见，通常用于修饰一个方法，确保方法体内的浮点数运算在每个平台上执行的结果相同。
38. super： super 关键字可用于调用父类的方法或者变量。
39. switch： switch 关键字通常用于三个（以上）的条件判断。
40. synchronized： synchronized 关键字用于指定多线程代码中的同步方法、变量或者代码块。
41. this： this 关键字可用于在方法或构造函数中引用当前对象。
42. throw： throw 关键字主动抛出异常。
43. throws： throws 关键字用于声明异常。
44. transient： transient 关键字在序列化的使用用到，它修饰的字段不会被序列化。
45. try： try 关键字用于包裹要捕获异常的代码块。
46. void： void 关键字用于指定方法没有返回值。
47. volatile： volatile 关键字保证了不同线程对它修饰的变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
48. while： 如果循环次数不固定，建议使用 while 循环。

05、操作符

除去“=”赋值操作符，Java 中还有很多其他作用的操作符，我们来大致看一下。

①、算术运算符

• +（加号）
• –（减号）
• *（乘号）
• /（除号）
• ％（取余）

来看一个例子：

“+”号比较特殊，还可以用于字符串拼接，来看一个例子：

②、逻辑运算符

逻辑运算符通常用于布尔表达式，常见的有：

• &&（AND）多个条件中只要有一个为 false 结果就为 false
• ||（OR）多个条件只要有一个为 true 结果就为 true
• !（NOT）条件如果为 true，加上“!”就为 false，否则，反之。

来看一个例子：

③、比较运算符

• < (小于)
• <= (小于或者等于)
• > (大于)
• >= (大于或者等于)
• == (相等)
• != (不等)

Java 中最小的程序单元叫做类，一个类可以有一个或者多个字段（也叫作成员变量），还可以有一个或者多个方法，甚至还可以有一些内部类。

如果一个类想要执行，就必须有一个 main 方法——程序运行的入口，就好像人的嘴一样，嗯，可以这么牵强的理解一下。

通常，一些教程在介绍这块内容的时候，建议你通过命令行中先执行 javac 命令将源代码编译成字节码文件，然后再执行 java 命令指定代码。

但我不希望这个糟糕的局面再继续下去了——新手安装配置 JDK 真的蛮需要勇气和耐心的，稍有不慎，没入门就先放弃了。况且，在命令行中编译源代码会遇到很多莫名其妙的错误，这对新手是极其致命的——如果你再遇到这种老式的教程，可以吐口水了。

好的方法，就是去下载 IntelliJ IDEA，简称 IDEA，它被业界公认为最好的 Java 集成开发工具，尤其在智能代码助手、代码自动提示、代码重构、代码版本管理(Git、SVN、Maven)、单元测试、代码分析等方面有着亮眼的发挥。IDEA 产于捷克（位于东欧），开发人员以严谨著称。IDEA 分为社区版和付费版两个版本，新手直接下载社区版就足够用了。

安装成功后，可以开始敲代码了，然后直接右键运行（连保存都省了），结果会在 Run 面板中显示，如下图所示。

想查看反编译后的字节码的话，可以在 src 的同级目录 target/classes 的包路径下找到一个 StructureProgram.class 的文件（如果找不到的话，在目录上右键选择「Reload from Disk」）。

可以双击打开它。

IDEA 默认会用 Fernflower 将 class 字节码反编译为我们可以看得懂的 Java 代码。实际上，class 字节码（请安装 show bytecode 插件）长下面这个样子：

新手看起来还是有些懵逼的，建议过过眼瘾就行了。

好了，我亲爱的读者朋友，以上就是本文的全部内容了，源代码已上传到码云，点击阅读原文就可以跳转过去了。学任何一门编程语言，在我看来，方法都是一样的，那就是不停地去实践，别觉得浅显易懂就不肯动手去尝试——你的左手和右手就是你最好的老师。

对了，在这里说一下，我目前是在职Java开发，如果你现在正在学习Java，了解Java，渴望成为一名合格的Java开发工程师，在入门学习Java的过程当中缺乏基础入门的视频教程，可以关注并私信我：01。获取。我这里有最新的Java基础全套视频教程。

我把Java基础编程及思维导图整理的超级详细，小白都能看懂

目录：

• Java学习导图
• 一、Java基本语法
• 1.关键字与标识符 2.变量分类 3.运算符 4.流程控制
• 二、数组
• 1.数组概述 2.一维数组 3.二维数组 4.数组常见算法 5.Arrays工具类使用
• 三、面向对象
• Java类及其类成员三大特性(封装、继承、多态)关键字

Java学习思维导图

Java基本语法

关键字与标识符

定义变量格式变量类型 变量名 = 变量值；变量类型 变量名；变量名 = 变量值；

变量使用注意点

① 变量必须先声明，后使用② 变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了③ 同一个作用域内，不可以声明两个同名的变量

基本数据变量运算规则

1. 自动类型转换：结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。byte 、char 、short –> int –> long –> float –> double特别的：当byte、char、short三种类型的变量做运算时，结果为int型

说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量

1. 强制类型转换：

1.需要使用强转符：()2.注意点：强制类型转换，可能导致精度损失。

算术运算符： + – + – * / % (前)++ (后)++ (前)– (后)– +1.(前)++ :先自增1，后运算(后)++ :先运算，后自增12.(前)– :先自减1，后运算(后)– :先运算，后自减13.连接符：+：只能使用在String与其他数据类型变量之间使用。

复制运算符：= += -= *= /= %=1.运算的结果不会改变变量本身的数据类型2.开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)//方式一：num = num + 1;//方式二：num += 1;//方式三：num++; (推荐)

比较运算符： == != > < >= <= instanceof1.比较运算符的结果是boolean类型2.> < >= <= :只能使用在数值类型的数据之间。3. == 和 !=: 不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间。

逻辑运算符：& && | || ! ^1.逻辑运算符操作的都是boolean类型的变量。而且结果也是boolean类型

2.区分& 与 &&相同点1：& 与 && 的运算结果相同相同点2：当符号左边是true时，二者都会执行符号右边的运算不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。开发中，推荐使用&&

3.区分：| 与 ||相同点1：| 与 || 的运算结果相同相同点2：当符号左边是false时，二者都会执行符号右边的运算不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算开发中，推荐使用||

位运算符：<< >> >>> & | ^ ~

1. 位运算符操作的都是整型的数据
2. << ：在一定范围内，每向左移1位，相当于 * 2>>: 在一定范围内，每向右移1位，相当于/2

三元运算符：(条件表达式)? 表达式1 : 表达式2

说明① 条件表达式的结果为boolean类型② 根据条件表达式真或假，决定执行表达式1，还是表达式2.如果表达式为true，则执行表达式1。如果表达式为false，则执行表达式2。③ 表达式1 和表达式2要求是一致的。④ 三元运算符可以嵌套使用

凡是可以使用三元运算符的地方，都可以改写为if-else反之，不成立。

如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。

分支结构：1.if-else条件判断结构

结构一：if (条件表达式) {执行表达式}

结构二：二选一if (条件表达式) {执行表达式1}else{执行表达式2}

结构三：n选一if (条件表达式) {执行表达式1}else if (条件表达式) {执行表达式2}else if (条件表达式) {执行表达式3}…else{执行表达式n}

2.switch-case选择结构

switch (表达式) {case 常量1:执行语句1;break;case 常量2:执行语句2;break;…default:执行语句n;break;}

循环结构：

1.循环结构的四要素

① 初始化条件② 循环条件 —>是boolean类型③ 循环体④ 迭代条件说明：通常情况下，循环结束都是因为②中循环条件返回false了。

2.三种循环结构：

2.1 for循环结构

for(①;②;④){③}执行过程：① – ② – ③ – ④ – ② – ③ – ④ – … – ②

2.2 while循环结构

①while(②){③;④;}执行过程：① – ② – ③ – ④ – ② – ③ – ④ – … – ②说明：写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！

for和while循环总结：

开发中，基本上我们都会从for、while中进行选择，实现循环结构。for循环和while循环是可以相互转换的！区别：for循环和while循环的初始化条件部分的作用范围不同我们写程序，要避免出现死循环。

2.3 do-while循环结构

①do{③;④;}while(②);执行过程：① – ③ – ④ – ② – ③ – ④ – … – ②

说明：1.do-while循环至少会执行一次循环体！2.开发中，使用for和while更多一些。较少使用do-while

1.数组理解： 数组(Array)，是多个相同类型数据一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

2.数组相关的概念：

数组名元素角标、下标、索引数组的长度：元素的个数

3.数组的特点：

1. 数组是序排列的
2. 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
3. 创建数组对象会在内存中开辟一整块连续的空间
4. 数组的长度一旦确定，就不能修改。

4. 数组的分类：① 二维数：一维数组、二维数组、。。。② 照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

1.一维数组的声明与初始化

错误的方式：// int[] arr1 = new int[];// int[5] arr2 = new int[5];// int[] arr3 = new int[3]{1,2,3};

2.一维数组元素的引用：通过角标的方式调用。数组的角标（或索引从0开始的，到数组的长度-1结束）

3.数组的属性：lengthSystem.out.println(names.length);//5System.out.println(ids.length);

说明：数组一旦初始化，其长度就是确定的。arr.length数组长度一旦确定，就不可修改。

4.一维数组的遍历for(int i = 0;i < names.length;i++){System.out.println(names[i]);}

5.一维数组元素的默认初始化值> 数组元素是整型：0> 数组元素是浮点型：0.0> 数组元素是char型：0或’\\u0000’，而非’0’> 数组元素是boolean型：false> 数组元素是引用数据类型：null

1.如何理解二维数组？数组属于引用数据类型数组的元素也可以是引用数据类型一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组。

2.二维数组的声明与初始化

错误的方式：// String[][] arr4 = new String[][4];// String[4][3] arr5 = new String[][];// int[][] arr6 = new int[4][3]{{1,2,3},{4,5},{6,7,8}};

3.如何调用二维数组元素:System.out.println(arr1[0][1]);//2System.out.println(arr2[1][1]);//null

4.遍历二维数组元素

1.数组的创建与元素赋值：杨辉三角（二维数组）、回形数（二维数组）、6个数，1-30之间随机生成且不重复。

2.针对于数值型的数组：最大值、最小值、总和、平均数等

3.数组的复制与复制int[] array1,array2;array1 = new int[]{1,2,3,4};3.1 赋值：

array2 = array1;如何理解：将array1保存的数组的地址值赋给了array2，使得array1和array2共同指向堆空间中的同一个数组实体。

3.2 复制：

array2 = new int[array1.length];for(int i = 0;i < array2.length;i++){array2[i] = array1[i];}如何理解：我们通过new的方式，给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。

1.理解：① 定义在java.util包下。② Arrays:提供了很多操作数组的方法。

2.使用：

1.类的设计中，两个重要结构之一：属性

对比：属性 vs 局部变量

1.相同点：1.1 定义变量的格式：数据类型 变量名 = 变量值1.2 先声明，后使用1.3 变量都其对应的作用域

2.不同点：

2.1 在类中声明的位置的不同属性：直接定义在类的一对{}内局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2.2 关于权限修饰符的不同属性：可以在声明属性时，指明其权限，使用权限修饰符。常用的权限修饰符：private、public、缺省、protected —>封装性目前，大家声明属性时，都使用缺性就可以了。局部变量：不可以使用权限修饰符。

2.3 默认初始化值的情况：属性：类的属性，根据其类型，都默认初始化值。整型（byte、short、int、long：0）浮点型（float、double：0.0）字符型（char：0 （或’\\u0000’））布尔型（boolean：false）

2.4 在内存中加载的位置：属性：加载到堆空间中 （非static）局部变量：加载到栈空间

2.类的设计中，两个重要结构之二：方法方法：描述类应该具的功能。

• public void eat(){}
• public void sleep(int hour){}
• public String getName(){}
• public String getNation(String nation){}

2. 方法的声明：权限修饰符 返回值类型 方法名(形参列表){方法体}

3. 说明：3.1 关于权限修饰符：默认方法的权限修饰符先都使用publicJava规定的4种权限修饰符：private、public、缺省、protected –>封装性再细说

3.2 返回值类型： 返回值 vs 没返回值

3.2.1 如果方法返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用 return关键字来返回指类型的变量或常量：“return 数据”。如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。

构造器（或构造方法）：

• 1.创建对象
• 2.初始化对象的信息

使用说明：1.如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器2.定义构造器的格式：权限修饰符 类名(形参列表){}3.一个类中定义的多个构造器，彼此构成重载4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器5.一个类中，至少会有一个构造器。

面向对象的特征一：封装与隐藏

1.为什么要引入封装性？我们程序设计追求“高内聚，低耦合”。高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；低耦合 ：仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.封装性思想具体的代码体现：体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值private double radius;public void setRadius(double radius){this.radius = radius;}public double getRadius(){return radius;}体现二：不对外暴露的私有的方法体现三：单例模式（将构造器私有化）体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

3.Java规定的四种权限修饰符

3.1 权限从小到大顺序为：private < 缺省 < protected < public3.2 具体的修饰范围：3.3 权限修饰符可用来修饰的结构说明：

4.种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类修饰类的话，只能使用：缺省、public

面向对象特征二:继承性

1.继承性的格式：class A extends B{}

• A:子类、派生类、subclass
• B:父类、超类、基类、superclass

2.子类继承父类以后有哪些不同？

2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私的结构。只因为封装性的影响，使得人类不能直接调用父类的结构而已。

2.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。

• 子类和父类的关系，不同于子集和集合的关系。
• extends：延展、扩展

3.Java中继承性的说明

3.1.一个类可以被多个子类继承。

3.2.Java中类的单继承性：一个类只能有一个父类3.3.子父类是相对的概念。3.4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类3.5.子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性和方法

面向对象的特性三：多态性

1.多态性的理解：可以理解为一个事物的多种形态。

2.何为多态性：对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）举例：Person p = new Man();Object obj = new Date();

3.多态性的使用：虚拟方法调用有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。总结：编译，看左边；运行，看右边。

4.多态性的使用前提：① 类的继承关系 ② 方法的重写

6.多态性使用的注意点：对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

关键字：this1.可以调用的结构：属性、方法；构造器

2.this调用属性、方法：this理解为：当前对象 或 当前正在创建的对象

2.1 在类的方法中，我们可以使用\”this.属性\”或\”this.方法\”的方式，调用当前对象属性或方法。但是通常情况下，我们都择省略\”this.\”。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用\”this.变量\”的方式，表明此变量是属性，而非形参。

2.2 在类的构造器中，我们可以使用\”this.属性\”或\”this.方法\”的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略\”this.\”。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用\”this.变量\”的方式，表明此变量是属性，而非形参。

3.this调用构造器：

① 我们在类的构造器中，可以显式的使用\”this(形参列表)\”方式，调用本类中指定的其他构造器② 构造器中不能通过\”this(形参列表)“方式调用自己③ 如果一个类中有n个构造器，则最多有 n – 1构造器中使用了\”this(形参列表)”④ 规定：\”this(形参列表)“必须声明在当前构造器的首行⑤ 构造器内部，最多只能声明一个\”this(形参列表)”，用来调用其他的构造器

关键字:abstractabstract: 抽象的1.可以用来修饰：类、方法2.具体的：abstract修饰类：抽象类

abstract修饰方法：抽象方法

3.注意点：

1.abstract不能用来修饰：属性、构造器等结构2.abstract不能用来修饰私方法、静态方法、final的方法、final的类

第3天｜Java入门有野，基础语法

老铁，我是不会告诉你我的计算机上安装了Eclipse，用于开发Spring Boot；安装了Android Studio用于开发Android App；安装了DevEco-Studio用于试验鸿蒙App的。

有关App和对应开发工具的介绍，等你学完Java的基础知识之后，我再逐步展开讲解。来，现在就打开你的IntelliJ IDEA社区版和我一起见证创建第1个Java程序的奇迹。

好多人学编程，都是从Hello World开始的，我觉得那样实在太无趣了。这不，我就多输出点内容，让你开心开心。

输出结果

你可千万别小瞧这个第一个Java程序，它麻雀虽小可五脏俱全啊。后面学的好多Java语法，在这都能瞧得见。如果你是一个爱学习的人，就往下遛。

在第一个程序中，开始的/** */是多行注释符号。在代码中的注释，是给人看的，机器是看不懂的，编译器在编译程序时，会将其删除掉。

不写注释的程序员就是在耍流氓，Java注释包括单号注释(用//开头)和多行注释(/* */或/** */)。其中/***/为文档注释内容，你可以用javadoc工具将注释内容输出到HTML文件中。

public、static、void等是编程语言里的关键字，是为程序制定规则用的。它们不能用于常量、变量和任何标识符的名称。否则谁知道你是李逵还是李鬼。Java的关键字，你大概了解它们是什么意思即可。在编写程序时，开发工具会用显眼的颜色告诉你的。

另外还有2个保留字：goto和const，是Java保留着的。意思是将来可能会使用，但在启动之前，程序不可用，你也不可用。

Java程序的组成需要名字，名字命名很重要，除了能达到望文生义，还需要遵守命名规则。为类、方法、变量起的名字，就是所谓的标识符。Java标识符是大小写敏感的，就是说lao和Lao是不同的。

1. 所有的标识符都应该以字母（A-Z表示。 或者 a-z）,美元符（$）、或者下划线（_）开始

2. 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合

3. 关键字不能用作标识符。

在Java代码中，每行代码用分号;结束，空白行同注释行一样，是为了提高代码的可读性，是给程序员看的，它们都会被编译器忽略掉。

好了，有关Java基础语法的内容，老陈讲完了，如果觉得对你有所帮助，希望你能转发点赞，让更多的人看到这篇文章。你的转发和点赞，就是对老陈继续创作和分享最大的鼓励。

一个当了10年技术总监的老家伙，分享多年的编程经验。想学编程的朋友，可关注今日头条：老陈说编程。我在分享Python，前端、Java和App方面的干货。关注我，没错的。

本文作者及来源:Renderbus瑞云渲染农场https://www.renderbus.com