day01-java

Java标识符

规则

  • 组成元素：字母（A-Z, a-z）、数字（0-9）、下划线（_）、美元符（$）
  • 限制：
    • 不能以数字开头（如 1name 非法，name1 合法）
    • 不能是关键字（如 class、public 等）
    • 区分大小写（Name 和 name 是不同的标识符）

命名规范

  • 变量/方法名：小驼峰（如 studentName）
  • 类名：大驼峰（如 StudentInfo）
  • 常量名：全大写，下划线分隔（如 MAX_COUNT）

static 修饰符

作用

  • 静态变量（类变量）：所有对象共享同一份数据
  • 静态方法：可直接通过类名调用（无需创建对象）

示例

public class Example {
    static int count = 0;  // 静态变量
    
    public static void printMessage() {  // 静态方法
        System.out.println("Hello!");
    }
}

// 调用静态成员
Example.count = 10;
Example.printMessage();

final 修饰符

作用

  • 常量：值不可修改
  • final类：禁止继承（如 String 类）
  • final方法：禁止子类重写

示例

public class Constants {
    static final double PI = 3.14159;  // 常量（通常全大写命名）
}

// 错误示例：PI = 3.14;  // 编译报错，无法修改常量

注释

三种形式

  1. 单行注释：

    int age = 20;  // 这是单行注释

  2. 多行注释：

    /*
这是多行注释
可以跨多行
*/

  3. 文档注释（生成API文档）：

    /**
 * 计算两个数的和
 * @param a 第一个数
 * @param b 第二个数
 * @return 两数之和
 */
public int add(int a, int b) {
    return a + b;
}

Java基础数据类型

8种基本类型

类型 关键字 大小 取值范围 默认值 示例
字节型 byte 1字节 -128 ~ 127 0 byte b = 100;
短整型 short 2字节 -32768 ~ 32767 0 short s = 2000;
整型 int 4字节 -2^31 ~ 2^31-1 0 int i = 100000;
长整型 long 8字节 -2^63 ~ 2^63-1 0L long l = 100L;
单精度 float 4字节 ±3.4E+38（约6-7位小数） 0.0f float f = 3.14f;
双精度 double 8字节 ±1.7E+308（约15位小数） 0.0d double d = 3.14;
字符型 char 2字节 Unicode字符（如 'A'、'中'） '\u0000' char c = 'A';
布尔型 boolean 无明确大小 true/false false boolean flag = true;

类型转换

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

  • 规则：小类型 → 大类型（如 int → double）

  • 示例：

    int a = 10;
double b = a;  // 自动转换为 10.0

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

  • 语法：(目标类型)值

  • 注意：可能导致精度丢失或溢出

  • 示例：

    double x = 3.14;
int y = (int)x;  // y = 3（直接截断小数部分）

运算符

算术运算符

符号 说明
+、-、*、/、% 加减乘除取模
++、-- 自增：++a（先加再算）、a++（先算再加）

关系运算符

符号 说明
==、!=、>、<、>=、<= 判断大小，返回boolean

赋值运算符

符号 说明
= 赋值
+=、-=、/=、*=、%= a += 1 -> a = a + 1

逻辑运算符

符号 说明
& 同真为真，否则为假（两边都需要判断）
| 存在一个真就为真（两边都需要判断）
^ 相同false、不同true
! 取反

短路运算符

符号 说明
&& a&&b：a为假就不用判断b
|| a||b：a为真就不用判断b

三元运算符

符号 说明
关系表达式?表达式1:表达式2 a>b?a:b：前面为真，返回a，为假返回b

原码补码反码

十进制数字 原码 反码 补码
+0 0000 0000 0000 0000 0000 0000
-0 1000 0000 1111 1111 0000 0000
-1 1000 0001 1111 1110 1111 1111
-2 1000 0010 1111 1101 1111 1110
-3 1000 0011 1111 1100 1111 1101
-4 1000 0100 1111 1011 1111 1100
... ... ... ...
-126 1111 1110 1000 0001 1000 0010
-127 1111 1111 1000 0000 1000 0001
-128 无 无 1000 0000

