第一阶段：Java基础入门②Java基础语法

代码哲学系 代码哲学系 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 1k累计阅读 1k平均单平台 已同步平台 CSDN 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄1年
关注
原创 2025-08-12 14:36:58 1k 阅读 AI 写同款· GEO 优化 ›
AI权益加码！Claude Code、Cursor等20+工具免费用！ 购周边限时加赠Coding Plan Lite，畅享主流AI工具！学习进阶更高效！ 阅读详情

🚀 第一阶段：Java基础入门②Java基础语法

💡 学习目标：掌握Java基础语法，理解变量、数据类型、运算符和基本输入输出

📝 Java语法基础

🎯 Java语法特点

🌟 Java语法设计理念：简洁、清晰、易读

✨ 核心语法规则
📋 Java语法规则
│
├── 🔤 大小写敏感
│   ├── Hello ≠ hello ≠ HELLO
│   └── 变量名、类名、方法名都区分大小写
│
├── 📝 标识符规则
│   ├── 字母、数字、下划线、美元符号
│   ├── 不能以数字开头
│   └── 不能使用Java关键字
│
├── 🎯 命名约定
│   ├── 类名：PascalCase (HelloWorld)
│   ├── 方法名：camelCase (getName)
│   ├── 变量名：camelCase (userName)
│   └── 常量名：UPPER_CASE (MAX_SIZE)
│
└── 📄 文件结构
    ├── 包声明 (package)
    ├── 导入语句 (import)
    ├── 类定义 (class)
    └── 方法定义 (method)
🔑 Java关键字
类别关键字说明
🏗️ 类相关class, interface, extends, implements定义类和接口
🔒 访问控制public, private, protected控制访问权限
🔢 数据类型int, double, boolean, char基本数据类型
🔄 流程控制if, else, for, while, switch控制程序流程
🎯 修饰符static, final, abstract修饰类、方法、变量
⚠️ 注意事项
• Java关键字不能用作变量名、方法名或类名
• 关键字都是小写字母
• 保留字（如goto、const）虽然不使用，但也不能作为标识符

📄 Java程序结构

🏗️ 基本程序结构
💻 标准Java程序结构 
// 📦 包声明（可选）
package com.example.demo;

// 📚 导入语句（可选）
import java.util.Scanner;
import java.util.Date;

/**
 * 📝 类注释
 * 这是一个示例Java类
 */
public class JavaSyntaxDemo {
    
    // 🔢 类变量（静态变量）
    public static final String COMPANY_NAME = "Java学习";
    
    // 📦 实例变量
    private String userName;
    private int userAge;
    
    // 🚪 程序入口点
    public static void main(String[] args) {
        // 📢 输出欢迎信息
        System.out.println("🎉 欢迎学习Java基础语法！");
        
        // 🎯 创建对象并调用方法
        JavaSyntaxDemo demo = new JavaSyntaxDemo();
        demo.showUserInfo("张三", 25);
    }
    
    // 📝 实例方法
    public void showUserInfo(String name, int age) {
        this.userName = name;
        this.userAge = age;
        
        System.out.println("👤 用户姓名：" + userName);
        System.out.println("🎂 用户年龄：" + userAge);
    }
}
🎨 代码风格规范
📏 代码格式化规范
• 缩进：使用4个空格或1个Tab
• 大括号：开括号不换行，闭括号单独一行
• 空格：运算符前后加空格
• 注释：单行用//，多行用/* */

🔢 数据类型详解

🎯 Java数据类型分类

📊 Java数据类型体系：基本类型 + 引用类型

🔢 Java数据类型
│
├── 🎯 基本数据类型 (Primitive Types)
│   ├── 🔢 整数类型
│   │   ├── byte    (1字节, -128 ~ 127)
│   │   ├── short   (2字节, -32,768 ~ 32,767)
│   │   ├── int     (4字节, -2^31 ~ 2^31-1)
│   │   └── long    (8字节, -2^63 ~ 2^63-1)
│   │
│   ├── 💫 浮点类型
│   │   ├── float   (4字节, 单精度)
│   │   └── double  (8字节, 双精度)
│   │
│   ├── 🔤 字符类型
│   │   └── char    (2字节, Unicode字符)
│   │
│   └── ✅ 布尔类型
│       └── boolean (true/false)
│
└── 📦 引用数据类型 (Reference Types)
    ├── 🏗️ 类 (Class)
    ├── 🔗 接口 (Interface)
    └── 📋 数组 (Array)

🔢 基本数据类型详解

1️⃣ 整数类型
💻 整数类型示例 
public class IntegerTypes {
    public static void main(String[] args) {
        // 🔢 byte类型 (-128 ~ 127)
        byte smallNumber = 100;
        System.out.println("byte值: " + smallNumber);
        
        // 🔢 short类型 (-32,768 ~ 32,767)
        short mediumNumber = 30000;
        System.out.println("short值: " + mediumNumber);
        
        // 🔢 int类型 (默认整数类型)
        int normalNumber = 2000000;
        System.out.println("int值: " + normalNumber);
        
        // 🔢 long类型 (需要L后缀)
        long bigNumber = 9000000000L;
        System.out.println("long值: " + bigNumber);
        
        // 🎨 不同进制表示
        int decimal = 100;      // 十进制
        int binary = 0b1100100; // 二进制 (Java 7+)
        int octal = 0144;       // 八进制
        int hex = 0x64;         // 十六进制
        
        System.out.println("十进制: " + decimal);
        System.out.println("二进制: " + binary);
        System.out.println("八进制: " + octal);
        System.out.println("十六进制: " + hex);
    }
}
类型字节数取值范围默认值使用场景
byte1-128 ~ 1270节省内存的小整数
short2-32,768 ~ 32,7670中等范围整数
int4-2,147,483,648 ~ 2,147,483,6470最常用的整数类型
long8-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,8070L大整数运算
2️⃣ 浮点类型
💻 浮点类型示例 
public class FloatingTypes {
    public static void main(String[] args) {
        // 💫 float类型 (需要f后缀)
        float price = 99.99f;
        System.out.println("商品价格: " + price);
        
        // 💫 double类型 (默认浮点类型)
        double pi = 3.14159265359;
        System.out.println("圆周率: " + pi);
        
        // 🔬 科学计数法
        double scientific = 1.23e-4; // 0.000123
        System.out.println("科学计数法: " + scientific);
        
        // ⚠️ 浮点数精度问题
        double result = 0.1 + 0.2;
        System.out.println("0.1 + 0.2 = " + result); // 可能不等于0.3
        
        // 🎯 特殊值
        double positiveInfinity = Double.POSITIVE_INFINITY;
        double negativeInfinity = Double.NEGATIVE_INFINITY;
        double notANumber = Double.NaN;
        
        System.out.println("正无穷: " + positiveInfinity);
        System.out.println("负无穷: " + negativeInfinity);
        System.out.println("非数字: " + notANumber);
    }
}
类型字节数精度取值范围默认值
float4约7位有效数字±3.4E±380.0f
double8约15位有效数字±1.7E±3080.0d
⚠️ 浮点数注意事项
• 浮点数存在精度问题，不适合精确计算（如金融）
• 使用BigDecimal类进行精确的小数运算
• float字面量需要f后缀，否则默认为double
3️⃣ 字符类型
💻 字符类型示例 
public class CharacterType {
    public static void main(String[] args) {
        // 🔤 字符字面量
        char letter = 'A';
        char chinese = '中';
        char symbol = '@';
        
        System.out.println("字母: " + letter);
        System.out.println("中文: " + chinese);
        System.out.println("符号: " + symbol);
        
        // 🔢 Unicode编码
        char unicodeChar = '\u4E2D'; // 中文"中"的Unicode
        System.out.println("Unicode字符: " + unicodeChar);
        
        // 🎯 转义字符
        char newline = '\n';    // 换行
        char tab = '\t';        // 制表符
        char backslash = '\\';  // 反斜杠
        char quote = '\'';      // 单引号
        
        System.out.println("转义字符演示:");
        System.out.println("第一行" + newline + "第二行");
        System.out.println("制表符" + tab + "对齐");
        System.out.println("反斜杠: " + backslash);
        System.out.println("单引号: " + quote);
        
        // 🔄 字符与数字转换
        char digit = '5';
        int number = digit - '0'; // 字符转数字
        System.out.println("字符'5'转为数字: " + number);
        
        char nextChar = (char)(letter + 1); // 下一个字符
        System.out.println("A的下一个字符: " + nextChar);
    }
}
4️⃣ 布尔类型
💻 布尔类型示例 
public class BooleanType {
    public static void main(String[] args) {
        // ✅ 布尔字面量
        boolean isStudent = true;
        boolean isWorking = false;
        
        System.out.println("是学生: " + isStudent);
        System.out.println("在工作: " + isWorking);
        
        // 🔍 比较运算结果
        int age = 18;
        boolean isAdult = age >= 18;
        boolean isMinor = age < 18;
        
        System.out.println("年龄: " + age);
        System.out.println("是成年人: " + isAdult);
        System.out.println("是未成年人: " + isMinor);
        
        // 🔄 逻辑运算
        boolean canVote = isAdult && isStudent;
        boolean needGuardian = isMinor || !isWorking;
        
        System.out.println("可以投票: " + canVote);
        System.out.println("需要监护人: " + needGuardian);
    }
}
💡 布尔类型特点
• 只有两个值：true 和 false
• 不能与数字类型相互转换
• 常用于条件判断和逻辑运算
• 默认值为false

