Klein's-blue的博客

记录生活，分享技术

0%

Java基础

（注释、 标识符和关键字、 数据类型讲解、 数据类型扩展、 类型转换、 变量常量作用域、 基本运算符、 自增自减、 逻辑运算符、 位运算符、 三元运算符、 包机制）

注释

  • 注释是代码中用于解释说明的部分，不会影响程序的执行。Java 支持三种类型的注释：

单行注释

  • 使用//开头，直到行尾结束
  • 适用于简短说明
1
2
// 这是一个单行注释
int x = 10; // 变量 x 的初始化

多行注释

  • 使用/*开头， */结束
  • 适用于多行说明或临时屏蔽代码
1
2
3
4
/*
这是一个多行注释
可以跨越多行
*/

文档注释

  • 使用/**开头， */结束
  • 用于生成API文档，支持标签如@param、 @return等
  • 常用于类、方法、字段的描述
1
2
3
4
5
6
7
8
9
/**
 * 这是一个加法方法
 * @param a 第一个加数
 * @param b 第二个加数
 * @return 两个数的和
 */
public int add(int a, int b) {
    return a + b;
}

标识符和关键字

标识符

标识符是用户自定义的名称，用于命名变量、类、方法等。规则：

  • 由字母、数字、下划线_或者美元符号$组成
  • 第一个字符不能是数字
  • 区分大小写
  • 不能使用Java关键字
  • 长度无限制，但是建议简短有意义
  • 命名规范：驼峰式(camelCase)用于变量/方法；帕斯卡式(PascalCase)用于类。
1
2
3
4
5
有效：
myVariable、 userName、 MAX_VALUE、 _$test

无效：
2abc(数字开头)、 my-var(连字符)、 class(关键字)

关键字

关键字是Java语言预定义的保留字，有特殊含义，不能用作标识符。常见关键字包括：

  • 数据类型： byte、short、int、long、float、double、char、boolean
  • 控制流：if、else、switch、case、for、while、do、break、continue、return
  • 类/接口：class、interface、extends、implements、abstract、final、static、private、protected
  • 异常：try、catch、finally、throw、throws
  • 其他：void、new、this、super、instanceof、synchronized、volatile、transient、enum、assert、strictfp 
1
int int = 10; // 错误：int是关键字，不能用作变量名

数据类型

Java是强类型语言，所有变量必须先声明类型。数据类型分为两大类：基本数据类型和引用类型。

基本数据类型

  • 直接存储值，效率高
  • 8种基本数据类型

位是最小的数据存储单位(bit) : 11001100是一个八位二进制数
字节(byte): 是计算机中数据处理的基本单位，一般使用B来表示
1B(byte, 字节) = 8bit(位)

32位的电脑和64位的电脑：32位的电脑只能使用32位的CPU，64位的电脑既能使用64位的也能使用32位的，区别在于二者之间的寻址能力，32位只能使用4GB内存，64位最大能使用128GB的内存

1
2
3
4
5
6
7
8
byte    整数(有符号)    1字节   0       -128 ~ 127
short   整数(有符号)    2字节   0       -32768 ~ 32767
int     整数(有符号)    4字节   0       -2^31 ~ 2^31-1
long    整数(有符号)    8字节   0L      -2^63 ~ 2^63-1
float   单精度浮点数    4字节   0.0f    约±3.4E38
double  双精度浮点数    8字节   0.0d    约±1.7E308
char    单个Unicode字符 2字节   ''      ''~'\uffff'
boolean 真/假           1位     false   true/false
1
2
3
4
int age = 25; // int 类型
double salary = 5000.5; // double类型
char gender = 'M'; // char类型，用单引号
boolean isStudent = true;

引用类型

  • 存储对象的引用(地址), 如类、接口、数组、String等
  • 默认值：null
  • 示例：String name = "abc";（String是引用类型，但常像基本类型使用）
    注意：基本类型在栈中存储，引用类型在堆中。

数据类型拓展

整数拓展

  • 支持二进制(Ob前缀)、八进制(0前缀)、十六进制(0x前缀)
    1
    2
    3
    int binary = 0b1010; // 二进制 10
    int octal = 012; // 八进制 10
    int hex = 0xA; // 十六进制 10

浮点数拓展

  • float用f/F后缀，double用d/D
  • 浮点数有精度问题，避免用于精确计算
    1
    2
    3
    float f = 3.14f; 
    double d = 3.14;
    System.out.println(0.1 + 0.2); // 精度丢失

字符拓展

  • char是Unicode, 支持转义序列(如 \n、 \t)
  • ASCII值：A=65，a=97
    1
    2
    char c1 = 'A';
    char c2 = '\u0041'; // Unicode 等价于 'A'

布尔拓展

  • 仅true/false, 不能转换为整数
  • 用于条件判断

包装类

  • 基本类型的对象形式：Integer、Double等，用于集合或需要对象时
  • 自动装箱/拆箱：Integer i = 10;(自动装箱)

类型转换

类型转换用于不同类型间赋值或运算。分为自动转换(隐式)和强制转换(显示)。

