杏仁海棠花饼的Java学习日记第四天

一，前言

今天就是第四天了，继续接着昨天的往下进行。

二，Java基础语法续

1.逻辑运算符，位运算符

（1）逻辑运算符

逻辑运算符主要用于布尔表达式的计算，常用于条件判断和循环控制。Java 中的逻辑运算符包括：

• &&（逻辑与）：当且仅当两个操作数都为 true 时，结果才为 true。

• ||（逻辑或）：只要两个操作数中有一个为 true，结果就为 true。

• !（逻辑非）：对操作数取反，true 变为 false，false 变为 true

• &（非短路与）：与 && 类似，但会计算两边的表达式。

• |（非短路或）：与 || 类似，但会计算两边的表达式。

• ^（逻辑异或）：当两个操作数不同时，结果为 true。

在 Java 中，短路特性是逻辑运算符（&& 和 ||）的重要特性，它允许表达式在确定结果后停止计算剩余部分，从而提高效率并避免潜在的错误。

例如，&&（短路与）的短路特性

• 规则：当且仅当所有操作数都为 true时，结果才为 true。若第一个操作数为false，则直接返回 false，不再计算后续操作数。

• 作用：避免不必要的计算，尤其是当后续操作数包含方法调用或复杂表达式时。

package Study;
​
public class demo02 {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        
        // 逻辑与
        System.out.println(a && b); // 输出 false
        
        // 逻辑或
        System.out.println(a || b); // 输出 true
        
        // 逻辑非
        System.out.println(!a);    // 输出 false
        
        // 非短路与
        System.out.println(a & b);  // 输出 false
        
        // 非短路或
        System.out.println(a | b);  // 输出 true
        
        // 逻辑异或
        System.out.println(a ^ b);  // 输出 true
    }
}
​

​

输出结果：

（2）位运算符

位运算符用于对整数类型（如 int、long 等）的二进制位进行操作。Java 中的位运算符包括：

• &（按位与）：对两个操作数的对应位进行逻辑与运算。

• |（按位或）：对两个操作数的对应位进行逻辑或运算。

• ^（按位异或）：对两个操作数的对应位进行逻辑异或运算。

• ~（按位取反）：对操作数的每一位取反。

• <<（左移）：将左操作数的二进制位向左移动右操作数指定的位数。

• >>（右移）：将左操作数的二进制位向右移动右操作数指定的位数，符号位保持不变。

• >>>（无符号右移）：将左操作数的二进制位向右移动右操作数指定的位数，符号位也被移动。

例如:

public class Demo03 {
public static void main(String[] args) {
    /*
     * A = 0011 1100
​
B = 0000 1101
​
-------------------------------------------------------------------------------
​
A&B = 0000 1100
​
A|B = 0011 1101
​
A^B = 0011 0001
​
~B = 1111 0010
​
<<      就相当于    *2
​
>>      就相当于    /2
位运算效率极高！！！！！
     */
}
}

（3）赋值运算符

运算符	等价形式	示例
+=	a = a + b	a += 5 等价于 a = a + 5
-=	a = a - b	a -= 3 等价于 a = a - 3
*=	a = a * b	a *= 2 等价于 a = a * 2
/=	a = a / b	a /= 4 等价于 a = a / 4
%=	a = a % b	a %= 3 等价于 a = a % 3

（4）补充：字符串连接符 ‘+’

在编程里，字符串连接符的作用是把多个字符串合并成一个新的字符串。

注意：

连接符在前面和在后面是不同的，

 int a = 10;
    int b = 20;
System.out.println(""+a+b);
System.out.println(a+b+"");

输出结果。

1020
30

（5）三元运算符

在编程中，三元运算符（Ternary Operator）是一种简洁的条件表达式，用于根据条件的真假返回不同的值。它可以替代简单的 if-else 语句，使代码更紧凑。

例如：

  // x ? y : z
    // x为true，返回y，否则返回z
    int score = 80;
    String result = score > 60 ? "及格" : "不及格";
    System.out.println(result);

这段代码的输出结果就是及格。

（6）包机制

在编程中，包机制（Package System） 是一种组织代码的方式，用于将相关的类、模块或文件分组管理，避免命名冲突，提高代码的可维护性和复用性。

包本质上就是文件夹

包的名字一般利用公司域名倒置作为包名。

如果要使用其他包的类需要导包，使用import来实现

import com.example.util.MathUtils;  // 导入特定类
​
public class Main {
    public static void main(String[] args) {
        int result = MathUtils.add(1, 2);
    }
}

import com.example.util.*;  // 导入包下所有类

就是写成.* 就可以，叫做通配符。