📦 变量的声明与使用

🎯 变量基础概念

📦 变量：存储数据的容器，具有名称、类型和值

🔧 变量声明语法
📝 变量声明格式 
// 🎯 基本语法
数据类型 变量名;                    // 声明变量
数据类型 变量名 = 初始值;           // 声明并初始化

// 💻 实际示例
int age;                          // 声明整型变量
int score = 95;                   // 声明并初始化
String name = "张三";             // 声明字符串变量

// 🔄 多变量声明
int x, y, z;                      // 声明多个同类型变量
int a = 1, b = 2, c = 3;         // 声明并初始化多个变量

🏷️ 变量命名规范

✅ 命名规则（必须遵守）
✅ 合法的变量名
• 以字母、下划线(_)或美元符号($)开头
• 后续字符可以是字母、数字、下划线或美元符号
• 区分大小写
• 不能使用Java关键字
❌ 非法的变量名
• 以数字开头： 2name
• 包含特殊字符： user-name, user@email
• 使用关键字： int, class, public
🎨 命名约定（建议遵守）
💻 命名约定示例 
public class NamingConventions {
    // 🔢 常量：全大写，下划线分隔
    public static final int MAX_SIZE = 100;
    public static final String DEFAULT_NAME = "未知";
    
    // 📦 实例变量：驼峰命名法
    private String userName;
    private int userAge;
    private boolean isActive;
    
    // 🎯 局部变量：驼峰命名法
    public void processData() {
        String firstName = "张";
        String lastName = "三";
        int totalScore = 0;
        boolean hasPermission = true;
        
        // 🔄 循环变量：简短有意义
        for (int i = 0; i < 10; i++) {
            // 处理逻辑
        }
        
        // 📋 集合变量：复数形式
        List<String> studentNames = new ArrayList<>();
        Map<String, Integer> scoreMap = new HashMap<>();
    }
}
类型命名约定示例说明
🔢 常量UPPER_CASEMAX_SIZE, PI全大写，下划线分隔
📦 变量camelCaseuserName, totalScore首字母小写的驼峰
🏗️ 类名PascalCaseStudentInfo, DataProcessor首字母大写的驼峰
📝 方法名camelCasegetName(), calculateTotal()动词开头的驼峰

🔄 变量的作用域

📍 作用域类型
🎯 Java变量作用域
│
├── 🏗️ 类变量 (Static Variables)
│   ├── 作用域：整个类
│   ├── 生命周期：程序运行期间
│   └── 访问：类名.变量名
│
├── 📦 实例变量 (Instance Variables)
│   ├── 作用域：整个对象
│   ├── 生命周期：对象存在期间
│   └── 访问：对象.变量名
│
├── 🎯 局部变量 (Local Variables)
│   ├── 作用域：声明的代码块内
│   ├── 生命周期：代码块执行期间
│   └── 访问：直接使用变量名
│
└── 🔄 参数变量 (Parameter Variables)
    ├── 作用域：方法内部
    ├── 生命周期：方法执行期间
    └── 访问：直接使用参数名
💻 作用域示例 
public class VariableScope {
    // 🏗️ 类变量（静态变量）
    public static int classVariable = 100;
    
    // 📦 实例变量
    private String instanceVariable = "实例变量";
    
    public void demonstrateScope(String parameter) { // 🔄 参数变量
        // 🎯 局部变量
        int localVariable = 50;
        
        System.out.println("类变量: " + classVariable);
        System.out.println("实例变量: " + instanceVariable);
        System.out.println("参数变量: " + parameter);
        System.out.println("局部变量: " + localVariable);
        
        // 🔄 代码块作用域
        if (true) {
            int blockVariable = 25; // 只在if块内有效
            System.out.println("块变量: " + blockVariable);
        }
        // System.out.println(blockVariable); // ❌ 编译错误
        
        // 🔄 循环作用域
        for (int i = 0; i < 3; i++) { // i只在循环内有效
            System.out.println("循环变量: " + i);
        }
        // System.out.println(i); // ❌ 编译错误
    }
    
    public static void main(String[] args) {
        VariableScope obj = new VariableScope();
        obj.demonstrateScope("传入的参数");
        
        // 🏗️ 访问类变量
        System.out.println("通过类名访问: " + VariableScope.classVariable);
    }
}

🎯 变量初始化

🔧 默认值规则
数据类型默认值说明
byte, short, int0整数类型默认为0
long0L长整型默认为0L
float0.0f单精度浮点默认为0.0f
double0.0d双精度浮点默认为0.0d
char‘\u0000’字符类型默认为空字符
booleanfalse布尔类型默认为false
引用类型null对象引用默认为null
⚠️ 重要提醒
• 实例变量和类变量有默认值
• 局部变量必须显式初始化才能使用
• 使用未初始化的局部变量会导致编译错误
💻 变量初始化示例 
public class VariableInitialization {
    // 📦 实例变量（有默认值）
    private int instanceInt;        // 默认值：0
    private boolean instanceBool;   // 默认值：false
    private String instanceString;  // 默认值：null
    
    public void demonstrateInitialization() {
        // 🎯 局部变量（必须初始化）
        int localInt;
        // System.out.println(localInt); // ❌ 编译错误：未初始化
        
        localInt = 10; // ✅ 初始化后可以使用
        System.out.println("局部变量: " + localInt);
        
        // ✅ 声明时初始化
        int initializedVar = 20;
        System.out.println("初始化变量: " + initializedVar);
        
        // 📦 显示实例变量的默认值
        System.out.println("实例int默认值: " + instanceInt);
        System.out.println("实例boolean默认值: " + instanceBool);
        System.out.println("实例String默认值: " + instanceString);
    }
    
    public static void main(String[] args) {
        VariableInitialization obj = new VariableInitialization();
        obj.demonstrateInitialization();
    }
}

🔄 类型转换

🎯 类型转换概述

🔄 类型转换：将一种数据类型的值转换为另一种数据类型

📊 转换类型分类
🔄 Java类型转换
│
├── 🔼 自动类型转换 (隐式转换)
│   ├── 小范围 → 大范围
│   ├── 精度不丢失
│   └── 编译器自动完成
│
└── 🔽 强制类型转换 (显式转换)
    ├── 大范围 → 小范围
    ├── 可能丢失精度
    └── 需要强制转换操作符

🔼 自动类型转换（隐式转换）

📈 转换规则图
🔼 自动类型转换路径

byte → short → int → long → float → double
  ↓      ↓      ↓      ↓       ↓
char ────────→ int → long → float → double

📏 转换规则：
• 容量小的类型自动转换为容量大的类型
• 整数类型可以自动转换为浮点类型
• char可以自动转换为int及更大的类型
💻 自动转换示例 
public class AutomaticConversion {
    public static void main(String[] args) {
        // 🔼 整数类型自动转换
        byte byteValue = 10;
        short shortValue = byteValue;    // byte → short
        int intValue = shortValue;       // short → int
        long longValue = intValue;       // int → long
        
        System.out.println("byte → short: " + shortValue);
        System.out.println("short → int: " + intValue);
        System.out.println("int → long: " + longValue);
        
        // 🔼 整数到浮点数转换
        float floatValue = longValue;    // long → float
        double doubleValue = floatValue; // float → double
        
        System.out.println("long → float: " + floatValue);
        System.out.println("float → double: " + doubleValue);
        
        // 🔤 字符类型转换
        char charValue = 'A';
        int charToInt = charValue;       // char → int (ASCII值)
        
        System.out.println("字符'A': " + charValue);
        System.out.println("'A'的ASCII值: " + charToInt);
        
        // 🔄 混合运算中的自动转换
        int intNum = 10;
        double doubleNum = 3.14;
        double result = intNum + doubleNum; // int自动转换为double
        
        System.out.println("混合运算结果: " + result);
    }
}

🔽 强制类型转换（显式转换）

⚠️ 强制转换语法
📝 强制转换语法 
// 🎯 基本语法
目标类型 变量名 = (目标类型) 源变量;

// 💻 实际示例
double doubleValue = 3.14;
int intValue = (int) doubleValue;        // 强制转换为int

long longValue = 1000L;
int intFromLong = (int) longValue;       // 强制转换为int

