学习目标

  • 上午：基本语法
    • 学习Java的注释（单行、多行、文档注释）。
    • 学习变量的概念：声明、初始化、命名规范。
    • 掌握基本数据类型：int, double, char, boolean。
  • 下午：运算符与输入
    • 学习运算符：算术运算符、赋值运算符、比较运算符、逻辑运算符。
    • 学习使用 Scanner 类从控制台获取用户输入。
  • 实践任务：编写一个程序，让用户输入两个数字，然后输出它们的和、差、积、商。

快速过一遍知识点：

注释

用于对代码进行解释说明的文本,不会进入到编译运行中

注释类型

语法

主要用途

单行注释

// ...

简短说明，临时禁用单行代码

多行注释

/* ... */

较长说明，临时禁用代码块

文档注释

/** ... */

生成API官方文档，描述类、方法功能

变量

变量就是一个打包盒，奖对应的数据打包好放进这个盒子里，需要用的时候以盒子为单位邮寄给需要的地方使用

变量的声明

语法：
数据类型 变量名;

例子：

int age;        // 申请一个能存放整数的“盒子”，标签叫 `age`
double score;   // 申请一个能存放小数的“盒子”，标签叫 `score`
String name;    // 申请一个能存放字符串的“盒子”，标签叫 `name`
char gender;    // 申请一个能存放单个字符的“盒子”，标签叫 `gender`

关键点：

  • 声明后，这个“盒子”就被预留出来了，但里面可能是空的（对于局部变量来说，未初始化不能直接使用）。
  • 初始化就是把东西放进去

变量的初始化

概念：初始化就是第一次往“盒子”里放东西。也就是给变量第一次赋值。

语法：
变量名 = 值;

例子：

age = 18;           // 往 `age` 盒子里放入整数 18
score = 99.5;       // 往 `score` 盒子里放入小数 99.5
name = "张三";      // 往 `name` 盒子里放入字符串 "张三"
gender = '男';      // 往 `gender` 盒子里放入字符 '男'

声明与初始化可以合并（通常这样做）：

java

int age = 18;           // 申请一个叫age的盒子，并立刻放入18
double score = 99.5;    // 申请一个叫score的盒子，并立刻放入99.5
String name = "张三";   // 申请一个叫name的盒子，并立刻放入"张三"

重要规则：在Java中，局部变量（例如在方法内部声明的变量）在使用前必须被显式初始化，否则编译器会报错。

public static void main(String[] args) {
    int count;      // 只是声明
    // System.out.println(count); // 错误！变量count尚未初始化，无法使用。
    count = 10;     // 初始化
    System.out.println(count); // 正确！输出：10
}

3. 变量的命名规范

这是养成良好的编程习惯的第一步。规范的命名能让你的代码像诗一样易读，而不规范的命名则像天书。

必须遵守的硬性规则（语法规定）：
  1. 可以由：字母、数字、下划线 _、美元符号 $ 组成。
  2. 不能以数字开头。
  3. 不能是Java的关键字（如 int, class, public, static 等）。
  4. 区分大小写。age 和 Age 是两个不同的变量。
推荐的软性规范（行业共识）：

这些规则不是语法强制要求的，但所有Java程序员都遵守它们，让你的代码更专业、更易读。

采用驼峰命名法：

    • 小驼峰法：第一个单词首字母小写，后面每个单词首字母大写。
    • 适用于：变量、方法名。
String firstName;   // 变量
double totalScore;  // 变量
public void getUserName() { ... } // 方法

见名知意：

    • 变量名应清晰表达其用途，避免使用无意义的字母（如 a, b, x1），除非是简单的循环计数器。
// 差的名字
int a;
String n;

// 好的名字
int studentAge;
String userName;
boolean isPassed;

常量命名：

    • 使用全大写字母，单词间用下划线 _ 连接。
    • 用 final 关键字修饰。
final double PI = 3.14159;
final int MAX_SPEED = 120;

基本数据类型

好的，我们来系统地学习 Java 的 基本数据类型。这是理解变量能存储什么 kind of 数据的基础。

Java 是一种强类型语言，这意味着必须为每个变量明确定义其数据类型。基本数据类型是 Java 语言内置的、最基本的的数据类型，它们不是对象（但有其对应的包装类）。

概览：八大基本数据类型

