跳转至

Java基础语法

📖 章节简介

本章将介绍Java的基础语法，包括变量、数据类型、运算符和类型转换。

Java基础语法知识图谱

上图梳理了本章核心模块：变量与类型、运算符、类型转换和引用类型。

📦 变量与数据类型

1. 变量声明

Java
// 变量声明
public class Variables {
    public static void main(String[] args) {
        // 声明并初始化
        int age = 25;
        String name = "张三";
        double price = 99.99;
        boolean isStudent = true;

        // 先声明后初始化
        int score;
        score = 95;

        // 常量（final）
        final int MAX_SCORE = 100;
        final double PI = 3.14159;

        System.out.println("姓名: " + name);
        System.out.println("年龄: " + age);
        System.out.println("价格: " + price);
        System.out.println("是否学生: " + isStudent);
    }
}

2. 基本数据类型

Java
// 基本数据类型
public class PrimitiveTypes {
    public static void main(String[] args) {
        // 整数类型
        byte byteVar = 127;           // 8位，-128到127
        short shortVar = 32767;       // 16位，-32768到32767
        int intVar = 2147483647;      // 32位，-2^31到2^31-1
        long longVar = 9223372036854775807L; // 64位，-2^63到2^63-1

        // 浮点类型
        float floatVar = 3.14f;       // 32位，单精度
        double doubleVar = 3.141592653589793; // 64位，双精度

        // 字符类型
        char charVar = 'A';            // 16位Unicode字符

        // 布尔类型
        boolean booleanVar = true;      // true或false

        System.out.println("byte: " + byteVar);
        System.out.println("short: " + shortVar);
        System.out.println("int: " + intVar);
        System.out.println("long: " + longVar);
        System.out.println("float: " + floatVar);
        System.out.println("double: " + doubleVar);
        System.out.println("char: " + charVar);
        System.out.println("boolean: " + booleanVar);
    }
}

3. 引用数据类型

Java
// 引用数据类型
public class ReferenceTypes {
    public static void main(String[] args) {
        // 字符串
        String str1 = "Hello";
        String str2 = new String("World");

        // 数组
        int[] numbers = {1, 2, 3, 4, 5};
        String[] names = new String[3];
        names[0] = "张三";
        names[1] = "李四";
        names[2] = "王五";

        // 类
        Person person = new Person("张三", 25);

        System.out.println("str1: " + str1);
        System.out.println("str2: " + str2);
        System.out.println("numbers: " + java.util.Arrays.toString(numbers));
        System.out.println("person: " + person);
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

🔢 运算符

1. 算术运算符

Java
// 算术运算符
public class ArithmeticOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;

        // 加减乘除
        System.out.println("a + b = " + (a + b));  // 13
        System.out.println("a - b = " + (a - b));  // 7
        System.out.println("a * b = " + (a * b));  // 30
        System.out.println("a / b = " + (a / b));  // 3（整数除法）
        System.out.println("a % b = " + (a % b));  // 1（取余）

        // 自增自减
        int x = 5;
        System.out.println("x++ = " + x++);  // 5（先使用后增加）
        System.out.println("++x = " + ++x);  // 7（先增加后使用）
        System.out.println("x-- = " + x--);  // 7（先使用后减少）
        System.out.println("--x = " + --x);  // 5（先减少后使用）
    }
}

2. 关系运算符

Java
// 关系运算符
public class RelationalOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        System.out.println("a == b: " + (a == b));  // false
        System.out.println("a != b: " + (a != b));  // true
        System.out.println("a > b: " + (a > b));    // false
        System.out.println("a < b: " + (a < b));    // true
        System.out.println("a >= b: " + (a >= b));  // false
        System.out.println("a <= b: " + (a <= b));  // true
    }
}

3. 逻辑运算符

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

        // 逻辑与（&&）：两个都为true才为true
        System.out.println("a && b: " + (a && b));  // false

        // 逻辑或（||）：有一个为true就为true
        System.out.println("a || b: " + (a || b));  // true

        // 逻辑非（！）：取反
        System.out.println("!a: " + (!a));          // false

        // 短路求值
        int x = 10;
        boolean result = (x > 5) && (++x < 20);
        System.out.println("result: " + result);  // true
        System.out.println("x: " + x);          // 11（由于第一个条件为真，++x被执行了）
    }
}

4. 位运算符