float floatValue = 99.99f;
int intFromFloat = (int) floatValue;     // 强制转换为int
💻 强制转换示例 
public class ExplicitConversion {
    public static void main(String[] args) {
        // 🔽 浮点数到整数转换（截断小数部分）
        double pi = 3.14159;
        int intPi = (int) pi;
        System.out.println("π的值: " + pi);
        System.out.println("强制转换为int: " + intPi); // 输出：3
        
        // 🔽 大整数到小整数转换
        long bigNumber = 300L;
        byte smallByte = (byte) bigNumber;
        System.out.println("long值: " + bigNumber);
        System.out.println("转换为byte: " + smallByte); // 可能溢出
        
        // ⚠️ 数据溢出示例
        int maxInt = Integer.MAX_VALUE;
        byte overflowByte = (byte) maxInt;
        System.out.println("int最大值: " + maxInt);
        System.out.println("溢出后的byte值: " + overflowByte);
        
        // 🔤 数字到字符转换
        int asciiValue = 65;
        char character = (char) asciiValue;
        System.out.println("ASCII 65对应字符: " + character); // 输出：A
        
        // 🔄 字符到数字转换
        char digit = '9';
        int number = digit - '0'; // 字符运算转换
        System.out.println("字符'9'转为数字: " + number);
        
        // 🎯 布尔类型不能转换
        // boolean flag = true;
        // int boolToInt = (int) flag; // ❌ 编译错误
    }
}
⚠️ 强制转换注意事项
• 可能导致数据丢失或精度损失
• 大数值转换为小类型可能发生溢出
• 浮点数转整数会截断小数部分
• boolean类型不能与其他类型相互转换

🎯 类型提升规则

📊 运算中的类型提升
💻 类型提升示例 
public class TypePromotion {
    public static void main(String[] args) {
        // 🔼 byte和short运算提升为int
        byte b1 = 10;
        byte b2 = 20;
        // byte result = b1 + b2; // ❌ 编译错误
        int result = b1 + b2;     // ✅ 正确
        System.out.println("byte运算结果: " + result);
        
        // 🔼 char运算提升为int
        char c1 = 'A';
        char c2 = 'B';
        int charResult = c1 + c2; // char提升为int
        System.out.println("字符运算结果: " + charResult);
        
        // 🔼 混合类型运算
        int intValue = 10;
        float floatValue = 3.5f;
        float mixedResult = intValue + floatValue; // int提升为float
        System.out.println("混合运算结果: " + mixedResult);
        
        // 🔼 表达式中的最高类型
        byte byteVal = 1;
        short shortVal = 2;
        int intVal = 3;
        long longVal = 4L;
        float floatVal = 5.0f;
        
        // 结果类型为float（表达式中的最高类型）
        float expressionResult = byteVal + shortVal + intVal + longVal + floatVal;
        System.out.println("表达式结果: " + expressionResult);
    }
}
📋 类型提升规则总结
运算情况提升规则结果类型
byte + byte提升为intint
short + short提升为intint
char + char提升为intint
int + longint提升为longlong
int + floatint提升为floatfloat
float + doublefloat提升为doubledouble
💡 类型提升记忆口诀
• byte、short、char运算必提升为int
• 有long则long，有float则float，有double则double
• 表达式结果类型取决于参与运算的最高类型

⚡ 运算符

🎯 运算符分类

⚡ 运算符：用于执行特定数学或逻辑操作的符号

⚡ Java运算符分类
│
├── 🔢 算术运算符
│   ├── + (加法)
│   ├── - (减法)
│   ├── * (乘法)
│   ├── / (除法)
│   └── % (取模)
│
├── 🔄 赋值运算符
│   ├── = (赋值)
│   ├── += (加等)
│   ├── -= (减等)
│   ├── *= (乘等)
│   └── /= (除等)
│
├── 🔍 比较运算符
│   ├── == (等于)
│   ├── != (不等于)
│   ├── > (大于)
│   ├── < (小于)
│   ├── >= (大于等于)
│   └── <= (小于等于)
│
├── 🧠 逻辑运算符
│   ├── && (逻辑与)
│   ├── || (逻辑或)
│   └── ! (逻辑非)
│
├── 🔄 自增自减运算符
│   ├── ++ (自增)
│   └── -- (自减)
│
└── 🎯 三元运算符
    └── ?: (条件运算符)

🔢 算术运算符

💻 算术运算符示例 
public class ArithmeticOperators {
    public static void main(String[] args) {
        int a = 15;
        int b = 4;

        // 🔢 基本算术运算
        int addition = a + b;       // 加法
        int subtraction = a - b;    // 减法
        int multiplication = a * b; // 乘法
        int division = a / b;       // 除法（整数除法）
        int modulus = a % b;        // 取模（余数）

        System.out.println("a = " + a + ", b = " + b);
        System.out.println("a + b = " + addition);      // 19
        System.out.println("a - b = " + subtraction);   // 11
        System.out.println("a * b = " + multiplication); // 60
        System.out.println("a / b = " + division);       // 3 (整数除法)
        System.out.println("a % b = " + modulus);        // 3 (余数)

        // 💫 浮点数除法
        double doubleA = 15.0;
        double doubleB = 4.0;
        double doubleDivision = doubleA / doubleB;

        System.out.println("浮点数除法: " + doubleA + " / " + doubleB + " = " + doubleDivision);

        // ⚠️ 除零异常
        try {
            int result = a / 0; // 运行时异常
        } catch (ArithmeticException e) {
            System.out.println("除零错误: " + e.getMessage());
        }

        // 🎯 取模运算的应用
        int number = 17;
        boolean isEven = (number % 2) == 0;
        boolean isOdd = (number % 2) == 1;

        System.out.println(number + " 是偶数: " + isEven);
        System.out.println(number + " 是奇数: " + isOdd);
    }
}
运算符名称示例结果说明
+加法5 + 38数值相加
-减法5 - 32数值相减
*乘法5 * 315数值相乘
/除法5 / 31整数除法取整
%取模5 % 32取余数

🔄 赋值运算符

💻 赋值运算符示例 
public class AssignmentOperators {
    public static void main(String[] args) {
        int x = 10; // 基本赋值

        System.out.println("初始值 x = " + x);

        // 🔄 复合赋值运算符
        x += 5;  // 等价于 x = x + 5
        System.out.println("x += 5 后，x = " + x); // 15

        x -= 3;  // 等价于 x = x - 3
        System.out.println("x -= 3 后，x = " + x); // 12

        x *= 2;  // 等价于 x = x * 2
        System.out.println("x *= 2 后，x = " + x); // 24

        x /= 4;  // 等价于 x = x / 4
        System.out.println("x /= 4 后，x = " + x); // 6

        x %= 4;  // 等价于 x = x % 4
        System.out.println("x %= 4 后，x = " + x); // 2

        // 🎯 字符串连接赋值
        String message = "Hello";
        message += " World";  // 字符串连接
        message += "!";
        System.out.println("字符串连接结果: " + message); // Hello World!

        // 🔄 多重赋值
        int a, b, c;
        a = b = c = 100; // 从右到左赋值
        System.out.println("多重赋值: a=" + a + ", b=" + b + ", c=" + c);
    }
}
运算符名称示例等价形式说明
=赋值x = 5-将右边的值赋给左边
+=加等x += 3x = x + 3加法后赋值
-=减等x -= 3x = x - 3减法后赋值
*=乘等x *= 3x = x * 3乘法后赋值
/=除等x /= 3x = x / 3除法后赋值
%=模等x %= 3x = x % 3取模后赋值

🔍 比较运算符

💻 比较运算符示例 
public class ComparisonOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 10;

        System.out.println("a = " + a + ", b = " + b + ", c = " + c);

        // 🔍 基本比较运算
        boolean equal = (a == c);           // 等于
        boolean notEqual = (a != b);        // 不等于
        boolean greater = (b > a);          // 大于
        boolean less = (a < b);             // 小于
        boolean greaterEqual = (a >= c);    // 大于等于
        boolean lessEqual = (a <= b);       // 小于等于

        System.out.println("a == c: " + equal);        // true
        System.out.println("a != b: " + notEqual);     // true
        System.out.println("b > a: " + greater);       // true
        System.out.println("a < b: " + less);          // true
        System.out.println("a >= c: " + greaterEqual); // true
        System.out.println("a <= b: " + lessEqual);    // true

        // 🔤 字符比较
        char char1 = 'A';
        char char2 = 'B';
        boolean charComparison = char1 < char2; // 比较ASCII值
        System.out.println("'A' < 'B': " + charComparison); // true

        // 📝 字符串比较（注意：不能用==比较内容）
        String str1 = "Hello";
        String str2 = "Hello";
        String str3 = new String("Hello");

        System.out.println("str1 == str2: " + (str1 == str2));     // true (字符串池)
        System.out.println("str1 == str3: " + (str1 == str3));     // false (不同对象)
        System.out.println("str1.equals(str3): " + str1.equals(str3)); // true (内容相同)

        // 🎯 浮点数比较注意事项
        double d1 = 0.1 + 0.2;
        double d2 = 0.3;
        System.out.println("0.1 + 0.2 == 0.3: " + (d1 == d2)); // 可能为false

        // 正确的浮点数比较方法
        double epsilon = 1e-10;
        boolean floatEqual = Math.abs(d1 - d2) < epsilon;
        System.out.println("浮点数近似相等: " + floatEqual);
    }
}
运算符名称示例结果类型说明
==等于a == bboolean值相等返回true
!=不等于a != bboolean值不等返回true
>大于a > bbooleana大于b返回true
<小于a < bbooleana小于b返回true
>=大于等于a >= bbooleana大于等于b返回true
<=小于等于a <= bbooleana小于等于b返回true

🧠 逻辑运算符

💻 逻辑运算符示例 
public class LogicalOperators {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        boolean c = true;