说明：

  • 原码：最高位为符号位（0正1负），其余位为数值的绝对值。
  • 反码：正数与原码相同；负数符号位不变，其余位按位取反。
  • 补码：正数与原码相同；负数为反码加1（-128无原码和反码，直接用补码表示）。

位运算

1.2 位运算符概览

运算符 名称 示例 说明
& 按位与 a & b 两位同时为1时结果为1
` ` 按位或 a|b
^ 按位异或 a ^ b 两位不同时结果为1
~ 按位取反 ~a 所有位取反（包括符号位）
<< 左移位 a << n 左移n位，低位补0
>> 带符号右移 a >> n 右移n位，高位补符号位（0/1）
>>> 无符号右移 a >>>n 右移n位，高位补0

if

if(){}

if(){}
else{}

if(){}
else if(){}
...
else{}

swich

1. 基本模板

switch 语句根据表达式的值选择执行不同的代码分支。
语法示例：

switch (表达式) {
    case 值1:
        // 代码块1
        break;
    case 值2:
        // 代码块2
        break;
    default:
        // 默认代码块（可选）
}
  • 表达式类型：支持 int、char、String（Java 7+）、枚举（Java 5+）及包装类（如 Integer）。
  • 注意事项：
    • case 后的值必须与表达式类型一致。
    • default 分支处理未匹配的情况。

2. case 穿透

若 case 分支末尾没有 break，程序会继续执行后续分支的代码，直到遇到 break 或 switch 结束。
示例：

switch (num) {
    case 1:
        System.out.println("One"); // 无 break，穿透到 case 2
    case 2:
        System.out.println("Two");
        break;
}
  • 用途：
    • 多个 case 共享同一逻辑时，可省略重复代码。
  • 风险：
    • 意外穿透可能导致逻辑错误，需谨慎使用。

3. 新特性（Java 12+）

从 Java 12 开始，switch 支持更简洁的语法和表达式返回值。

① 箭头符号 ->

  • 使用 -> 代替 :，无需 break，自动退出分支。
  • 单行代码可直接写，多行代码用 {} 包裹。
    示例：
switch (变量) {
    case 值1 -> System.out.println("结果1");
    case 值2 -> {
        System.out.println("结果2");
        System.out.println("多行代码");
    }
    default -> System.out.println("默认结果");
}

② switch 表达式返回值

  • 可作为表达式直接赋值给变量。
  • 单值返回直接写，多行代码需用 yield 返回结果。
    示例：
String result = switch (变量) {
    case 值1 -> "结果1";
    case 值2 -> {
        // 多行操作
        yield "结果2"; // 必须显式使用 yield
    }
    default -> "默认结果";
};

③ 多值合并与模式匹配

  • 支持逗号分隔多个 case 值。
  • 支持类型模式匹配（Java 17+，需 instanceof 和强制转型）。
    示例：
switch (day) {
    case 1, 2, 3, 4, 5 -> System.out.println("工作日");
    case 6, 7 -> System.out.println("周末");
}

循环结构

1. 普通 for 循环

语法：

for (初始化; 条件; 迭代) {
    // 循环体
}

示例：

for (int i = 0; i < 5; i++) {
    System.out.println("i = " + i);
}

特点：

  • 明确循环次数：适合已知循环次数的场景。
  • 初始化、条件、迭代：可灵活控制循环流程。

2. 增强型 for 循环（foreach）

语法：

for (元素类型 变量 : 集合或数组) {
    // 使用变量访问元素
}

示例：

int[] numbers = {1, 2, 3};
for (int num : numbers) {
    System.out.println(num);
}

特点：

  • 遍历专用：简化数组或集合的遍历操作。
  • 只读性：不可直接修改集合结构（如删除元素），否则可能抛出 ConcurrentModificationException。

3. while 循环

语法：

while (条件) {
    // 循环体
}

示例：

int i = 0;
while (i < 3) {
    System.out.println("i = " + i);
    i++;
}

特点：

  • 条件驱动：适合循环次数未知但需满足条件时使用。
  • 先判断后执行：若初始条件不满足，循环体可能一次也不执行。

4. do-while 循环

语法：

do {
    // 循环体
} while (条件);

示例：

int j = 0;
do {
    System.out.println("j = " + j);
    j++;
} while (j < 0); // 条件不成立，但仍执行一次

