【JAVA基础指南（一）】快速掌握基础语法

超级苦力怕

发布于 2025-12-24 09:12:03

2360

前言

本文主要内容：从 0 认识“变量、数据类型、输入、运算符、类型转换”等 Java 基础语法。适合人群：刚配置好 JDK、能运行 main 方法，但对语法还不熟的同学。阅读收益：看完你能独立写出简单的输入输出与条件判断代码，并看懂常见表达式。

1. 注释

1.1 概述

注释是对代码的解释和说明文字，用于代码的解释，实际并不运行。

1.2 示例

Java 中分为三种注释，具体如下

单行注释 //
多行注释 /* */
文档注释 /** */

示例：

public class PoemPrinter {
    
    /**
     * 
     * 这是文档注释
     */
    public static void main(String[] args) {
        // 这是单行注释：打印诗歌标题
        System.out.println("=== 《静夜思》 ===");
        
        /*
         * 这是多行注释：
         * 以下代码打印诗歌的正文内容
         * 每行一句，共四句
         */
        System.out.println("床前明月光，");      // 第一句
        System.out.println("疑是地上霜。");      // 第二句
        System.out.println("举头望明月，");      // 第三句
        System.out.println("低头思故乡。");      // 第四句
        
        // 打印结束分隔符
        System.out.println("==================");
    }
   
}

展示效果

=== 《静夜思》 ===
床前明月光，
疑是地上霜。
举头望明月，
低头思故乡。
==================

2. 变量

2.1 简介

变量是在程序中临时存储数据的容器，这个容器中只含一个值。

2.2 定义格式

数据类型变量名 = 数据值。

//赋值，这里以int类型为例，后续会讲解其他类型。
int a = 16;
System.out.println(a);//16

2.3 注意事项

变量名不能重复
在一条语句中，可以定义多个变量。(这种方式影响代码阅读，少用)
使用变量前需要赋值

3. 数据类型

3.1 概述

数据类型分为 基本数据类型 和 引用数据类型，这里主要讲解基本数据类型

3.2 基本数据类型

数据类型	关键字	内存占用	取值范围
整数	byte	1	负的 2 的 7 次方 ~ 2 的 7 次方-1 (-128~127)
	short	2	负的 2 的 15 次方 ~ 2 的 15 次方-1 (-32768~32767)
	int	4	负的 2 的 31 次方 ~ 2 的 31 次方-1
	long	8	负的 2 的 63 次方 ~ 2 的 63 次方-1
浮点数	float	4	1.401298 e-45 ~ 3.402823 e+38
	double	8	4.9000000 e-324 ~ 1.797693 e+308
字符	char	2	0-65535
布尔	boolean	1	true, false

说明：

e+38 表示是乘以 10 的 38 次方，同样，e-45 表示乘以 10 的负 45 次方
在 Java 中整数默认是 int 类型，浮点数默认是 double 类型

重点：

byte 类型的取值范围： -128~127
整数类型和小数类型的取值范围大小关系： double > float > long > int > short > byte

3.3 示例代码

public class VariableDemo3{
    public static void main(String[] args){
        //1.定义byte类型的变量
        //数据类型 变量名 = 数据值;
        byte a = 10;
        System.out.println(a);

        //2.定义short类型的变量
        short b = 20;
        System.out.println(b);

        //3.定义int类型的变量
        int c = 30;
        System.out.println(c);

        //4.定义long类型的变量
        long d = 123456789123456789L;
        System.out.println(d);

        //5.定义float类型的变量
        float e = 10.1F;
        System.out.println(e);

        //6.定义double类型的变量
        double f = 20.3;
        System.out.println(f);

        //7.定义char类型的变量
        char g = 'a';
        System.out.println(g);

        //8.定义boolean类型的变量
        boolean h = true;
        System.out.println(h);

    }
}

注意：