八大基本数据类型可以分为四大类，我们可以用一个简单的表来总结：

类别

数据类型

关键字

大小

默认值

取值范围与用途

整型

字节型

byte

1字节 (8位)

0

-128 ~ 127

短整型

short

2字节 (16位)

0

-32,768 ~ 32,767

整型

int

4字节 (32位)

0

-2³¹ ~ 2³¹-1 (约±21亿)

长整型

long

8字节 (64位)

0L

-2⁶³ ~ 2⁶³-1

浮点型

单精度浮点

float

4字节 (32位)

0.0f

大约 ±3.4e+38F (6-7位有效数字)

双精度浮点

double

8字节 (64位)

0.0d

大约 ±1.7e+308 (15位有效数字)

字符型

字符型

char

2字节 (16位)

\u0000

0 ~ 65,535 (存储一个Unicode字符)

布尔型

布尔型

boolean

未精确定义

false

true 或 false

提示：最常用的是 int, double, boolean, String（注意String不是基本类型，是类）。

详细讲解与代码示例

1. 整型

用于存储整数。选择哪种类型取决于数值范围，以节省内存。

// 1. byte - 常用于处理原始二进制数据（如文件流）
byte fileData = 127; // 最大值

// 2. short - 不常用，可兼容老式设备或特定协议
short sensorValue = 30000;

// 3. int - 最常用！默认的整数类型
int age = 25;
int population = 1411750000; // 14亿

// 4. long - 用于非常大的整数，赋值时需在数字后加 'L' 或 'l'（建议用大写的L）
long worldPopulation = 8000000000L; // 80亿，不加L会被当作int而报错
long bigNumber = 123456789012345L;
2. 浮点型

用于存储小数。由于存储方式的特殊性，浮点数不适合进行精确的金融计算（会有精度损失），金融计算应使用 BigDecimal。

// 1. float - 单精度，赋值时需在数字后加 'F' 或 'f'
float price = 19.99F; // 不加F会被当作double而报错
float radius = 5.5f;

// 2. double - 最常用！默认的小数类型，精度更高
double salary = 15000.50;
double pi = 3.141592653589793;
double scientificNotation = 1.23e-4; // 科学计数法，表示 0.000123
3. 字符型

用于存储单个字符。使用单引号 '' 括起来。

char grade = 'A';
char initial = '张'; // 可以存储中文字符
char symbol = '$';
char newLine = '\n'; // 转义字符，表示换行
char unicodeChar = '\u0041'; // Unicode编码，表示字符 'A'

常见转义字符：

  • \n：换行
  • \t：制表符
  • \\：表示一个反斜杠
  • \'：表示一个单引号
  • \"：表示一个双引号
4. 布尔型

只有两个值：true 或 false。常用于条件判断和循环控制。

boolean isRaining = true;
boolean isLoggedIn = false;
boolean isAdult = (age >= 18); // 通过比较表达式赋值，结果也是boolean类型

默认值

重要：以上默认值仅适用于类的成员变量。在方法内部声明的局部变量没有默认值，必须手动初始化后才能使用，否则编译器会报错。

public class Test {
    int classLevelInt; // 成员变量，默认值为0

    public void myMethod() {
        int localInt; // 局部变量，无默认值
        // System.out.println(localInt); // 编译错误！变量localInt未初始化
        localInt = 10; // 必须先初始化
        System.out.println(localInt); // 正确
    }
}

总结与记忆技巧

  1. 整数用 int，大数用 long。
  2. 小数用 double，省钱用 float（但不常用）。
  3. 是非判断用 boolean。
  4. 单个字符用 char。
  5. 局部变量必须先赋值再使用。
  6. long 和 float 类型赋值时，别忘记在数字后加 L 和 F。

理解这些基本数据类型是你在Java世界中进行计算和数据处理的第一步。接下来，你就会学习如何用运算符来操作这些类型的数据。

运算符

好的，我们来全面学习 Java 的 运算符。运算符是用于对操作数（变量、常量等）进行各种运算的符号。它是构建程序逻辑的基石。

我们可以将运算符分为以下几大类：

1. 算术运算符

用于基本的数学运算。

运算符

含义

示例

结果 (a=10, b=3)

+

加法

a + b

13

-

减法

a - b

7

*

乘法

a * b

30

/

除法

a / b

3 (整数相除，结果取整)

%

取模