特点：

  • 至少执行一次：先执行循环体，再判断条件。
  • 适合场景：需要至少执行一次操作，例如输入验证、菜单选择等。

5. 循环控制语句

  • break：立即终止当前循环。

    for (int i = 0; i < 10; i++) {
    if (i == 5) break; // 当 i=5 时退出循环
    System.out.println(i);
}

  • continue：跳过当前循环的剩余代码，进入下一次迭代。

    for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) continue; // 跳过偶数
    System.out.println(i);
}

6. 注意事项与最佳实践

  1. 避免无限循环：

    • while 和 do-while 需确保条件最终会变为 false。
    int k = 0;
while (k < 5) { // 若忘记写 k++，会导致无限循环
    System.out.println(k);
    k++;
}

  2. 增强型 for 循环的限制：

    • 不可直接修改集合结构（如删除元素），需改用迭代器或普通 for 循环。

  3. 选择循环类型：

    • 已知次数 → 普通 for。
    • 遍历集合 → 增强型 for。
    • 条件驱动且次数未知 → while。
    • 至少执行一次 → do-while。

随机数

Java 中生成随机数的常用方法主要有两种：Math.random() 和 Random 类。以下分别说明其用法及如何生成不同范围的随机数。

1. Math.random() 方法

  • 功能：生成 [0.0, 1.0) 之间的 double 类型随机数。

  • 范围控制：

    • 整数范围：通过缩放和类型转换生成指定范围的整数。

    • 通用公式：

      (int)(Math.random() * (max - min + 1)) + min;

示例代码：

// 生成 [0, 9] 的整数
int num1 = (int)(Math.random() * 10);

// 生成 [5, 14] 的整数
int num2 = (int)(Math.random() * 10) + 5;

// 生成 [0.0, 5.0) 的浮点数
double num3 = Math.random() * 5;

// 生成 [3.5, 8.5) 的浮点数
double num4 = Math.random() * 5 + 3.5;

2. Random 类

  • 功能：提供更灵活的随机数生成方法（整数、浮点数、布尔值等）。
  • 步骤：
    1. 创建 Random 对象：Random random = new Random();
    2. 调用方法生成随机数。

常用方法：

方法 范围 示例
nextInt() 所有 int 范围（含负数） random.nextInt()
nextInt(int bound) [0, bound) 的整数 random.nextInt(10) → 0-9
nextDouble() [0.0, 1.0) 的浮点数 random.nextDouble()
nextBoolean() true 或 false random.nextBoolean()

范围控制示例：

// 生成 [0, 9] 的整数
int num5 = random.nextInt(10);

// 生成 [5, 14] 的整数
int num6 = random.nextInt(10) + 5;

// 生成 [1, 10] 的整数
int num7 = random.nextInt(10) + 1;

// 生成 [2.5, 7.5) 的浮点数
double num8 = random.nextDouble() * 5 + 2.5;

3. 其他场景

  • 生成不重复的随机数：
    使用 Set 集合去重，例如：

    Set<Integer> set = new HashSet<>();
while (set.size() < 5) {
    set.add(random.nextInt(20) + 1); // 生成 5 个 [1, 20] 的不重复数
}

  • 线程安全的随机数（Java 7+）：
    使用 ThreadLocalRandom：

    int num9 = ThreadLocalRandom.current().nextInt(1, 11); // [1, 10]

  • 密码学安全的随机数：
    使用 SecureRandom（适用于加密场景）：

    SecureRandom secureRandom = new SecureRandom();
int num10 = secureRandom.nextInt(100); // [0, 99]

4. 注意事项

  1. 包含边界：

    • Math.random() * n 生成 [0.0, n) 的浮点数，强转为 int 后得到 [0, n-1]。
    • Random.nextInt(n) 生成 [0, n-1] 的整数。

  2. 种子控制：

    • 设置种子可生成可重复的随机数序列：

      Random random = new Random(123); // 固定种子 123

  3. 性能优化：

    • 避免频繁创建 Random 对象，尽量复用同一个实例。
posted @ 2025-03-16 21:19  咋还没来  阅读(38)  评论(0)    收藏  举报