        System.out.println("a = " + a + ", b = " + b + ", c = " + c);

        // 🧠 逻辑与 (&&) - 短路运算
        boolean andResult = a && c;  // true && true = true
        boolean andResult2 = a && b; // true && false = false
        boolean andResult3 = b && c; // false && true = false

        System.out.println("a && c: " + andResult);   // true
        System.out.println("a && b: " + andResult2);  // false
        System.out.println("b && c: " + andResult3);  // false

        // 🧠 逻辑或 (||) - 短路运算
        boolean orResult = a || b;   // true || false = true
        boolean orResult2 = b || c;  // false || true = true
        boolean orResult3 = b || false; // false || false = false

        System.out.println("a || b: " + orResult);    // true
        System.out.println("b || c: " + orResult2);   // true
        System.out.println("b || false: " + orResult3); // false

        // 🧠 逻辑非 (!)
        boolean notA = !a;           // !true = false
        boolean notB = !b;           // !false = true

        System.out.println("!a: " + notA);            // false
        System.out.println("!b: " + notB);            // true

        // 🎯 复合逻辑表达式
        int age = 25;
        boolean hasLicense = true;
        boolean canDrive = (age >= 18) && hasLicense;

        System.out.println("年龄: " + age + ", 有驾照: " + hasLicense);
        System.out.println("可以开车: " + canDrive);

        // 🔄 短路运算演示
        int x = 5;
        boolean shortCircuit = (x > 10) && (++x > 0); // ++x不会执行
        System.out.println("短路运算后 x = " + x); // x仍为5