a % b

1 (求余数)

++

自增

a++ 或 ++a

a 变为 11

--

自减

a-- 或 --a

a 变为 9

特别注意：

  • 整数除法：10 / 3 的结果是 3，不是 3.333...。如果要得到小数，至少有一个操作数是小数（如 10.0 / 3）。
  • 自增/自减的前置与后置：
    • a++（后置）：先使用a的当前值，然后再给a加1。
    • ++a（前置）：先给a加1，然后再使用a的新值。
int a = 5;
int b = a++; // 步骤：1. b = a (b=5), 2. a = a + 1 (a=6)
System.out.println(a); // 输出 6
System.out.println(b); // 输出 5

int x = 5;
int y = ++x; // 步骤：1. x = x + 1 (x=6), 2. y = x (y=6)
System.out.println(x); // 输出 6
System.out.println(y); // 输出 6

2. 赋值运算符

用于为变量赋值。

运算符

示例

等价于

=

a = 10

把 10 赋值给 a

+=

a += 5

a = a + 5

-=

a -= 3

a = a - 3

*=

a *= 2

a = a * 2

/=

a /= 4

a = a / 4

%=

a %= 3

a = a % 3

复合赋值运算符（如 +=）可以提高编码效率和可读性。

3. 比较运算符（关系运算符）

用于比较两个值，结果是一个 布尔值 (true 或 false)。常用于 if 条件语句和循环中。

运算符

含义

示例

结果 (a=10, b=3)

==

等于

a == b

false

!=

不等于

a != b

true

>

大于

a > b

true

<

小于

a < b

false

>=

大于等于

a >= b

true

<=

小于等于

a <= b

false

特别注意：== 比较的是值。对于基本数据类型，比较的是变量的值是否相等。对于引用数据类型（如String），== 比较的是内存地址是否相同（即是否是同一个对象），比较字符串内容是否相等应使用 .equals() 方法。

int num1 = 10;
int num2 = 10;
System.out.println(num1 == num2); // 输出 true

String str1 = "Hello";
String str2 = new String("Hello");
System.out.println(str1 == str2);      // 输出 false! 因为不是同一个对象
System.out.println(str1.equals(str2)); // 输出 true! 比较内容是否相等

4. 逻辑运算符

用于连接多个布尔表达式，结果仍是一个布尔值。常用于复杂的条件判断。

运算符

含义

示例

说明

&&

逻辑与

(a > 5) && (a < 15)

两个条件都为真，结果才为真

`

`

逻辑或

!

逻辑非

!(a > 5)

取反，真变假，假变真

短路效应：

  • &&（短路与）：如果第一个条件为 false，则不再判断第二个条件，直接返回 false。
  • ||（短路或）：如果第一个条件为 true，则不再判断第二个条件，直接返回 true。
int a = 10;
// 由于 a > 5 已经为true，所以会继续判断 ++a > 10
if (a > 5 && ++a > 10) {
    System.out.println("条件成立"); // 这会执行
}
System.out.println(a); // 输出 11，因为 ++a 被执行了

int b = 10;
// 由于 b > 5 已经为true，根据短路效应，后面的 ++b > 10 不会再判断
if (b > 5 || ++b > 10) {
    System.out.println("条件成立"); // 这会执行
}
System.out.println(b); // 输出 10，因为 ++b 没有被执行！

5. 三元运算符（条件运算符）

一种简写形式的 if-else。

语法：条件 ? 表达式1 : 表达式2
执行过程：如果条件为 true，则整个式子的值是表达式1；如果条件为 false，则整个式子的值是表达式2。

int score = 75;
String result = (score >= 60) ? "及格" : "不及格";
System.out.println(result); // 输出 "及格"

// 等价于下面的 if-else 语句
if (score >= 60) {
    result = "及格";
} else {
    result = "不及格";
}

运算符优先级

当表达式中包含多个运算符时，会按照优先级的顺序进行计算。优先级高的先算。记不住没关系，常用的是：

  1. () 优先级最高，用于强制改变顺序。
  2. 算术运算符 > 比较运算符 > 逻辑运算符。
  3. 赋值运算符优先级几乎最低。

最佳实践：当你不确定优先级时，或者为了代码更清晰，多用小括号 () 来明确指定计算顺序。