Java
// 位运算符
public class BitwiseOperators {
    public static void main(String[] args) {
        int a = 5;  // 二进制：101
        int b = 3;  // 二进制：011

        // 按位与（&）：对应位都为1才为1
        System.out.println("a & b = " + (a & b));  // 1（001）

        // 按位或（|）：对应位有一个为1就为1
        System.out.println("a | b = " + (a | b));  // 7（111）

        // 按位异或（^）：对应位不同为1
        System.out.println("a ^ b = " + (a ^ b));  // 6（110）

        // 按位取反（~）：所有位取反
        System.out.println("~a = " + (~a));       // -6

        // 左移（<<）：各位左移，右边补0
        System.out.println("a << 1 = " + (a << 1));  // 10（1010）

        // 右移（>>）：各位右移，左边补符号位
        System.out.println("a >> 1 = " + (a >> 1));  // 2（010）

        // 无符号右移（>>>）：各位右移，左边补0
        System.out.println("a >>> 1 = " + (a >>> 1)); // 2（010）
    }
}

🔄 类型转换

1. 自动类型转换

Java
// 自动类型转换（隐式转换）
public class AutomaticTypeConversion {
    public static void main(String[] args) {
        // 小类型到大类型自动转换
        byte b = 10;
        short s = b;      // byte -> short
        int i = s;        // short -> int
        long l = i;       // int -> long
        float f = l;      // long -> float
        double d = f;      // float -> double

        System.out.println("byte: " + b);
        System.out.println("short: " + s);
        System.out.println("int: " + i);
        System.out.println("long: " + l);
        System.out.println("float: " + f);
        System.out.println("double: " + d);

        // 表达式中的自动提升
        int x = 10;
        double y = 3.14;
        double result = x + y;  // int自动提升为double
        System.out.println("result: " + result);
    }
}

2. 强制类型转换

Java
// 强制类型转换（显式转换）
public class ExplicitTypeConversion {
    public static void main(String[] args) {
        // 大类型到小类型需要强制转换
        double d = 3.14;
        int i = (int) d;  // double -> int，丢失小数部分
        System.out.println("int: " + i);  // 3

        // 可能导致精度损失或溢出
        long l = 10000000000L;
        int j = (int) l;  // 可能溢出
        System.out.println("int: " + j);  // 1410065408（溢出）

        // 字符与数字的转换
        char c = 'A';
        int ascii = (int) c;  // char -> int
        System.out.println("ASCII: " + ascii);  // 65

        int num = 66;
        char ch = (char) num;  // int -> char
        System.out.println("char: " + ch);  // B
    }
}

💡 最佳实践

1. 变量命名

Java
// 变量命名最佳实践
public class VariableNaming {
    public static void main(String[] args) {
        // ✅ 好的命名
        int studentAge = 20;
        String userName = "张三";
        boolean isVip = true;
        final int MAX_COUNT = 100;

        // ❌ 不好的命名
        int a = 20;           // 不明确
        String s = "张三";       // 太短
        boolean flag = true;     // 不具体
        final int n = 100;      // 无意义
    }
}

2. 常量定义

Java
// 常量定义最佳实践
public class Constants {
    // 常量使用全大写，下划线分隔
    public static final int MAX_AGE = 120;
    public static final double PI = 3.141592653589793;
    public static final String DEFAULT_NAME = "匿名用户";
    public static final int CONNECTION_TIMEOUT = 30000; // 毫秒

    // 枚举常量
    public enum Status {
        ACTIVE, INACTIVE, PENDING, DELETED
    }

    public static void main(String[] args) {
        System.out.println("最大年龄: " + MAX_AGE);
        System.out.println("圆周率: " + PI);
        System.out.println("默认名称: " + DEFAULT_NAME);
        System.out.println("状态: " + Status.ACTIVE);
    }
}

📝 练习题

基础题

  1. Java有哪些基本数据类型？
  2. 如何声明和初始化变量？
  3. Java的运算符有哪些？

进阶题

  1. 理解类型转换的规则。
  2. 使用位运算符实现快速计算。
  3. 设计合理的常量定义。

实践题

  1. 编写一个计算器程序。
  2. 实现单位转换功能。
  3. 创建一个简单的数据统计程序。

📚 推荐阅读

🔗 下一章

控制流程 - 学习Java的条件语句和循环语句。