        boolean noShortCircuit = (x < 10) && (++x > 0); // ++x会执行
        System.out.println("非短路运算后 x = " + x); // x变为6
    }
}
运算符名称示例说明短路特性
&&逻辑与a && b两个都为true才返回true左边为false时不计算右边
``逻辑或`a
!逻辑非!a取反，true变false，false变true无短路

🔄 自增自减运算符

💻 自增自减运算符示例 
public class IncrementDecrementOperators {
    public static void main(String[] args) {
        int a = 5;
        int b = 5;

        // 🔄 前置自增/自减（先运算，后使用）
        int preIncrement = ++a;  // a先自增为6，然后赋值给preIncrement
        System.out.println("前置自增: a = " + a + ", preIncrement = " + preIncrement);

        int preDecrement = --b;  // b先自减为4，然后赋值给preDecrement
        System.out.println("前置自减: b = " + b + ", preDecrement = " + preDecrement);

        // 🔄 后置自增/自减（先使用，后运算）
        int c = 5;
        int d = 5;

        int postIncrement = c++; // c的值5先赋值给postIncrement，然后c自增为6
        System.out.println("后置自增: c = " + c + ", postIncrement = " + postIncrement);

        int postDecrement = d--; // d的值5先赋值给postDecrement，然后d自减为4
        System.out.println("后置自减: d = " + d + ", postDecrement = " + postDecrement);

        // 🎯 在表达式中的应用
        int x = 10;
        int y = 20;

        int result1 = x++ + ++y; // x=10参与运算后自增为11，y先自增为21再参与运算
        System.out.println("x++ + ++y = " + result1 + ", x = " + x + ", y = " + y);

        // 🔄 循环中的常见用法
        System.out.println("循环计数演示:");
        for (int i = 0; i < 5; i++) { // 后置自增
            System.out.print(i + " ");
        }
        System.out.println();

        // ⚠️ 注意事项：避免在同一表达式中多次修改同一变量
        int problematic = 5;
        // int bad = problematic++ + ++problematic; // 未定义行为，避免使用
    }
}
运算符名称示例执行顺序返回值
++var前置自增++a先自增，后使用自增后的值
var++后置自增a++先使用，后自增自增前的值
--var前置自减--a先自减，后使用自减后的值
var--后置自减a--先使用，后自减自减前的值

🎯 三元运算符

💻 三元运算符示例 
public class TernaryOperator {
    public static void main(String[] args) {
        // 🎯 基本语法：条件 ? 值1 : 值2
        int a = 10;
        int b = 20;

        // 🔍 找出较大值
        int max = (a > b) ? a : b;
        System.out.println("较大值: " + max); // 20

        // 🔍 找出较小值
        int min = (a < b) ? a : b;
        System.out.println("较小值: " + min); // 10

        // 🎯 判断奇偶性
        int number = 17;
        String parity = (number % 2 == 0) ? "偶数" : "奇数";
        System.out.println(number + " 是 " + parity);

        // 🎯 成绩等级判断
        int score = 85;
        String grade = (score >= 90) ? "优秀" :
                      (score >= 80) ? "良好" :
                      (score >= 70) ? "中等" :
                      (score >= 60) ? "及格" : "不及格";
        System.out.println("成绩 " + score + " 等级: " + grade);

        // 🎯 空值检查
        String name = null;
        String displayName = (name != null) ? name : "匿名用户";
        System.out.println("显示名称: " + displayName);

        // 🎯 绝对值计算
        int value = -15;
        int absoluteValue = (value >= 0) ? value : -value;
        System.out.println(value + " 的绝对值: " + absoluteValue);

        // 🔄 与if-else的对比
        // 使用三元运算符（简洁）
        String result1 = (a > 0) ? "正数" : "非正数";

        // 使用if-else（更清晰）
        String result2;
        if (a > 0) {
            result2 = "正数";
        } else {
            result2 = "非正数";
        }

        System.out.println("三元运算符结果: " + result1);
        System.out.println("if-else结果: " + result2);
    }
}
💡 三元运算符使用建议
• 适用于简单的条件赋值
• 嵌套使用时要注意可读性
• 复杂逻辑建议使用if-else语句
• 两个分支的返回类型要兼容

📊 运算符优先级

优先级运算符结合性说明
1() [] .左到右括号、数组、成员访问
2++ -- ! ~右到左一元运算符
3* / %左到右乘除取模
4+ -左到右加减
5<< >> >>>左到右位移运算
6< <= > >=左到右关系运算
7== !=左到右相等性判断
8&左到右按位与
9^左到右按位异或
10``左到右
11&&左到右逻辑与
12``
13?:右到左三元运算符
14= += -= 等右到左赋值运算符
💻 运算符优先级示例 
public class OperatorPrecedence {
    public static void main(String[] args) {
        // 🎯 算术运算符优先级
        int result1 = 2 + 3 * 4;        // 先乘后加：2 + 12 = 14
        int result2 = (2 + 3) * 4;      // 括号优先：5 * 4 = 20

        System.out.println("2 + 3 * 4 = " + result1);      // 14
        System.out.println("(2 + 3) * 4 = " + result2);    // 20

        // 🎯 比较和逻辑运算符优先级
        boolean result3 = 5 > 3 && 2 < 4;  // 先比较后逻辑：true && true = true
        boolean result4 = 5 > 3 || 2 > 4;  // 先比较后逻辑：true || false = true

        System.out.println("5 > 3 && 2 < 4 = " + result3); // true
        System.out.println("5 > 3 || 2 > 4 = " + result4); // true

        // 🎯 自增运算符优先级
        int a = 5;
        int result5 = ++a * 2;          // 先自增后乘法：6 * 2 = 12
        System.out.println("++a * 2 = " + result5 + ", a = " + a);

        int b = 5;
        int result6 = b++ * 2;          // 先乘法后自增：5 * 2 = 10
        System.out.println("b++ * 2 = " + result6 + ", b = " + b);

        // 🎯 复杂表达式
        int x = 10, y = 20, z = 30;
        boolean complexResult = x < y && y < z || x > z;
        // 等价于：((x < y) && (y < z)) || (x > z)
        // 即：(true && true) || false = true
        System.out.println("复杂表达式结果: " + complexResult);
    }
}
💡 优先级记忆技巧
• 括号优先级最高，可以改变运算顺序
• 一元运算符 > 算术运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符
• 不确定时使用括号明确运算顺序
• 复杂表达式建议拆分为多个简单表达式

🔀 流程控制

🎯 流程控制概述

🔀 流程控制：控制程序执行顺序的语句，包括条件判断、循环和跳转

📊 流程控制分类
🔀 Java流程控制语句
│
├── 🔍 条件语句 (Selection Statements)
│   ├── if语句
│   ├── if-else语句
│   ├── if-else if-else语句
│   └── switch语句
│
├── 🔄 循环语句 (Loop Statements)
│   ├── for循环
│   ├── while循环
│   ├── do-while循环
│   └── 增强for循环(for-each)
│
└── 🎯 跳转语句 (Jump Statements)
    ├── break语句
    ├── continue语句
    └── return语句

🔍 条件语句

1️⃣ if语句
💻 if语句示例 
public class IfStatement {
    public static void main(String[] args) {
        int score = 85;

        // 🔍 简单if语句
        if (score >= 60) {
            System.out.println("恭喜！考试及格了！");
        }

        // 🔍 if-else语句
        if (score >= 90) {
            System.out.println("优秀！");
        } else {
            System.out.println("继续努力！");
        }

        // 🔍 多重if-else语句
        if (score >= 90) {
            System.out.println("等级：优秀");
        } else if (score >= 80) {
            System.out.println("等级：良好");
        } else if (score >= 70) {
            System.out.println("等级：中等");
        } else if (score >= 60) {
            System.out.println("等级：及格");
        } else {
            System.out.println("等级：不及格");
        }

        // 🔍 嵌套if语句
        if (score >= 60) {
            if (score >= 90) {
                System.out.println("可以申请奖学金！");
            } else {
                System.out.println("继续努力争取奖学金！");
            }
        } else {
            System.out.println("需要补考！");
        }
    }
}
2️⃣ switch语句
💻 switch语句示例 
public class SwitchStatement {
    public static void main(String[] args) {
        // 🔍 基本switch语句
        int dayOfWeek = 3;

        switch (dayOfWeek) {
            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("无效的星期");
        }

        // 🔍 字符switch语句
        char grade = 'B';

        switch (grade) {
            case 'A':
                System.out.println("优秀！90-100分");
                break;
            case 'B':
                System.out.println("良好！80-89分");
                break;
            case 'C':
                System.out.println("中等！70-79分");
                break;
            case 'D':
                System.out.println("及格！60-69分");
                break;
            case 'F':
                System.out.println("不及格！0-59分");
                break;
            default:
                System.out.println("无效的等级");
        }

        // 🔍 字符串switch语句（Java 7+）
        String season = "春天";

        switch (season) {
            case "春天":
                System.out.println("万物复苏的季节");
                break;
            case "夏天":
                System.out.println("炎热的季节");
                break;
            case "秋天":
                System.out.println("收获的季节");
                break;
            case "冬天":
                System.out.println("寒冷的季节");
                break;
            default:
                System.out.println("未知的季节");
        }
    }
}

🔄 循环语句

1️⃣ for循环
💻 for循环示例 
public class ForLoop {
    public static void main(String[] args) {
        // 🔄 基本for循环
        System.out.println("=== 基本for循环 ===");
        for (int i = 1; i <= 5; i++) {
            System.out.println("第" + i + "次循环");
        }

        // 🔄 计算1到100的和
        System.out.println("\n=== 计算1到100的和 ===");
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println("1到100的和：" + sum);

        // 🔄 嵌套for循环 - 打印乘法表
        System.out.println("\n=== 九九乘法表 ===");
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "×" + i + "=" + (i * j) + "\t");
            }
            System.out.println();
        }

        // 🔄 增强for循环（for-each）
        System.out.println("\n=== 增强for循环 ===");
        int[] numbers = {1, 2, 3, 4, 5};
        for (int number : numbers) {
            System.out.println("数字：" + number);
        }

        String[] fruits = {"苹果", "香蕉", "橙子"};
        for (String fruit : fruits) {
            System.out.println("水果：" + fruit);
        }
    }
}
2️⃣ while循环
💻 while循环示例 
public class WhileLoop {
    public static void main(String[] args) {
        // 🔄 基本while循环
        System.out.println("=== 基本while循环 ===");
        int count = 1;
        while (count <= 5) {
            System.out.println("计数：" + count);
            count++;
        }

        // 🔄 计算阶乘
        System.out.println("\n=== 计算5的阶乘 ===");
        int n = 5;
        int factorial = 1;
        int i = 1;
        while (i <= n) {
            factorial *= i;
            i++;
        }
        System.out.println(n + "的阶乘：" + factorial);

        // 🔄 用户输入验证
        System.out.println("\n=== 输入验证示例 ===");
        java.util.Scanner scanner = new java.util.Scanner(System.in);
        int number;

        System.out.print("请输入一个1-10之间的数字：");
        number = scanner.nextInt();

        while (number < 1 || number > 10) {
            System.out.print("输入无效！请重新输入1-10之间的数字：");
            number = scanner.nextInt();
        }

        System.out.println("您输入的数字是：" + number);
        scanner.close();
    }
}
3️⃣ do-while循环
💻 do-while循环示例 
public class DoWhileLoop {
    public static void main(String[] args) {
        // 🔄 基本do-while循环
        System.out.println("=== 基本do-while循环 ===");
        int count = 1;
        do {
            System.out.println("执行第" + count + "次");
            count++;
        } while (count <= 5);

        // 🔄 菜单系统示例
        System.out.println("\n=== 简单菜单系统 ===");
        java.util.Scanner scanner = new java.util.Scanner(System.in);
        int choice;

        do {
            System.out.println("\n=== 主菜单 ===");
            System.out.println("1. 查看信息");
            System.out.println("2. 添加数据");
            System.out.println("3. 删除数据");
            System.out.println("0. 退出系统");
            System.out.print("请选择操作：");

            choice = scanner.nextInt();

            switch (choice) {
                case 1:
                    System.out.println("正在查看信息...");
                    break;
                case 2:
                    System.out.println("正在添加数据...");
                    break;
                case 3:
                    System.out.println("正在删除数据...");
                    break;
                case 0:
                    System.out.println("感谢使用，再见！");
                    break;
                default:
                    System.out.println("无效选择，请重新输入！");
            }
        } while (choice != 0);

        scanner.close();
    }
}

🎯 跳转语句

1️⃣ break语句
💻 break语句示例 
public class BreakStatement {
    public static void main(String[] args) {
        // 🎯 在循环中使用break
        System.out.println("=== 查找特定数字 ===");
        int[] numbers = {1, 3, 5, 7, 9, 2, 4, 6, 8};
        int target = 7;
        boolean found = false;

        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] == target) {
                System.out.println("找到数字" + target + "，位置：" + i);
                found = true;
                break; // 找到后立即退出循环
            }
        }

        if (!found) {
            System.out.println("未找到数字" + target);
        }

        // 🎯 在嵌套循环中使用break
        System.out.println("\n=== 嵌套循环中的break ===");
        outer: // 标签
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= 3; j++) {
                if (i == 2 && j == 2) {
                    System.out.println("遇到特殊条件，退出所有循环");
                    break outer; // 退出标签指定的循环
                }
                System.out.println("i=" + i + ", j=" + j);
            }
        }
    }
}
2️⃣ continue语句
💻 continue语句示例 
public class ContinueStatement {
    public static void main(String[] args) {
        // 🎯 跳过偶数，只打印奇数
        System.out.println("=== 只打印奇数 ===");
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) {
                continue; // 跳过偶数
            }
            System.out.println("奇数：" + i);
        }

        // 🎯 跳过特定条件
        System.out.println("\n=== 跳过负数和零 ===");
        int[] numbers = {-2, -1, 0, 1, 2, 3, -4, 5};

        for (int number : numbers) {
            if (number <= 0) {
                continue; // 跳过负数和零
            }
            System.out.println("正数：" + number);
        }

        // 🎯 在嵌套循环中使用continue
        System.out.println("\n=== 嵌套循环中的continue ===");
        for (int i = 1; i <= 3; i++) {
            System.out.println("外层循环：" + i);
            for (int j = 1; j <= 3; j++) {
                if (j == 2) {
                    continue; // 跳过内层循环的当前迭代
                }
                System.out.println("  内层循环：" + j);
            }
        }
    }
}

🎨 流程控制综合应用

💻 综合应用：数字猜谜游戏 
import java.util.Scanner;
import java.util.Random;

public class GuessNumberGame {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Random random = new Random();

        System.out.println("🎮 欢迎来到数字猜谜游戏！");

        boolean playAgain = true;

        while (playAgain) {
            // 生成1-100之间的随机数
            int secretNumber = random.nextInt(100) + 1;
            int attempts = 0;
            int maxAttempts = 7;
            boolean hasWon = false;

            System.out.println("\n🎯 我想了一个1-100之间的数字，你有" + maxAttempts + "次机会猜中它！");

            while (attempts < maxAttempts && !hasWon) {
                System.out.print("第" + (attempts + 1) + "次猜测，请输入你的数字：");
                int guess = scanner.nextInt();
                attempts++;

                if (guess == secretNumber) {
                    System.out.println("🎉 恭喜！你猜对了！数字就是" + secretNumber);
                    System.out.println("你用了" + attempts + "次就猜中了！");
                    hasWon = true;
                } else if (guess < secretNumber) {
                    System.out.println("📈 太小了！再试试更大的数字");
                } else {
                    System.out.println("📉 太大了！再试试更小的数字");
                }

                if (!hasWon && attempts < maxAttempts) {
                    System.out.println("还有" + (maxAttempts - attempts) + "次机会");
                }
            }

            if (!hasWon) {
                System.out.println("😢 很遗憾，你没有猜中！正确答案是：" + secretNumber);
            }

            // 询问是否再玩一次
            System.out.print("\n🔄 想再玩一次吗？(y/n)：");
            String response = scanner.next();
            playAgain = response.equalsIgnoreCase("y") || response.equalsIgnoreCase("yes");
        }

        System.out.println("👋 感谢游戏，再见！");
        scanner.close();
    }
}
💡 流程控制最佳实践
• 合理使用缩进，保持代码可读性
• 避免过深的嵌套，考虑提取方法
• 在switch语句中不要忘记break
• 使用有意义的变量名和注释
• 注意循环的终止条件，避免无限循环

📥 输入输出操作

📤 输出操作

🖨️ System.out输出方法
💻 基本输出方法 
public class OutputOperations {
    public static void main(String[] args) {
        // 📢 println() - 输出并换行
        System.out.println("Hello World!");
        System.out.println("这是第二行");

        // 📢 print() - 输出不换行
        System.out.print("不换行输出1 ");
        System.out.print("不换行输出2 ");
        System.out.println(); // 手动换行

        // 📢 printf() - 格式化输出
        String name = "张三";
        int age = 25;
        double salary = 8500.50;

        System.out.printf("姓名：%s，年龄：%d，薪资：%.2f%n", name, age, salary);

        // 🎯 变量输出
        int number = 42;
        String text = "Java";
        boolean flag = true;

        System.out.println("数字：" + number);
        System.out.println("文本：" + text);
        System.out.println("布尔值：" + flag);

        // 🎨 特殊字符输出
        System.out.println("制表符：\t制表符效果");
        System.out.println("换行符：\n这是新的一行");
        System.out.println("反斜杠：\\");
        System.out.println("双引号：\"Hello\"");

        // 🔢 数值格式化
        double pi = Math.PI;
        System.out.println("π的值：" + pi);
        System.out.printf("π保留2位小数：%.2f%n", pi);
        System.out.printf("π保留4位小数：%.4f%n", pi);
    }
}
🎨 格式化输出详解
💻 printf格式化示例 
public class FormattedOutput {
    public static void main(String[] args) {
        // 🔢 整数格式化
        int number = 123;
        System.out.printf("整数：%d%n", number);
        System.out.printf("5位宽度右对齐：%5d%n", number);
        System.out.printf("5位宽度左对齐：%-5d%n", number);
        System.out.printf("前导零：%05d%n", number);

        // 💫 浮点数格式化
        double value = 123.456789;
        System.out.printf("浮点数：%f%n", value);
        System.out.printf("保留2位小数：%.2f%n", value);
        System.out.printf("科学计数法：%e%n", value);
        System.out.printf("自动选择格式：%g%n", value);

        // 🔤 字符串格式化
        String name = "Java";
        System.out.printf("字符串：%s%n", name);
        System.out.printf("10位宽度右对齐：%10s%n", name);
        System.out.printf("10位宽度左对齐：%-10s%n", name);

        // 🔤 字符格式化
        char letter = 'A';
        System.out.printf("字符：%c%n", letter);
        System.out.printf("字符的ASCII值：%d%n", (int)letter);

        // ✅ 布尔值格式化
        boolean flag = true;
        System.out.printf("布尔值：%b%n", flag);
        System.out.printf("布尔值（大写）：%B%n", flag);

        // 🎯 综合格式化示例
        String studentName = "李四";
        int studentAge = 20;
        double studentScore = 95.5;
        char studentGrade = 'A';

        System.out.printf("学生信息：姓名=%s, 年龄=%d, 成绩=%.1f, 等级=%c%n",
                         studentName, studentAge, studentScore, studentGrade);

        // 📊 表格格式输出
        System.out.println("学生成绩表：");
        System.out.printf("%-10s %5s %8s %6s%n", "姓名", "年龄", "成绩", "等级");
        System.out.printf("%-10s %5d %8.1f %6c%n", "张三", 18, 88.5, 'B');
        System.out.printf("%-10s %5d %8.1f %6c%n", "李四", 19, 92.0, 'A');
        System.out.printf("%-10s %5d %8.1f %6c%n", "王五", 20, 76.5, 'C');
    }
}
格式符数据类型说明示例
%d整数十进制整数%d → 123
%f浮点数小数形式%.2f → 123.46
%e浮点数科学计数法%e → 1.234568e+02
%s字符串字符串%s → Hello
%c字符单个字符%c → A
%b布尔值true/false%b → true
%n换行符平台无关的换行相当于\n

📥 输入操作

🎯 Scanner类基础
💻 Scanner基本使用 
import java.util.Scanner; // 导入Scanner类

public class InputOperations {
    public static void main(String[] args) {
        // 🎯 创建Scanner对象
        Scanner scanner = new Scanner(System.in);

        // 📝 提示用户输入
        System.out.print("请输入您的姓名：");
        String name = scanner.nextLine(); // 读取一行字符串

        System.out.print("请输入您的年龄：");
        int age = scanner.nextInt(); // 读取整数

        System.out.print("请输入您的身高（米）：");
        double height = scanner.nextDouble(); // 读取浮点数

        System.out.print("您是学生吗？(true/false)：");
        boolean isStudent = scanner.nextBoolean(); // 读取布尔值

        // 📤 输出用户信息
        System.out.println("\n=== 用户信息 ===");
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.printf("身高：%.2f米%n", height);
        System.out.println("是否为学生：" + isStudent);

        // 🔒 关闭Scanner（良好习惯）
        scanner.close();
    }
}
🔧 Scanner方法详解
💻 Scanner各种输入方法 
import java.util.Scanner;

public class ScannerMethods {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 🔤 字符串输入
        System.out.print("输入一个单词：");
        String word = scanner.next(); // 读取单个单词（遇到空格停止）
        System.out.println("单词：" + word);

        // 清除缓冲区的换行符
        scanner.nextLine();

        System.out.print("输入一行文本：");
        String line = scanner.nextLine(); // 读取整行（包含空格）
        System.out.println("整行：" + line);

        // 🔢 数值输入
        System.out.print("输入一个字节(-128~127)：");
        byte byteValue = scanner.nextByte();

        System.out.print("输入一个短整数：");
        short shortValue = scanner.nextShort();

        System.out.print("输入一个整数：");
        int intValue = scanner.nextInt();

        System.out.print("输入一个长整数：");
        long longValue = scanner.nextLong();

        System.out.print("输入一个单精度浮点数：");
        float floatValue = scanner.nextFloat();

        System.out.print("输入一个双精度浮点数：");
        double doubleValue = scanner.nextDouble();

        // ✅ 布尔值输入
        System.out.print("输入布尔值(true/false)：");
        boolean boolValue = scanner.nextBoolean();

        // 📊 输出所有输入的值
        System.out.println("\n=== 输入汇总 ===");
        System.out.println("byte: " + byteValue);
        System.out.println("short: " + shortValue);
        System.out.println("int: " + intValue);
        System.out.println("long: " + longValue);
        System.out.println("float: " + floatValue);
        System.out.println("double: " + doubleValue);
        System.out.println("boolean: " + boolValue);

        scanner.close();
    }
}
方法返回类型说明示例
next()String读取下一个单词输入"Hello World"返回"Hello"
nextLine()String读取整行输入"Hello World"返回"Hello World"
nextInt()int读取整数输入"123"返回123
nextDouble()double读取浮点数输入"3.14"返回3.14
nextBoolean()boolean读取布尔值输入"true"返回true
hasNext()boolean检查是否有下一个输入有输入返回true
hasNextInt()boolean检查下一个输入是否为整数是整数返回true
⚠️ Scanner使用注意事项
💻 Scanner常见问题及解决方案 
import java.util.Scanner;

public class ScannerIssues {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // ⚠️ 问题1：nextInt()后使用nextLine()的问题
        System.out.print("输入年龄：");
        int age = scanner.nextInt();

        // 这里需要消费掉nextInt()留下的换行符
        scanner.nextLine(); // 消费换行符

        System.out.print("输入姓名：");
        String name = scanner.nextLine();

        System.out.println("年龄：" + age + "，姓名：" + name);

        // ⚠️ 问题2：输入验证
        System.out.print("请输入一个整数：");
        while (!scanner.hasNextInt()) {
            System.out.print("输入无效，请输入一个整数：");
            scanner.next(); // 消费无效输入
        }
        int validNumber = scanner.nextInt();
        System.out.println("有效整数：" + validNumber);

        // ⚠️ 问题3：异常处理
        scanner.nextLine(); // 消费换行符
        System.out.print("输入一个浮点数：");
        try {
            String input = scanner.nextLine();
            double number = Double.parseDouble(input);
            System.out.println("浮点数：" + number);
        } catch (NumberFormatException e) {
            System.out.println("输入格式错误：" + e.getMessage());
        }

        scanner.close();
    }
}
⚠️ Scanner使用建议
• 使用完Scanner后要调用close()方法
• nextInt()等方法后使用nextLine()前要先消费换行符
• 使用hasNextXxx()方法进行输入验证
• 对于可能出错的输入使用异常处理
• 一个程序中尽量只创建一个Scanner对象
🎯 实战练习：简单计算器
💻 综合练习：控制台计算器 
import java.util.Scanner;

public class SimpleCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("🧮 欢迎使用简单计算器！");
        System.out.println("支持运算：+ - * / %");
        System.out.println("输入 'quit' 退出程序");

        while (true) {
            try {
                // 📥 获取第一个数字
                System.out.print("\n请输入第一个数字（或输入quit退出）：");
                String input1 = scanner.nextLine();

                if ("quit".equalsIgnoreCase(input1)) {
                    System.out.println("👋 感谢使用，再见！");
                    break;
                }

                double num1 = Double.parseDouble(input1);

                // 📥 获取运算符
                System.out.print("请输入运算符 (+, -, *, /, %)：");
                String operator = scanner.nextLine();

                // 📥 获取第二个数字
                System.out.print("请输入第二个数字：");
                double num2 = Double.parseDouble(scanner.nextLine());

                // 🧮 执行计算
                double result = 0;
                boolean validOperation = true;

                switch (operator) {
                    case "+":
                        result = num1 + num2;
                        break;
                    case "-":
                        result = num1 - num2;
                        break;
                    case "*":
                        result = num1 * num2;
                        break;
                    case "/":
                        if (num2 == 0) {
                            System.out.println("❌ 错误：除数不能为零！");
                            validOperation = false;
                        } else {
                            result = num1 / num2;
                        }
                        break;
                    case "%":
                        if (num2 == 0) {
                            System.out.println("❌ 错误：除数不能为零！");
                            validOperation = false;
                        } else {
                            result = num1 % num2;
                        }
                        break;
                    default:
                        System.out.println("❌ 错误：不支持的运算符！");
                        validOperation = false;
                }

                // 📤 显示结果
                if (validOperation) {
                    System.out.printf("✅ 计算结果：%.2f %s %.2f = %.2f%n",
                                    num1, operator, num2, result);
                }

            } catch (NumberFormatException e) {
                System.out.println("❌ 错误：请输入有效的数字！");
            }
        }

        scanner.close();
    }
}

📝 本章小结

🎉 恭喜！你已经掌握了Java基础语法的核心内容！

✅ 学习成果检查清单

🎯 知识掌握情况
学习内容掌握程度检查方式
📝 Java语法规则✅ 已掌握能说出标识符命名规则
🔢 数据类型✅ 已掌握熟悉8种基本数据类型
📦 变量使用✅ 已掌握能正确声明和初始化变量
🔄 类型转换✅ 已掌握理解自动和强制转换
⚡ 运算符✅ 已掌握掌握各种运算符的使用
📥 输入输出✅ 已掌握能使用Scanner和System.out

🏆 技能成就解锁

📝 语法规范专家
掌握Java语法规则和命名约定
🔢 数据类型大师
熟练使用各种数据类型
⚡ 运算符专家
掌握所有运算符的使用
📥 输入输出能手
能够处理用户交互

🎯 核心知识点总结

📊 数据类型速查表
类型字节取值范围默认值示例
byte1-128 ~ 1270byte b = 100;
short2-32,768 ~ 32,7670short s = 1000;
int4-2^31 ~ 2^31-10int i = 100000;
long8-2^63 ~ 2^63-10Llong l = 100000L;
float4±3.4E±380.0ffloat f = 3.14f;
double8±1.7E±3080.0ddouble d = 3.14;
char20 ~ 65535‘\u0000’char c = 'A';
boolean-true/falsefalseboolean b = true;
⚡ 运算符优先级速记
🎯 运算符优先级（从高到低）
1. () [] .           - 括号、数组、成员访问
2. ++ -- ! ~         - 一元运算符
3. * / %             - 乘除取模
4. + -               - 加减
5. < <= > >=         - 关系运算
6. == !=             - 相等性判断
7. &&                - 逻辑与
8. ||                - 逻辑或
9. ?:                - 三元运算符
10. = += -= *= /=    - 赋值运算符
🔄 类型转换规则
🔼 自动类型转换路径
byte → short → int → long → float → double
  ↓      ↓      ↓      ↓       ↓
char ────────→ int → long → float → double

🔽 强制类型转换
目标类型 变量 = (目标类型) 源变量;

📋 实战练习作业

💪 实践出真知：通过练习巩固所学知识

🎯 基础练习（必做）

练习1：变量声明与初始化 ⭐⭐

// 声明并初始化各种类型的变量
// 包括：姓名、年龄、身高、是否为学生、成绩等

练习2：运算符综合应用 ⭐⭐⭐

// 编写程序计算：
// 1. 两个数的四则运算
// 2. 判断一个数是否为偶数
// 3. 比较三个数的大小

练习3：类型转换练习 ⭐⭐⭐

// 练习自动和强制类型转换
// 观察精度损失和数据溢出现象
🚀 进阶练习（选做）

练习4：用户信息管理系统 ⭐⭐⭐⭐

// 使用Scanner获取用户输入
// 包括：姓名、年龄、身高、体重
// 计算BMI指数并给出健康建议

练习5：数学计算器增强版 ⭐⭐⭐⭐⭐

// 在简单计算器基础上增加：
// 1. 历史记录功能
// 2. 更多数学函数（平方、开方等）
// 3. 错误处理和输入验证

🔍 常见错误与解决方案

❌ 常见错误类型
错误类型原因解决方案
变量未初始化使用未赋值的局部变量声明时初始化或使用前赋值
类型不匹配将大类型赋值给小类型使用强制类型转换
除零异常除数为0添加条件判断
数组越界访问不存在的数组索引检查数组长度
输入格式错误Scanner读取错误格式添加异常处理
🛠️ 调试技巧
🔧 调试建议
• 使用System.out.println()输出中间结果
• 检查变量的值和类型
• 逐步执行代码，定位问题所在
• 使用IDE的调试功能设置断点
• 阅读错误信息，理解错误原因

🗺️ 专栏学习路径图

📈 Java程序员从0到1成长路径
🎯 第一阶段：Java基础入门 (4-6周)
┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ 1.开发环境   │───▶│ 2.基础语法   │───▶│ 3.面向对象   │───▶│ 4.核心API   │
│   搭建      │    │             │    │   编程基础   │    │             │
│ ✅ 已完成    │    │ ✅ 已完成    │    │ 🎯 下一步    │    │ 📅 计划中    │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘

🚀 第二阶段：Java进阶技能 (4-6周)
┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ 1.高级特性   │    │ 2.I/O与网络  │    │ 3.新特性     │    │ 4.工具框架   │
│             │    │   编程      │    │             │    │   入门      │
│ 📅 计划中    │    │ 📅 计划中    │    │ 📅 计划中    │    │ 📅 计划中    │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘

🎯 第三阶段：项目实战 (4-8周)
┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ 1.小型项目   │    │ 2.Web开发    │    │ 3.Spring    │    │ 4.数据库与   │
│   开发      │    │   基础      │    │   框架入门   │    │   持久层    │
│ 📅 计划中    │    │ 📅 计划中    │    │ 📅 计划中    │    │ 📅 计划中    │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘

🏆 第四阶段：职业发展 (持续更新)
┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│ 1.代码质量   │    │ 2.开发工具   │    │ 3.面试准备   │    │ 4.职业规划   │
│   与规范    │    │   链        │    │             │    │             │
│ 📅 计划中    │    │ 📅 计划中    │    │ 📅 计划中    │    │ 📅 计划中    │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
📋 第一阶段学习进度
章节主要内容预计时间难度状态
📚 1.开发环境搭建JDK安装、Hello World、IDE使用1-2天⭐⭐✅ 已完成
📝 2.基础语法变量、数据类型、运算符、流程控制1周⭐⭐⭐✅ 已完成
🏗️ 3.面向对象基础类与对象、封装、继承、多态1-2周⭐⭐⭐⭐🎯 下一步
🔧 4.核心APIString、集合框架、异常处理1周⭐⭐⭐📅 计划中
🎯 当前进度
• 第一阶段进度：50% (2/4章节完成)
• 下一步：学习面向对象编程基础
• 建议：巩固基础语法，准备进入面向对象世界
• 重点：理解类与对象的概念，掌握封装原理

📚 推荐学习资源

🌟 在线资源
资源类型难度推荐指数
📖 Oracle Java教程官方教程⭐⭐⭐⭐⭐⭐⭐⭐
💻 菜鸟教程Java中文教程⭐⭐⭐⭐⭐⭐
🎥 慕课网Java课程视频教程⭐⭐⭐⭐⭐⭐⭐
📝 LeetCode Java练习编程练习⭐⭐⭐⭐⭐⭐⭐⭐⭐
📖 经典书籍
📚 推荐阅读
• 《Java核心技术 卷I》 - 基础知识全面覆盖
• 《Head First Java》 - 生动有趣的入门书籍
• 《Java编程思想》 - 深入理解Java设计理念
• 《Effective Java》 - Java最佳实践指南

🎬 下一章预告

🏗️ 第一阶段第3章：面向对象编程基础

🎯 下章学习内容

  • 🏗️ 面向对象编程概述与四大特性
  • 📦 类与对象的定义和使用
  • 🔒 封装、继承与多态的原理和应用
  • 🎯 抽象类与接口的设计和使用
  • 🛠️ 面向对象程序设计实践

📚 学习重点

  • 理解面向对象编程思想
  • 掌握类和对象的基本概念
  • 学会使用封装、继承、多态
  • 理解抽象类与接口的区别和应用
  • 能够设计简单的面向对象程序
🚀 准备好进入面向对象编程的世界了吗？

💡 学习小贴士

掌握了基础语法和流程控制，你已经具备了编程的基本能力！
接下来学习面向对象编程，这是Java编程的核心思想！

记住：从面向过程到面向对象是编程思维的重要转变！ 🌟

📧 有问题？欢迎在评论区讨论交流！
⭐ 觉得有用？别忘了点赞收藏！
🔄 继续关注，更多精彩内容即将到来！
收录于
Java程序员从0到1成长专栏

当前文章被收录于：

Java程序员从0到1成长专栏
11 篇文章 0 人学习

这是一个面向初学者的Java学习专栏，旨在帮助零基础的读者逐步成长为合格的Java开发工程师。专栏将采用循序渐进的方式，从基础语法到实际项目开发，覆盖Java程序员成长路径上的所有关键知识点

订阅专栏 查看详情
标签
#java #开发语言
本内容遵循 CC 4.0 BY-SA 版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
RSA与RC4加密算法深度对比：原理、安全实践与实战配置指南 加密算法是信息安全的核心基础，其设计原理直接决定了数据保护的强度与适用场景。非对称加密基于数学难题，如大整数分解，通过公钥与私钥的配对实现安全通信与身份认证；对称加密则依赖共享密钥，通过高效运算实现数据加解密。在工程实践中，算法的选择需平衡安全强度、性能开销与应用场景。RSA作为非对称加密的基石，在数字签名与密钥交换中仍扮演关键角色，但需关注密钥长度、填充方案等安全配置。而RC4作为曾广泛应用的流密码，因密钥流偏差等结构性缺陷，已被证实存在严重安全漏洞，现代安全实践要求全面禁用。本文聚焦RSA与RC4的深度 阅读详情

相关推荐

Java入门之~Java基础语法

Java入门之基础语法篇，收藏学起来

Ara-追着风跑 7712

黑马Java第一阶段：Java基础（基础篇笔记）

java

chen的博客 3481

Educoder-Java-第一阶段JAVA入门-java初体验知识点、答案汇总

Educoder-Java-第一阶段JAVA入门-java初体验知识点、答案汇总 第一关：Java第一课 1.编写第一个Java程序 （1）新建一个HelloWorld.java文件（新建HelloWorld.txt将后缀.txt改成.java就ok了 注意：Java对大小写敏感所以大小写不要弄错了哦，在本案例H和W都是大写）； （2）在文件中添加代码。 2.Java程序的编写执行流程： （1）将Java代码编写到扩展名为.java的文件中； （2）通过javac命令对该java文件进行编译； （3）通过j

qq_51430631的博客 4137

Java基础语法

1. Java概述 1.1 Java语言发展史 语言:人与人交流沟通的表达方式 计算机语言:人与计算机之间进行信息交流沟通的一种特殊语言 Java语言是美国Sun公司(Stanford University Network)在1995年推出的计算机语言 Java之父:詹姆斯·高斯林(James Gosling) 2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可:https://www.oracle.com 当前，我们课程使用的JDK版本:11.0 1.2 Java语言跨平台原理

terence的博客 10万+

Java基础入门

所谓跨平台指的是用Java语言开发的程序可以在多种操作系统上运行，常见的操作系统有Windows、Linux、MacOS系统。如果没有跨平台性，同一个应用程序，想要在多种操作系统上运行，需要针对各个操作系统单独开发应用。比如微信有Windows版本、MacOS版本、Android版本、IOS版本。

qq_58423640的博客 1万+

第一阶段：Java入门基础 | ⭐ Java基础语法

学习Java程序的基本结构、注释、关键字、标识符命名规则、数据类型、变量声明与初始化。这是写Java代码的"语法规则"，就像学英语要先学字母和语法一样重要。💭个人感悟：基础语法看似简单，但很多工作多年的老程序员也会在细节上翻车。所以，基础一定要打牢！不要觉得简单就跳过，每一个知识点都值得认真对待。🎯本章学习路线图📋 先浏览知识点清单，了解全貌🔧 跟着手把手教学步骤，逐一学习💻 运行代码示例，动手实践📝 完成练习题，检验学习效果🌟 挑选GitHub项目，进行实战。

m0_64027441的博客 400

java需要学习的基础语法

Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java Number类 Java Character类 Java String类 Java StringBuffer Java 数组 Java 日期时间 Java 正...

weixin_41719737的博客 1万+

【Java入门到精通】（二）Java基础语法（上）

本文介绍了Java编程基础中的变量、数据类型、运算符、流程控制、方法及数组等核心概念。变量是可操作的存储空间，需声明数据类型；Java数据类型分为基本类型和引用类型。运算符包括算术、赋值、关系、逻辑等类型。流程控制涵盖顺序、分支（if-else）和循环（while/for）结构。方法是对特定功能的代码封装，支持重载（同名不同参）。数组是固定长度的有序集合，通过索引访问元素。文章通过代码示例详细说明了各概念的使用方法，意在为Java初学者提供系统性的语法基础。

io_123io_123的博客 942

Java入门&IDEA&基础语法

但是，由于这种配置，只配置了较少的命令，而我们在JDK的bin目录下还有很多的命令可以使用，比如：jps,jpackage,jmap等。这里我们来讲解一下原理。有了它之后，我们就可以把变化的数据用一个变量存储，代码正常编写即可，如果需要修改数据，我们修改变量的值就可以了。在后续开发中，我们有些时候需要在DOS窗口，也就是我们前面见到的黑窗口下进行一些操作，所以，我们要掌握一些常用的操心命令。要开发一个Java程序，我们得安装JDK，而要安装JDK，我们得先有JDK，我们就可以进行Java程序的开发了，

是程序喵呀 1354

Java入门1: 基础语法

Java入门1: 基础语法

MangoGO的博客 859

【Python】快速入门Python一天学完基础语法

快速入门python 1. 数据类型与变量：元组、字典、拆包等 2. 基础运算与控制流程 3. 方法/函数、异常处理 4. 面向对象

CoderSharry的博客 2303

java基础语法（入门）

System.out.println("=====================total3不溢出===================");//输出-128，内存溢出，byte范围：-128-127。低-----------------------------------------------------→高。

weixin_49663593的博客 1391

java入门与基础语法

java入门及其基础语法

qq_74146366的博客 1140

Java 基础入门笔记：从 HelloWorld 到核心语法

具有特定含义，用户不能将其用作自定义标识符（如类名、变量名）。

2301_82132279的博客 881

黑马程序员——javase基础——day01——Java入门&IDEA&基础语法

下面我们正式进入Java的学习，在这里，大家第一个关心的问题，应该就是Java是什么，我们一起来看一下：Java是什么：Java是一门非常优秀的计算机语言语言：人与人交流沟通的表达方式计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言Java之父：詹姆斯·高斯林（James Gosling）知道了Java是什么之后，大家就会想，我们学完Java可以做什么呢？下面，我们就来聊一聊，Java的三大技术平台：JavaSEJavaMEJavaEE。

qq_56444564的博客 1910

java入门基础内容

如果在某次循环中执行了continue语句，那么本次循环就结束，即不再执行本次循环中循环体中continue语句后面的语句，而转入进行下一次循环。2）在cmd的根目录下输入javac Hello.Java语句执行文件，会生成一个class文件，接着执行java Hello语句执行编译文件就会自动的输出Hello word。对于二维数组，“数组名.length”的值是它含有的一维数组的个数。注：（1）“&&和||”同时使用的时候会出现短路的情况，如果左边已经得到了结果，那么右面的将不再执行。

Zmmm_11的博客 3434

Java笔记——Java基础入门

我想给大家说的是，写错代码都是很正常的，刚才有同学在使用IDEA编写程序时，可能会觉得字体比较小，背景色是黑色的，注释是灰色的，看不清，长时间可能对眼睛不好。讲完IDEA相关配置之后，接下来给大家讲一个很重要的IDEA的使用技巧，这就是IDEA的快捷键，所谓快捷键就是通过键盘上的按键组合起来，就可以帮我们生成代码。为了引导大家正确的完成IDEA的下载和安装，给小伙伴们单独提供了一个文档《IDEA安装、使用、配置.pdf》，文档中提供了IDEA详细的安装和使用步骤，大家只需要按照文档的步骤一步一步操作就行。

a25847a的博客 765

Java入门（一）——基础语法

（如果是主要编程Java系列的建议用IDEA、Eclipse，如果多种代码都有学习编程的话，可以选VS Code）每一个class当中都可以编写main方法，都可以设定程序的入口，想执行B.class中的main方法：java B。输入方法：java.util.Scanner s = new java.util.Scanner(System.in);，代表只能在该方法中使用，其他方法不知道这个变量，同时其他方法也可以用相同名字的局部变量名。在具体方法中声明则是。：指的是该该文件在Java项目中的逻辑地址。

qq_61562251的博客 911

Java学习路线第一阶段：java基础课程

Java学习路线第一阶段：java基础课程 Java的学习内容从计算机基本概念，DOS命令开始，为你入门编程语言扫盲，什么是程序，如何配置Java开发环境，Java编程的过程是怎样的，Java有什么物特点，程序是如何运行的，这些你都可以在这里得到答案。 Java编程的基础语法，共分为10个知识点，我们将学习变量，基本数据类型，进制，转义字符，运算符，分支语句和循环语句等，以达到训练基础语法和逻...

程序员日常 1938
上一篇： 第一阶段：Java基础入门①Java开发环境搭建
下一篇： 第一阶段：Java基础入门③面向对象编程基础
点赞 23
评论 1
书签 书签 20
代码哲学系
代码哲学系
博客等级 码龄1年 55粉丝 18原创
+ 关注 专栏目录 订阅专栏
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值