int result = 5 + 2 * 3;     // 结果是 11 (2*3先算)
int clearResult = (5 + 2) * 3; // 结果是 21，用括号明确顺序

总结

运算符类型

主要功能

关键点

算术

数学计算

注意整数除法和自增/自减的前后置区别

赋值

给变量赋值

复合赋值运算符很便捷

比较

比较大小

结果是布尔值，注意 == 和 .equals() 的区别

逻辑

组合布尔条件

理解短路效应 (&&, `

三元

简化if-else

条件 ? 值1 : 值2

熟练掌握这些运算符，你就能开始编写具有逻辑判断和计算功能的Java程序了！

Scanner 类

这是 Java 中一个非常实用工具类，用于获取用户的控制台输入，让你的程序从“单向输出”变成“双向交互”。

1. 什么是 Scanner 类？

Scanner 是 Java 自带的一个工具类，位于 java.util 包中。它可以像“扫描仪”一样，解析基本数据类型和字符串。最常见的使用场景就是从 System.in（标准输入流，通常是键盘）读取用户输入。

2. 使用 Scanner 的步骤

使用 Scanner 遵循一个固定的“三步走”流程。

步骤一：导入包

由于 Scanner 不在 Java 默认的 java.lang 包中，所以使用前必须先导入。

import java.util.Scanner; // 在Java文件的开头写上这句
步骤二：创建 Scanner 对象

在需要获取输入的方法中（通常是 main 方法），创建一个 Scanner 对象，并将其绑定到标准输入流 System.in 上。

Scanner scanner = new Scanner(System.in);

这里的 scanner 是变量名，你可以起任何你喜欢的名字（如 input, scan 等）。

步骤三：读取输入

使用创建好的 Scanner 对象调用其各种方法来读取不同类型的数据。

方法

功能描述

示例

nextInt()

读取下一个 整数

int num = scanner.nextInt();

nextDouble()

读取下一个 双精度浮点数

double score = scanner.nextDouble();

nextFloat()

读取下一个 单精度浮点数

float price = scanner.nextFloat();

nextLong()

读取下一个 长整型

long population = scanner.nextLong();

nextBoolean()

读取下一个 布尔值

boolean isPass = scanner.nextBoolean();

next()

读取下一个 字符串（遇到空格/换行符结束）

String name = scanner.next();

nextLine()

读取下一行 字符串（遇到换行符结束）

String sentence = scanner.nextLine();

3. 完整代码示例

下面是一个综合示例，演示如何获取不同类型的输入。

import java.util.Scanner; // 1. 导入包

public class ScannerDemo {
    public static void main(String[] args) {
        // 2. 创建Scanner对象
        Scanner input = new Scanner(System.in);
        
        System.out.print("请输入您的年龄（整数）: ");
        int age = input.nextInt(); // 3. 读取一个整数
        
        System.out.print("请输入您的身高（米，小数）: ");
        double height = input.nextDouble(); // 读取一个小数
        
        System.out.print("请输入您的姓名: ");
        String name = input.next(); // 读取一个字符串（不带空格）
        
        // 清除输入缓冲区中残留的换行符（重要！）
        input.nextLine();
        
        System.out.print("请输入您的地址: ");
        String address = input.nextLine(); // 读取一行字符串（可带空格）
        
        System.out.print("您是否通过考试（true/false）: ");
        boolean isPassed = input.nextBoolean(); // 读取一个布尔值
        
        // 打印汇总信息
        System.out.println("\n--- 您的信息如下 ---");
        System.out.println("姓名: " + name);
        System.out.println("年龄: " + age);
        System.out.println("身高: " + height + "米");
        System.out.println("地址: " + address);
        System.out.println("考试通过: " + isPassed);
        
        // 4. 关闭Scanner（好习惯，释放资源）
        input.close();
    }
}

运行结果示例：

请输入您的年龄（整数）: 25
请输入您的身高（米，小数）: 1.75
请输入您的姓名: 张三
请输入您的地址: 北京市海淀区中关村大街
您是否通过考试（true/false）: true

--- 您的信息如下 ---
姓名: 张三
年龄: 25
身高: 1.75米
地址: 北京市海淀区中关村大街
考试通过: true

4. 核心注意事项与常见“坑”

1. nextLine() 的“吞回车”问题

这是初学者最常遇到的坑！

问题描述：当在 nextInt(), nextDouble(), next() 等非nextLine()方法之后使用 nextLine() 时，会发现 nextLine() 好像被“跳过”了，没有等待用户输入就直接执行了。

原因：nextInt() 等方法只读取数字本身，而不读取输入流中数字后面的 换行符（回车键 \n）。这个残留的换行符会被紧随其后的 nextLine() 读取，nextLine() 遇到 \n 就立刻结束，所以看起来像是被跳过了。

解决方案：在需要读取整行内容之前，多加一个 input.nextLine(); 来“消耗”掉那个残留的换行符。

System.out.print("请输入一个数字: ");
int num = input.nextInt(); // 用户输入 100 后按回车

// 消耗掉输入缓冲区中残留的换行符
input.nextLine();

System.out.print("请输入一句话: ");
String sentence = input.nextLine(); // 现在这句可以正常工作了
2. next() 与 nextLine() 的区别

方法

结束标志

读取内容

next()

空格、制表符、换行符

不包含结束符的字符串

nextLine()

换行符 (\n)

包含空格，但不包含最后的换行符的整行内容

示例：
用户输入：Hello World 然后回车

String s1 = input.next();      // s1 = "Hello"
String s2 = input.nextLine();  // s2 = " World"（如果前面有残留数据，结果可能不同）
3. 关闭 Scanner

在使用完 Scanner 后，尤其是读取文件时，调用 close() 方法是一个好习惯，可以释放与之关联的系统资源。

scanner.close();

总结

Scanner 类是实现Java程序与用户交互的桥梁。记住以下关键点：

  1. 三步走：import -> new Scanner(System.in) -> 调用 nextXxx() 方法。
  2. 核心方法：根据要读取的数据类型选择对应的方法（nextInt, nextDouble, nextLine等）。
  3. 避开大坑：注意 nextLine() 在 nextInt() 等后面的“吞回车”问题，记得用额外的 nextLine() 消耗掉换行符。

现在，你就可以编写出能与用户对话的程序了！

实践

  • 实践任务：编写一个程序，让用户输入两个数字，然后输出它们的和、差、积、商。
import java.util.Scanner;

public class 实践 {
    public static void main(String[] args) {
        System.out.println("请输入两个数字，我没输出输出它们的和、差、积、商");
        Scanner input = new Scanner(System.in);
        System.out.println("请输入数字a：");
        double a = input.nextDouble();
        System.out.println("请输入数字b：");
        double b = input.nextDouble();
        System.out.println("a,b他们的和为："+(a+b));
        System.out.println("a,b他们的差为："+(Math.abs(a-b)));
        System.out.println("a,b他们的积为："+(a*b));
        System.out.println("a,b他们的积为："+(a/b));
    }
}
# python # 前端 # linux
Logo
鲲鹏昇腾开发者社区是面向全社会开放的“联接全球计算开发者，聚合华为+生态”的社区，内容涵盖鲲鹏、昇腾资源，帮助开发者快速获取所需的知识、经验、软件、工具、算力，支撑开发者易学、好用、成功，成为核心开发者。

鲲鹏昇腾开发者社区是面向全社会开放的“联接全球计算开发者，聚合华为+生态”的社区，内容涵盖鲲鹏、昇腾资源，帮助开发者快速获取所需的知识、经验、软件、工具、算力，支撑开发者易学、好用、成功，成为核心开发者。

更多推荐

cover

鲲鹏+昇腾：开启 AI for Science 新范式——基于PINN的流体仿真加速实践

avatar 鲲鹏昇腾开发者社区

鲲鹏 DevKit 持续集成部署实践：从零搭建 CI/CD 流水线

随着项目规模不断扩大，构建一条简单、稳定、自动化的 CI/CD 流水线变得越来越重要。鲲鹏 DevKit 在这一方面提供了完整的工具链支持，从代码检查到构建、测试、部署都有覆盖，让我们能够在国产化环境中快速搭建可靠的持续交付体系。我将结合实际使用经验，介绍如何基于 DevKit 构建一条完整、高效的 CI/CD 流水线，并给出相关配置示例与最佳实践。本次实验是在华为云开发者空间上进行的，点击进入D

avatar 鲲鹏昇腾开发者社区
cover

华为 DevKit 25.2.rc1 源码迁移分析使用教程（openEuler + ARM64）

avatar 鲲鹏昇腾开发者社区