（7）JavaDoc

API（Application Programming Interface） 即应用程序编程接口，是一组定义了软件组件之间如何交互的规则和协议。它允许不同的软件系统通过预先定义的方式相互通信，而无需关心对方的内部实现细节。以下是关于 API 的详细解释：

Java在线API帮助文档

JavaDoc 是 Java 提供的一种工具，用于从源代码中的特殊注释生成 API 文档。这些注释称为 Doc 注释，以 /** 开头，以 */ 结尾，可包含描述、参数、返回值等信息。生成的文档通常以 HTML 格式呈现，方便开发者查阅。

1. Doc 注释的基本格式

JavaDoc 注释可置于类、方法、字段上方，支持多种标签：

2. 常用 JavaDoc 标签

标签	作用
@param	描述方法参数（格式：@param 参数名 描述）。
@return	描述方法返回值（仅用于有返回值的方法）。
@throws	描述方法可能抛出的异常（或使用 @exception）。
@author	指定类的作者（可多次使用，列出多个作者）。
@version	指定版本号（如 @version 1.0.0）。
@since	指定最早使用的版本（如 @since 1.8）。
@see	引用其他类或方法（如 @see AnotherClass#anotherMethod）。
@deprecated	标记已过时的类或方法（需说明替代方案）。
{@link}	内联引用其他类或方法（如 {@link AnotherCla

public class Doc {
/**
 * 类的概述描述...
 * 类的详细描述...
 * 
 * @author 作者名
 * @version 版本号
 * @since 指定最早使用的版本
 */
    /**
     * 字段的描述信息
     */
    private int myField;
    /**
     * 
     * @param param1 参数1的描述
     * @param param2 参数2的描述
     * @return 返回值的描述
     * @throws ExceptionType 异常描述
     */
    public void myMethod(int param1, String param2) throws ExceptionType {
        // 方法实现
    }
}

3. 生成 JavaDoc 文档

使用 javadoc 命令从命令行生成文档：

可以在命令行中使用javadoc命令生成文档

生成之后就是这样的，这个是秦疆老师生成的借用一下。

里面的一些具体内存后面在慢慢学，除了使用命令行生成之外还可以使用其他的IDE来生成，比如IEDA，Eclipse。

JavaDoc 是编写高质量 Java 代码的重要工具，它通过规范化的注释生成清晰、易用的 API 文档，帮助开发者理解和使用代码。合理使用 JavaDoc 标签和最佳实践，可以显著提升项目的可维护性和协作效率。

三，Java流程控制

至此我们就开始了Java流程控制的学习。

1.用户交互Scanner类

关于 “Java Scanner”，它是 Java 标准库中用于处理用户输入的一个实用类，属于 java.util 包。

1、Scanner 类的作用

• 读取用户输入：从标准输入流（如键盘）或文件、字符串中解析基本数据类型（如 int、double）或字符串。

• 格式化输入处理：支持按指定分隔符（默认是空格）拆分输入内容，方便逐个读取数据。

2、基本使用步骤

1. 导入 Scanner 类

import java.util.Scanner; // 导入 java.util 包中的 Scanner 类

2. 创建 Scanner 对象

• 从键盘读取输入：

Scanner scanner = new Scanner(System.in); // System.in 表示标准输入流（键盘）

3. 读取输入数据

Scanner 提供了多种 nextXXX() 方法用于读取不同类型的数据：

方法	说明
next()	读取输入中的下一个 单词（以空格、回车等分隔符为结束标志）。
nextLine()	读取输入中的 整行内容（包括空格，以回车为结束标志）。
nextInt()	读取一个整数。
nextDouble()	读取一个浮点数。
nextBoolean()	读取一个布尔值（true 或 false）。
hasNext()	判断是否还有未读取的输入数据（返回布尔值）。
hasNextInt()	判断下一个输入是否为整数（返回布尔值），可用于数据校验。

示例：

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

        // 读取整数
        System.out.print("请输入年龄：");
        int age = scanner.nextInt();
      scanner.nextLine(); // 消耗掉换行符（避免影响后续 nextLine() 的读取）

其他的数据类型同理。

3.注意事项

1.输入缓冲区问题：

当 nextInt()、nextDouble() 等方法读取完数据后，输入流中会残留 换行符（\n），若后续使用 nextLine()，需先用 nextLine() 消耗掉残留的换行符，避免直接读取空行。

示例：

scanner.nextInt(); // 读取整数后，残留换行符
scanner.nextLine(); // 先调用一次，消耗换行符
String str = scanner.nextLine(); // 再读取字符串

2.资源释放：使用完毕后需调用 scanner.close() 关闭 Scanner，释放占用的资源（尤其是读取文件时）。

2.顺序结构

Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句的执行，顺序结构是最简单的算法结构。

语句与语句之间，框与框之间都是按照从上往下的顺序进行的，它是由若干个依次执行的处理步骤组成的，他是任何一个算法都离不开的一种基本算法结构。

3.选择结构

编程中，选择结构（也称为条件结构）用于根据条件判断来执行不同的代码分支。它是程序实现逻辑决策的基础，主要通过 if-else、switch 等语句实现。

一、if-else 结构

根据条件表达式的结果（true 或 false）选择执行不同的代码块。

1. 基本 if 语句

if (条件表达式) {
    // 条件为 true 时执行的代码
}

2. if-else 语句

if (条件表达式) {
    // 条件为 true 时执行的代码
} else {
    // 条件为 false 时执行的代码
}

3. if-else if-else 多分支

if (条件1) {
    // 条件1为 true 时执行
} else if (条件2) {
    // 条件2为 true 时执行
} else {
    // 所有条件都为 false 时执行
}

示例：根据分数判断等级

int score = 85;
if (score >= 90) {
    System.out.println("等级：A");
} else if (score >= 80) {
    System.out.println("等级：B");
} else if (score >= 70) {
    System.out.println("等级：C");
} else {
    System.out.println("等级：D");
}

二、嵌套 if-else

在一个 if-else 结构中嵌套另一个 if-else，用于更复杂的条件判断。

示例：判断年份是否为闰年

int year = 2024;
if (year % 4 == 0) {
    if (year % 100 == 0) {
        if (year % 400 == 0) {
            System.out.println("闰年"); // 能被400整除
        } else {
            System.out.println("平年"); // 能被100整除但不能被400整除
        }
    } else {
        System.out.println("闰年"); // 能被4整除但不能被100整除
    }
} else {
    System.out.println("平年"); // 不能被4整除
}

可以自己写一下，尝试一下！

三、switch 结构

用于多分支选择，根据表达式的值匹配不同的 case 标签。

基本语法

switch (表达式) {
    case 值1:
        // 当表达式的值等于值1时执行
        break;
    case 值2:
        // 当表达式的值等于值2时执行
        break;
    default:
        // 当表达式的值不匹配任何 case 时执行
}

示例：根据星期几输出活动

int day = 3;
switch (day) {
    case 1:
        System.out.println("周一：上班");
        break;
    case 2:
        System.out.println("周二：开会");
        break;
    case 3:
        System.out.println("周三：健身");
        break;
    default:
        System.out.println("其他：休息");
}

注意事项

• break 的作用：终止当前 switch 语句，避免执行后续 case（若省略 break，会发生 “穿透” 现象）每一个语句后面都要加break，穿透现象就是如果在第一个case的时候他就满足了条件，它在输出了第一个周一上班之后，还会把后面的周二周三也输出出来。

• 表达式类型限制：Java 中 switch 表达式可以是 byte、short、int、char、String（Java 7+）、枚举类型。

4.循环结构

1.while循环

一、基本语法

while (条件表达式) {
    // 循环体：条件为 true 时重复执行的代码
}

执行流程：

1. 先判断 条件表达式 的结果是否为 true。

2. 若为 true，执行 循环体，然后再次判断条件。

3. 若为 false，跳出循环，继续执行后续代码。

二、示例：计算 1 到 5 的累加和

int sum = 0;
int i = 1; // 初始化计数器

while (i <= 5) { // 循环条件：i 小于等于 5
    sum += i;    // 累加 i 的值到 sum
    i++;         // 计数器递增
}

System.out.println("和为：" + sum); // 输出：15

三、while 循环的特点

1. 先判断，后执行：循环体可能一次都不执行（若初始条件为 false）。

2. 条件表达式：必须是布尔类型（true 或 false）。

3. 循环控制：需在循环体内修改条件变量，否则会导致 无限循环。

四、无限循环（死循环）

若条件始终为 true，且循环体中没有终止循环的逻辑，会导致程序卡死。 示例：

while (true) { // 条件恒为 true
    System.out.println("无限循环中...");
    // 没有终止条件，需手动中断程序（如 Ctrl+C）
}

五、while 与 do-while 的区别

• while：先判断条件，再执行循环体（可能不执行）。

• do-while：先执行循环体，再判断条件（至少执行一次）。

do-while 示例：

int j = 1;
do {
    System.out.println("j = " + j);
    j++;
} while (j <= 0); // 条件为 false，但循环体已执行一次输出j = 1

今天就到这里了。