自动类型转换

  • 低精度-高精度：byte -> short -> int -> long -> float -> double
  • char可以转int
    1
    2
    int i = 10;
    double d = i; // int自动转为double

强制类型转换

  • 高精度 -> 低精度，可能丢失精度或溢出
  • 语法：(目标类型)值
    1
    2
    double d = 3.14;
    int i = (int) d; // i等于3，丢失小数

注意：

  • boolean 不能转换
  • 对象类型需instanceof检查
  • 运算中：低类型自动提升到高类型(如 byte + int -> int)

变量、常量和作用域

变量

  • 声明：类型 变量名 = 值
  • 分类：
    1. 局部变量：方法内声明，必须初始化
    2. 实例变量：类中声明，默认值（如 int是0）
    3. 类变量(static)：类中static声明，共享于所有实例，默认值
1
2
3
4
5
6
7
8
public class Test {
    int instanceVar; // 实例变量
    static int classVar; // 类变量

    public void method() {
        int localVar = 10; // 局部变量
    }
}

常量

  • 使用final修饰，不可修改
  • 命名：全大写 + 下划线 (如 MAX_VALUE)
1
2
final double PI = 3.14159;
PI = 3.14; // 错误：不能修改

作用域

  • 块级作用域：{}内有效果
  • 方法作用域：方法内
  • 类作用域：类内
    局部变量只能在方法内可见，实例变量在类内可见
  • 注意：变量名不能重复在同一作用域

基本运算符

运算符用于操作变量/常量。优先级：() > 一元 > 算术 > 移位 > 关系 > 位 > 逻辑 > 赋值

算术运算符

  • +加法、-减法、*乘法、/整除、%取余
1
2
3
int a = 10, b = 3;
int sum = a + b; // 13
int mod = a % b; // 取余数 1

关系运算符

  • == 等于、!= 不等于、> 大于 、< 小于、>=大于等于、<=小于等于
  • 返回boolean值
  • 示例：a > b -> true

赋值运算符

  • =简单赋值、+=、-=、*=、/=、%=符合赋值
  • 示例：a += 5;等价于a = a + 5;

自增自减

  • ++ 自增1、–自减1
  • 前缀(++a): 先增/减，再使用。 
    1
    2
    3
    4
    5
    6
    7
    8
    9
    int a = 10;
    int b = ++a;

    等价于

    int a = 10;
    a = a + 1;
    int b = a + 1;

  • 后缀(a++): 先使用，再增/减。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    int a = 10;
    int b = a++;

    等价于

    int a = 10;
    int b = a + 1;
    a = a + 1;

1
2
3
int x = 5;
int y = ++x; // y = 6, x = 6
int z = x++; // z = 6, x = 7
  • 注意：仅适用于数值类型，常用于循环

逻辑运算符

用于boolean值间的逻辑操作，返回boolean

  • && 逻辑与 (短路： 左false则不执行右)
  • || 逻辑或 (短路： 左true则不执行右)
  • ! 逻辑非，取反
1
2
3
4
boolean a = true, b = false;
boolean and = a && b; // false
boolean or = a || b; // true
boolean not = !a; // false

注意：短路特性可优化代码，避免空指针等错误。

位运算符

按二进制位操作，效率高，常用于底层优化。

  • & 按位与、| 按位或、^ 按位异或、~ 按位取反
  • << 左移(乘2^n)、>>右移(除2^n，有符号)、>>> 无符号右移
    1
    2
    3
    4
    5
    6
    int a = 5; // 二进制 101
    int b = 3; // 二进制 011
    int and = a & b; // 001 -> 2^0 -> 1
    int or = a | b; // 111 -> 2^2 + 2^1 + 2^0 -> 7
    int xor = a ^ b; // 110 -> 2^2 + 2^1 -> 6
    int left = a << 1; // 101 << 1 -> 1010 -> 2^3 + 2^1 -> 10

    注意：~是反码，负数需注意补码表示

三元运算符

也称为条件运算符，语法：条件 ? 真值 : 假值

  • 简洁替代if-else
    1
    int max = (a > b) ? a : b; // 如果 a > b, 返回 a, 否则 b

    注意：真值和假值类型需一致或兼容。可嵌套，但是切勿过长使用

包机制

包(Package) 用于组织类，防止命名冲突，像文件目录。

声明包

  • 第一行: package 包名
  • 包名：全小写 + 点分隔(如： com.example.utils)
    1
    2
    3
    4
    5
    package com.example;

    public class Hello {
        // ...
    }

导入包

  • 使用import导入其他包的类
    1
    2
    import com.example.Hello; // 导入单个类
    import com.example.*; // 导入包下所有的类(慎用， 容易引起冲突)

包的注意事项

  • 类全限定名：包名.类名(如： java.lang.String)
  • java.lang包自动导入(如： String、 System)
  • 多包项目：使用IDEA管理，编译时需 -d 指定输出目录
  • 访问控制：结合public/private/protected等修饰符
    1
    2
    3
    4
    src/
      com/
        example/
          Hello.java  // package com.example;
    通过包机制，实现模块化开发。