如果要定义一个整数类型的变量，不知道选择哪种数据类型了，默认使用 int。
如果要定义一个小数类型的变量，不知道选择哪种数据类型了，默认使用 double。
如果要定义一个 long 类型的变量，在数据值的后面需要加上 L 后缀。(大小写都可以，建议大写)
如果要定义一个 float 类型的变量，在数据值的后面需要加上 F 后缀。(大小写都可以）

3.4 扩充：新手先掌握哪些数据类型

如果先前并没有任何语言的基础，建议先把下面这些用熟：

int：最常用的整数类型（计数、年龄、数量）
double：最常用的小数类型（价格、分数）
char：单个字符（了解即可，后面会在字符串里经常见到）
boolean：条件判断的核心（true/false）

补充：String 严格来说是引用类型，但入门阶段输出文本、拼接内容几乎都离不开它，可以当成“先会用”的重点。

4. 标识符

在写代码中，默认遵守驼峰命名法，这样会使得代码简单易懂、便于理解。

4.1 硬性要求

必须这么遵守以下原则，否则代码会报错

必须由数字、字母、下划线_、美元符号$组成
数字不能开头
不能是关键字
区分大小写的

4.2 软件要求

如果不这么做，代码不会报错，但回使得代码可读性较差。

小驼峰命名法 适用于变量名和方法名

如果是一个单词，那么全部小写，比如：name
如果是多个单词，那么从第二个单词开始，首字母大写，比如：firstName、maxAge

大驼峰命名法 适用于类名、接口名

如果是一个单词，那么首字母大写，比如：Student
如果是多个单词，那么每个单词首字母都大写，比如：StudentService、UserInfo

补充：阿里巴巴命名规范细节

尽量不要用拼音。但是一些国际通用的拼音可视为英文单词。
正确：alibaba、hangzhou、nanjing
错误：jiage、dazhe
平时在给变量名、方法名、类名起名字的时候，不要使用下划线或美元符号。
错误：_name
正确：name

5. 键盘录入

5.1 概述

键盘录入的功能在 JDK 中，不需要我们实现，只需要直接使用 Scanner 这个类就可以了。

5.2 实现步骤

创建对象：告诉计算机，开始使用 Scanner 这个类
接收数据：实际写代码

5.3 代码示例

//导包，其实就是先找到Scanner这个类在哪
import java.util.Scanner;
public class ScannerDemo1{
  public static void main(String[] args){
    //2.创建对象，其实就是申明一下，我准备开始用Scanner这个类了。
    Scanner sc = new Scanner(System.in);
    //3.接收数据
    //当程序运行之后，我们在键盘输入的数据就会被变量i给接收了
    System.out.println("请输入一个数字");
    int i = sc.nextInt();
    System.out.println(i);
  }
}

5.4 运行示例（控制台）

当你运行程序后，控制台会等待输入：

请输入一个数字

此时你输入 12 并回车：

请输入一个数字
12
12

说明：第一行 12 是你在控制台输入的内容；第二行 12 是程序 System.out.println(i) 打印出来的。

6. 运算符（把常用的放在一起）

6.1 算术运算符（+ - * / %）

算术运算符就是加减乘除和取余。

/：整数相除只能得到整数（小数部分直接丢掉）
%：取余，得到“除完剩下多少”

补充：小数在计算机里用二进制存储，很多十进制小数转成二进制会“除不尽”，所以会出现轻微误差。

public class ArithmeticDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;

        System.out.println(a + b);  // 13
        System.out.println(a - b);  // 7
        System.out.println(a * b);  // 30
        System.out.println(a / b);  // 3
        System.out.println(a % b);  // 1

        System.out.println(10.0 / 3.0); // 3.3333333333333335
    }
}

6.2 自增自减（++ / --）

++：让变量值 +1。--：让变量值 -1。

快速记忆： ++i：先加再用 i++：先用再加

public class IncrementDecrementDemo {
    public static void main(String[] args) {
        int x = 5;
        int y = ++x; // x=6, y=6

        int m = 5;
        int n = m++; // m=6, n=5

        int count = 1;
        count = count++; // count 还是 1（新手常踩坑）
    }
}

6.3 赋值与复合赋值（=、+=、-=、*=、/=、%=）

复合赋值就是“先运算，再把结果赋回左边”。

public class AssignmentOperatorsDemo {
    public static void main(String[] args) {
        int a = 10;
        a += 3; // 等价于 a = a + 3
        a *= 2; // 等价于 a = a * 2

        short s = 5;
        s += 2; // 可以：隐含了类型转换
    }
}

6.4 关系运算符（比较运算符）

关系运算符用来比较大小或是否相等，结果一定是 boolean（true/false）。

符号	含义
==	是否相等
!=	是否不相等
>	是否大于
>=	是否大于等于
<	是否小于
<=	是否小于等于

注意：== 是比较，= 是赋值，新手最容易写错。

6.5 逻辑运算符（& | ! && ||）

&：两边都为 true 才是 true
|：只要有一边为 true 就是 true
!：取反

更常用的是短路运算符：

&&：左边为 false，右边就不算了
||：左边为 true，右边就不算了

public class LogicalOperatorDemo {
    public static void main(String[] args) {
        System.out.println(true && false); // false
        System.out.println(true || false); // true
        System.out.println(!true); // false
    }
}

6.6 三元运算符（条件 ? 值1 : 值2）

三元运算符就是“写在一行里的 if-else”。

注意：表达式会产生一个结果，通常要赋值给变量或直接打印。

public class TernaryOperatorDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int max = a > b ? a : b;
        System.out.println(max); // 20
    }
}

6.7 `+` 的两种特殊用法（字符串拼接 / 字符运算）

1) 字符串拼接：只要有一边是字符串，+ 就是“拼接”。

public class StringAddDemo {
    public static void main(String[] args) {
        System.out.println(10 + "年Java"); // 10年Java
        System.out.println(2 + 3 + 5 + "元"); // 10元（先算 2+3+5）
        System.out.println("总和：" + 2 + 3 + 5); // 总和：235（从左到右拼接）
        System.out.println("总分：" + (85 + 90)); // 总分：175（括号先算）
    }
}

2) 字符参与运算：char 参与 + 时，会先当成数字（编码值）再计算。

public class CharPlusDemo {
    public static void main(String[] args) {
        char c = 'a';
        System.out.println(c + 0); // 97
    }
}

7. 类型转换（自动 / 强制）

7.1 自动类型提升（隐式转换）

自动类型提升就是：把取值范围小的类型，自动提升为取值范围大的类型，再参与运算。

如果出现 byte/short/char 参与运算，通常会先提升为 int
不同类型一起算，会向“更大的类型”提升

取值范围从小到大：byte short int long float double

public class ImplicitConversionDemo {
    public static void main(String[] args) {
        byte b1 = 5;
        byte b2 = 2;
        int sum = b1 + b2; // byte 运算结果会提升为 int
        System.out.println(sum); // 7

        int a = 10;
        double d = 3.5;
        System.out.println(a + d); // 13.5
    }
}

7.2 强制类型转换

当你要把“大范围类型”塞进“小范围类型”时，必须强制转换。

public class CastDemo {
    public static void main(String[] args) {
        double a = 12.3;
        int b = (int) a;
        System.out.println(b); // 12
    }
}