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

day01 计算机基础与 Java 入门笔记

---

1. 计算机基础知识

（1）计算机发展史

• 第一台通用计算机：ENIAC
  • 由美国国防部用于弹道计算。
  • 使用 18000 个电子管，占地 170 平方米，重 30 吨，耗电 150 千瓦，每秒可运算 5000 次。

（2）数据存储与运算

• 计算机采用二进制存储数据
  • 十进制：0~9，逢十进一。
  • 二进制：0 和 1，逢二进一。
  • 计算机底层存储和计算都是通过电路的通断来实现 0 和 1 的表示。

---

2. 人机交互方式

• 图形化界面（GUI）
• 命令行界面（CLI）
  • 通过DOS 命令行（Windows）或终端（Linux、MacOS）进行交互。
  • 打开命令提示符（CMD）： Win + R，输入 cmd，回车。

---

3. Path 环境变量

• 作用：系统会自动查找 Path 变量中指定的路径来运行程序。
• 配置 Path 环境变量的步骤
  1. 右键“此电脑” -> 属性 -> 高级系统设置 -> 环境变量。
  2. 在系统变量中找到 Path，点击“编辑”。
  3. 添加软件路径（如 JDK 安装目录的 bin）。
  4. 点击“确定”保存。

---

4. 计算机语言

（1）计算机语言的发展

• 机器语言：使用 0 和 1 编写，计算机直接识别。
• 汇编语言：用简单的英文单词（如 ADD 1,2）代替机器指令。
• 高级语言：使用接近自然语言的代码（如 Java）。

（2）Java 语言简介

• Java 之父：詹姆斯·高斯林（James Gosling）
• 1995 年由 Sun 公司 发布，后被 Oracle 公司 收购。
• Java 三大平台
  • Java SE（标准版）：桌面应用、基础开发。
  • Java ME（小型版）：嵌入式系统。
  • Java EE（企业版）：Web 和企业级应用开发。

（3）Java 的跨平台性

• Java 代码不能直接运行，需要经过 Java 虚拟机（JVM）执行。
• 跨平台原理
  • 不同操作系统安装不同版本的 JVM。
  • Java 程序编译后生成 .class 文件，JVM 解释执行该文件，使 Java 程序可以在 Windows、MacOS、Linux 运行。

---

5. Java 环境安装

（1）JDK 介绍

• JDK（Java Development Kit）：Java 开发工具包，包含：
  • JVM（Java Virtual Machine）：Java 虚拟机，运行 Java 程序的核心。
  • JRE（Java Runtime Environment）：Java 运行环境，包含 JVM 和 Java 类库。
  • Java 开发工具：javac（编译器）、java（运行 Java 程序）。

（2）安装 JDK

• 官方下载地址：https://www.oracle.com/java/technologies/javase-downloads.html
• 安装步骤
  1. 下载 对应操作系统 的 JDK 安装包。
  2. 安装到 纯英文路径（如 D:\Develop\JDK）。
  3. 配置环境变量 JAVA_HOME。

（3）验证安装

java -version  # 查看 Java 版本
javac -version # 查看编译器版本

---

6. Java 语言基础

（1）HelloWorld 代码

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

• public class HelloWorld：定义一个类 HelloWorld，类名必须与文件名一致。
• public static void main(String[] args)：程序的入口方法 main。
• System.out.println("Hello, World!");：控制台输出 "Hello, World!"。

（2）编译与运行

javac HelloWorld.java  # 编译成 HelloWorld.class
java HelloWorld        # 运行 Java 程序

（3）常见错误

错误	解决方案
文件名和类名不一致	确保 Java 文件名和 class 名字相同
大小写错误	Java 区分大小写，确保正确拼写
语法错误	确保 ;、{} 等符号正确匹配
未配置 JDK	确保 JDK 安装正确，环境变量已设置

---

7. Java 语法基础

（1）注释

• 单行注释：// 这是单行注释
• 多行注释：

  /*
   * 这是多行注释
   */
  

• 文档注释（用于 API 文档生成）：

  /**
   * 这是文档注释
   */
  

（2）关键字

• Java 关键字不能作为变量名或方法名（如 class、public、static）。
• 示例

  public class Test {
      int age;  // age 不是关键字，可以作为变量名
  }
  

（3）字面量

• 整数：10, -100, 0
• 小数（浮点数）：3.14, -2.5
• 字符：'A', '中'
• 字符串："Hello"
• 布尔值：true, false

（4）变量

• 变量声明

  int age = 18;  // 定义一个整数变量 age，并赋值 18
  

• 数据类型

  类型	说明	示例
  int	整数	10
  double	小数	3.14
  char	单个字符	'A'
  String	字符串	"Hello"
  boolean	布尔值	true

（5）运算符

• 算术运算符：+ - * / %
• 比较运算符：== != > < >= <=
• 逻辑运算符：&& || !
• 赋值运算符：= += -=

（6）条件判断

if (age >= 18) {
    System.out.println("成年人");
} else {
    System.out.println("未成年");
}

（7）循环

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

---

8. 总结

• 掌握计算机基础知识（二进制、存储单位）。
• 能使用命令行和 Path 环境变量。
• 理解 Java 语言的发展和跨平台原理。
• 能安装 JDK 并配置环境变量。
• 掌握 Java 语法基础（变量、运算符、条件判断、循环）。

💡 继续学习 Java 面向对象编程（OOP）！🚀

day02 Java 基础语法笔记

---

1. Java 变量

（1）变量的概念

• 变量就是内存中的存储空间，用于存储会发生改变的数据。
• 变量的声明和使用

  数据类型 变量名 = 数据值;
  

  示例

  int salary = 15000;
  System.out.println(salary);
  salary = 18000; // 变量值可以修改
  System.out.println(salary);
  

（2）变量的注意事项

✅ 变量名不能重复定义
✅ 一条语句可以定义多个变量（如：int a = 10, b = 20;）
✅ 变量在使用前必须赋值
✅ 变量的作用域：变量只能在其声明的代码块内使用

---

2. Java Debug（调试）工具

• Debug 是程序调试工具，可用于追踪程序执行流程。
• 如何使用 Debug
  1. 添加断点：在代码行号区域单击鼠标左键。
  2. 启动 Debug：右键代码区域，选择 Debug。
  3. 执行步骤：
     • Step Over（F8）：逐行执行代码
     • 查看变量值：在 Variables 窗口查看
  4. 删除断点：再次单击断点，或批量删除。

---

3. Java 标识符

（1）标识符的概念

• 标识符是 Java 代码中用于命名类、方法、变量的符号。

（2）标识符命名规则

✅ 由 字母、数字、下划线 _、美元符 $ 组成
✅ 不能以数字开头
✅ 不能使用 Java 关键字
✅ 区分大小写（Hello 和 hello 是两个不同的标识符）

（3）标识符命名规范

• 小驼峰命名法（用于变量和方法）：
  • 单个单词：name
  • 多个单词：firstName
• 大驼峰命名法（用于类名）：
  • 单个单词：Student
  • 多个单词：GoodStudent

---

4. Java 数据类型

（1）Java 数据类型分类

数据类型	字节数	取值范围
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	3.4e-38 ~ 3.4e38
double	8	1.7e-308 ~ 1.7e308
char	2	单个字符
boolean	1	true / false

（2）数据类型示例

public class DataTypeDemo {
    public static void main(String[] args) {
        int age = 18;
        double price = 9.99;
        char grade = 'A';
        boolean isJavaFun = true;
        
        System.out.println(age);
        System.out.println(price);
        System.out.println(grade);
        System.out.println(isJavaFun);
    }
}

---

5. Scanner 键盘输入

• Scanner 允许用户从键盘输入数据
• 使用步骤
  1. 导入 Scanner：

     import java.util.Scanner;
     

  2. 创建 Scanner 对象：

     Scanner sc = new Scanner(System.in);
     

  3. 接收用户输入：

     int age = sc.nextInt();  // 读取整数
     String name = sc.next(); // 读取字符串
     

（示例）用户信息录入

import java.util.Scanner;

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

        System.out.print("请输入您的姓名: ");
        String name = sc.next();

        System.out.print("请输入您的年龄: ");
        int age = sc.nextInt();

        System.out.println("欢迎, " + name + "! 你的年龄是: " + age);
    }
}

---

6. 运算符

（1）算术运算符

运算符	作用
+	加法
-	减法
*	乘法
/	除法（整数相除只保留整数部分）
%	取余（模运算，返回余数）

示例

int a = 10, b = 3;
System.out.println(a / b);  // 3
System.out.println(a % b);  // 1

（2）字符串拼接

• + 遇到字符串，表示字符串拼接。

System.out.println("年龄: " + 23 + 1); // 输出: 年龄: 231
System.out.println("年龄: " + (23 + 1)); // 输出: 年龄: 24

（3）自增自减运算符

运算符	说明
++	自增 1
--	自减 1

• i++（后增）：先使用 i 的值，再自增 1。
• ++i（前增）：先自增 1，再使用 i 的值。

int a = 5;
System.out.println(a++); // 输出 5, 之后 a 变成 6
System.out.println(++a); // 先自增 a=7, 输出 7

---

7. Java 数据类型转换

（1）隐式转换（小转大）

int a = 10;
double b = a; // int 自动转换为 double
System.out.println(b); // 输出 10.0

（2）强制转换（大转小）

double x = 9.99;
int y = (int) x; // 强制转换
System.out.println(y); // 输出 9（小数部分丢失）

（3）计算时的类型转换

• byte、short、char 在计算时会自动提升为 int：

byte a = 10, b = 20;
int c = a + b; // 计算时会先提升为 int

---

8. 总结

✅ 变量的声明、赋值和作用域
✅ 使用 Debug 工具进行调试
✅ 变量、标识符、数据类型的基本概念
✅ Scanner 处理用户输入
✅ 算术运算、字符串拼接、自增自减运算符
✅ 类型转换（隐式转换、强制转换）
🚀 掌握这些基础后，可继续深入学习 Java 逻辑控制（if 语句、循环）！

day03 Java 运算符与方法基础笔记

---

1. Java 运算符

（1）算术运算符

运算符	作用
+	加法
-	减法
*	乘法
/	除法（整数相除取整）
%	取模（取余数）

示例

int a = 10, b = 3;
System.out.println(a / b);  // 3
System.out.println(a % b);  // 1

---

（2）自增 (++) & 自减 (--) 运算符

运算符	说明
++	自增 1
--	自减 1

• i++（后增）：先使用变量，再自增。
• ++i（前增）：先自增，再使用变量。

示例

int x = 5;
System.out.println(x++); // 输出 5, 之后 x 变成 6
System.out.println(++x); // 先自增 x=7, 输出 7

---

（3）赋值运算符

运算符	作用
=	赋值
+=	加后赋值
-=	减后赋值
*=	乘后赋值
/=	除后赋值
%=	取模后赋值

示例

int a = 10;
a += 5;  // 相当于 a = a + 5;
System.out.println(a);  // 15

注意：扩展运算符 (+=, -=, *=, /=) 隐含了强制类型转换。

---

（4）关系运算符

运算符	作用
==	是否相等
!=	是否不等
>	大于
<	小于
>=	大于等于
<=	小于等于

示例

int x = 10, y = 20;
System.out.println(x == y); // false
System.out.println(x != y); // true

注意：== 用于比较值是否相等，不能用于赋值。

---

（5）逻辑运算符

运算符	作用
&&	逻辑与（两个条件都为 true 结果才为 true）
||	逻辑或（一个条件为 true 结果就为 true）
!	逻辑非（取反）

示例

int score = 95;
boolean isExcellent = (score >= 90) && (score <= 100);
System.out.println(isExcellent); // true

短路逻辑运算符

短路运算符	说明
&&	短路与：左侧为 false，则右侧不执行
||	短路或：左侧为 true，则右侧不执行

int a = 10;
if (a > 5 || ++a > 20) {
    System.out.println(a); // a 仍为 10（因为 `||` 左侧为 true，右侧不执行）
}

---

（6）三元运算符

• 格式：判断条件 ? 值1 : 值2
• 执行流程：
  • 如果判断条件为 true → 取 值1
  • 如果判断条件为 false → 取 值2

示例

int a = 10, b = 20;
int max = (a > b) ? a : b;
System.out.println(max); // 20

---

（7）运算符优先级

逻辑运算符 && 优先级高于 ||，运算顺序可用 () 改变。

int a = 10, b = 20;
System.out.println(a > b || a < b && a > 5); // 等价于 a > b || (a < b && a > 5)

---

2. Java 方法

（1）方法的概念

• 方法（Method） 是 具有独立功能的代码块，用于提高代码复用性。
• 方法的作用：
  • 避免代码重复
  • 代码结构更清晰
  • 提高可维护性

---

（2）方法的定义与调用

方法的格式

public static void 方法名() {
    // 方法体
}

示例

public static void sayHello() {
    System.out.println("Hello, Java!");
}

public static void main(String[] args) {
    sayHello(); // 调用方法
}

---

（3）方法的参数

定义格式

public static void 方法名(参数类型 参数名) {
    // 方法体
}

示例

public static void printSum(int a, int b) {
    System.out.println("和：" + (a + b));
}

public static void main(String[] args) {
    printSum(10, 20);
}

---

（4）方法的返回值

定义格式

public static 数据类型 方法名() {
    return 数据值;
}

示例

public static int getMax(int a, int b) {
    return (a > b) ? a : b;
}

public static void main(String[] args) {
    int max = getMax(10, 20);
    System.out.println("最大值：" + max);
}

---

（5）方法的重载

• 方法重载（Overloading）：在同一个类中，方法名相同，但参数不同（类型/个数/顺序）。
• 特点
  • 方法名相同
  • 参数不同（个数、类型、顺序）
  • 与返回值无关

示例

public static int add(int a, int b) {
    return a + b;
}

public static double add(double a, double b) {
    return a + b;
}

public static int add(int a, int b, int c) {
    return a + b + c;
}

public static void main(String[] args) {
    System.out.println(add(10, 20));       // 调用 int 版本
    System.out.println(add(10.5, 20.5));   // 调用 double 版本
    System.out.println(add(10, 20, 30));   // 调用 3 参数版本
}

---

3. 总结

✅ 掌握 算术、赋值、关系、逻辑、三元运算符
✅ 理解 短路运算符 (&&, ||) 的执行逻辑
✅ 学会 定义、调用方法，提高代码复用性
✅ 掌握 方法的参数、返回值
✅ 学会 方法重载，提高代码灵活性

🚀 继续学习 Java 控制流（if 语句、循环）！

day04 Java 流程控制语句笔记

---

1. 流程控制语句概述

流程控制语句用于 控制程序的执行流程，分为 三种基本结构：

1. 顺序结构：程序按照代码编写顺序依次执行。
2. 分支结构：程序在执行过程中根据条件选择不同的执行路径（if 语句, switch 语句）。
3. 循环结构：程序重复执行某些代码（for、while、do...while）。

---

2. 分支语句

（1）if 语句

if 语句用于条件判断，决定代码是否执行。

第一种格式（单分支）

语法

if (条件) {
    // 语句体
}

示例

int score = 90;
if (score >= 60) {
    System.out.println("及格");
}

---

第二种格式（双分支）

语法

if (条件) {
    // 语句体1
} else {
    // 语句体2
}

示例

int score = 75;
if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

---

第三种格式（多分支）

语法

if (条件1) {
    // 语句体1
} else if (条件2) {
    // 语句体2
} else {
    // 语句体N
}

示例

int score = 85;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

---

（2）switch 语句

switch 语句用于多重条件分支。

语法

switch (变量) {
    case 值1:
        // 语句1;
        break;
    case 值2:
        // 语句2;
        break;
    ...
    default:
        // 默认语句;
        break;
}

示例

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;
}

注意事项
✅ case 只能使用 常量，不能使用变量。
✅ switch 适用于 byte、short、int、char、String（JDK7+）。
✅ break 语句用于 跳出 switch 结构，否则会执行后续 case（穿透现象）。

---

3. 循环语句

（1）for 循环

for 语句用于执行固定次数的循环任务。

语法

for (初始化; 条件判断; 条件控制) {
    // 循环体
}

示例

for (int i = 1; i <= 5; i++) {
    System.out.println("第 " + i + " 次循环");
}

---

（2）while 循环

while 适用于循环次数不确定**，但有终止条件的情况。

语法

初始化;
while (条件判断) {
    // 循环体;
    条件控制;
}

示例

int i = 1;
while (i <= 5) {
    System.out.println("第 " + i + " 次循环");
    i++;
}

---

（3）do…while 循环

do...while 语句至少执行一次循环**，再判断条件是否满足。

语法

初始化;
do {
    // 循环体;
    条件控制;
} while (条件判断);

示例

int i = 1;
do {
    System.out.println("第 " + i + " 次循环");
    i++;
} while (i <= 5);

---

（4）三种循环的区别

循环类型	适用情况	代码特点
for	循环次数确定	结构清晰，适用于已知循环次数
while	循环次数不确定，但有终止条件	适用于 输入判断
do...while	至少执行一次	先执行后判断

---

4. 跳转控制语句

（1）break 语句

• 作用：终止当前 for、while、do...while 语句，跳出循环。
• 示例

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        break;
    }
    System.out.println("i = " + i);
}
// 输出：1, 2

---

（2）continue 语句

• 作用：跳过本次循环，继续下一次循环。
• 示例

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        continue;
    }
    System.out.println("i = " + i);
}
// 输出：1, 2, 4, 5

---

5. 练习案例

（1）计算 1~100 之间的偶数和

int sum = 0;
for (int i = 1; i <= 100; i++) {
    if (i % 2 == 0) {
        sum += i;
    }
}
System.out.println("1~100 之间的偶数和：" + sum);

---

（2）水仙花数

水仙花数：一个三位数，每位数字立方和等于它本身。

for (int i = 100; i <= 999; i++) {
    int ge = i % 10;
    int shi = (i / 10) % 10;
    int bai = i / 100;

    if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
        System.out.println(i + " 是水仙花数");
    }
}

---

（3）使用 Random 生成 1~100 之间的随机数

import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        Random r = new Random();
        int num = r.nextInt(100) + 1; // 生成 1~100 的随机数
        System.out.println("随机数：" + num);
    }
}

---

6. 总结

✅ 掌握顺序、分支、循环三种流程控制结构
✅ 学会使用 if、switch 语句，选择合适的分支结构
✅ 能区分 for、while、do-while 的应用场景
✅ 掌握 break 和 continue，控制循环流程
✅ 能使用 Random 生成随机数，并编写简单的循环程序

🚀 下一步学习：数组与方法的结合使用！

day05 Java 数组基础笔记

---

1. 数组概述

• 数组是一个容器，用来存储同一数据类型的多个值。
• 数组中的元素具有 相同类型，且每个元素都有一个索引，索引从 0 开始。

数组使用场景

• 如果需要存储多个相同类型的数据，可以使用数组来简化数据管理。

---

2. 数组的初始化

（1）静态初始化

静态初始化是直接指定数组的元素值，由系统计算数组的长度。

格式

数据类型[] 数组名 = new 数据类型[] {元素1, 元素2, 元素3, ...};

示例

int[] arr = new int[]{1, 2, 3};

简化格式（不使用 new 关键字）

int[] arr = {1, 2, 3};

（2）动态初始化

动态初始化是仅指定数组的长度，元素由系统默认初始化为零值（数值类型为0，引用类型为null）。

格式

数据类型[] 数组名 = new 数据类型[数组长度];

示例

int[] arr = new int[5];  // 创建一个长度为5的整数数组，所有元素默认值为 0

---

3. 数组元素访问

数组元素通过 索引 来访问，索引从 0 开始。

格式

数组名[索引]

示例

int[] arr = {11, 22, 33};
System.out.println(arr[0]);  // 输出 11
System.out.println(arr[1]);  // 输出 22

---

4. 数组遍历

数组遍历是指通过循环访问数组中的所有元素，并对每个元素进行操作。

（1）求偶数和

需求：遍历数组，找出偶数并求和。

示例

int[] arr = {11, 22, 33, 44, 55};
int sum = 0;
for (int i = 0; i < arr.length; i++) {
    if (arr[i] % 2 == 0) {
        sum += arr[i];
    }
}
System.out.println("偶数和: " + sum);  // 输出偶数和

（2）求最大值

需求：遍历数组，找出最大值。

示例

int[] arr = {5, 44, 33, 55, 22};
int max = arr[0];  // 假设最大值为第一个元素
for (int i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
        max = arr[i];
    }
}
System.out.println("最大值: " + max);

---

5. 二维数组

（1）概念

二维数组是一个数组的数组，可以存储多个一维数组。

（2）二维数组静态初始化

格式

数据类型[][] 数组名 = new 数据类型[][] {{元素1, 元素2}, {元素1, 元素2}};

示例

int[][] arr = new int[][] {{11, 22}, {33, 44}};

简化格式

int[][] arr = {{11, 22}, {33, 44}};

（3）二维数组元素访问

二维数组中的元素通过 两个索引 来访问，分别指定行和列。

格式

数组名[行索引][列索引]

示例

int[][] arr = {{11, 22, 33}, {44, 55, 66}};
System.out.println(arr[0][1]);  // 输出 22
System.out.println(arr[1][2]);  // 输出 66

---

（4）二维数组遍历

需求：遍历一个二维数组并打印所有元素。

示例

int[][] arr = {{11, 22, 33}, {44, 55, 66}};
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}

---

（5）二维数组动态初始化

格式

数据类型[][] 数组名 = new 数据类型[行数][列数];

示例

int[][] arr = new int[2][3];  // 2行3列的二维数组
arr[0] = new int[]{11, 22, 33};
arr[1] = new int[]{44, 55, 66};

---

6. 数组的内存图

数组在内存中的存储是连续的。对于一维数组，每个元素按顺序存储在内存中。对于二维数组，数组的每一行也是一个一维数组，这些一维数组存储在一起。

---

7. 数组常见问题

（1）数组越界异常

访问数组时，如果索引超出了数组的范围，会抛出 ArrayIndexOutOfBoundsException 异常。

示例

int[] arr = {1, 2, 3};
System.out.println(arr[5]);  // 抛出异常：ArrayIndexOutOfBoundsException

（2）空指针异常

如果一个数组引用为 null，且尝试访问它，会抛出 NullPointerException。

示例

int[] arr = null;
System.out.println(arr[0]);  // 抛出异常：NullPointerException

---

8. 总结

✅ 数组的定义和初始化方式
✅ 数组元素访问
✅ 掌握数组的遍历操作
✅ 理解二维数组的概念及其使用
✅ 了解数组的内存图
✅ 能够解决常见数组问题，如数组越界、空指针异常

🚀 继续深入学习 Java 中的集合框架及其应用！

day06 Java 综合案例笔记

---

1. 逢7跳过

需求：打印出 1 到 100 之间的数字，遇到包含数字7或是7的倍数时打印 “过”。

思路：

• 遍历 1 到 100 的数字，检查每个数字是否包含7或是否为7的倍数。
• 如果是，则打印 “过”。

示例

for (int i = 1; i <= 100; i++) {
    if (i % 7 == 0 || String.valueOf(i).contains("7")) {
        System.out.println("过");
    } else {
        System.out.println(i);
    }
}

---

2. 数组元素求和

需求：给定一个数组 {68, 27, 95, 88, 171, 996, 51, 210}，求出数组中满足条件的元素和：个位和十位都不能是7，且元素只能是偶数。

思路：

• 遍历数组元素，检查每个元素是否为偶数，且个位和十位不为7。
• 满足条件则累加。

示例

int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};
int sum = 0;

for (int num : arr) {
    if (num % 2 == 0 && (num % 10 != 7) && (num / 10 % 10 != 7)) {
        sum += num;
    }
}
System.out.println("满足条件的数组元素和：" + sum);

---

3. 判断两个数组是否相同

需求：定义一个方法，判断两个数组是否长度、内容、顺序完全相同。

思路：

• 比较两个数组的长度，如果不同，直接返回 false。
• 如果长度相同，逐一比较每个元素。

示例

public static boolean areArraysEqual(int[] arr1, int[] arr2) {
    if (arr1.length != arr2.length) {
        return false;
    }

    for (int i = 0; i < arr1.length; i++) {
        if (arr1[i] != arr2[i]) {
            return false;
        }
    }
    return true;
}

---

4. 查找元素在数组中的索引

需求：查找指定元素在数组中的索引位置。

思路：

• 遍历数组，逐个比较元素，如果找到了目标元素，返回其索引；否则返回 -1。

示例

public static int findIndex(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;  // 如果未找到目标元素，返回 -1
}

---

5. 数组元素反转

需求：给定数组 {11, 22, 33, 44, 55}，实现元素反转，使数组变为 {55, 44, 33, 22, 11}。

思路：

• 使用双指针法，从数组两端向中间交换元素。

示例

public static void reverseArray(int[] arr) {
    int start = 0;
    int end = arr.length - 1;

    while (start < end) {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
        start++;
        end--;
    }
}

---

6. 评委打分

需求：6个评委给参赛者打分，去掉最高分和最低分，计算剩余4个评委的平均分。

思路：

• 排序后去掉第一个（最小分）和最后一个（最高分），计算剩余分数的平均值。

示例

public static double calculateAverageScore(int[] scores) {
    Arrays.sort(scores);
    int sum = 0;
    for (int i = 1; i < scores.length - 1; i++) {  // 排除最小和最大分
        sum += scores[i];
    }
    return sum / 4.0;  // 平均分
}

---

7. 随机产生验证码

需求：随机从26个英文字母（大小写）和数字0-9中产生一个5位验证码。

思路：

• 使用 Random 类随机生成字符或数字，生成一个5位验证码。

示例

import java.util.Random;

public static String generateCaptcha() {
    String[] chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".split("");
    Random rand = new Random();
    StringBuilder captcha = new StringBuilder();

    for (int i = 0; i < 5; i++) {
        captcha.append(chars[rand.nextInt(chars.length)]);
    }

    return captcha.toString();
}

---

8. 总结

• 通过这些综合案例，我们学习了如何应用数组的基础操作：
  • 数组元素的访问和修改。
  • 数组的遍历方法（如求和、查找最大值等）。
  • 数组的反转操作。
• 通过这些练习，能够增强我们对 数组、循环 和 条件判断 的理解，提升编码能力。

🚀 继续通过编写实际的案例来提高编程能力，掌握更多算法与数据结构！

day 07 Java 面向对象基础笔记**

---

1. 面向对象编程（OOP）概述

• 面向对象：并不是一项技术，而是一种编程的指导思想。它的核心思想是：通过“对象”来组织程序，解决问题。
• 为什么要学面向对象？：面向对象使得代码更加模块化、可维护、易理解，就像现实生活中解决问题的方式一样，面向对象使得编程变得简单高效。

---

2. 类与对象

（1）类的概念

• 类：是一组相关属性和行为的集合，类似于设计图。例如，在 Java 中，要创建一个对象，必须先有类。

（2）类和对象的关系

• 类是模板，对象是根据类创建的实例。
• 每个类可以创建多个对象。

示例：

public class Student {
    String name = "张三";
    int age = 23;

    public void study() {
        System.out.println("学习 Java");
    }

    public void eat() {
        System.out.println("吃饭");
    }
}

（3）创建对象

public class Test {
    public static void main(String[] args) {
        Student stu = new Student(); // 创建对象
        stu.study();  // 使用对象的成员方法
        stu.eat();    // 使用对象的成员方法
    }
}

---

3. 类的组成

（1）成员变量

• 成员变量是类中的数据字段，定义在类的方法之外。

（2）成员方法

• 成员方法是类的行为，定义在类中，通常不需要static关键字。

---

4. this 关键字

• **this**代表当前类的对象引用（即当前对象的地址）。
• 用来解决局部变量与成员变量同名的问题，明确区分两者。

示例：

public class Student {
    String name;

    public void setName(String name) {
        this.name = name;  // 使用 this 关键字来区分成员变量和局部变量
    }
}

---

5. 构造方法

（1）构造方法的定义

• 构造方法用于初始化对象的成员变量。构造方法的名称必须与类名相同，且没有返回值类型。

示例：

public class Student {
    String name;
    int age;

    public Student(String name, int age) {  // 构造方法
        this.name = name;
        this.age = age;
    }
}

（2）构造方法的重载

• 构造方法可以重载，允许定义多个构造方法，根据传递参数的不同来初始化对象。

示例：

public class Student {
    String name;
    int age;

    public Student() {  // 无参数构造方法
        this.name = "默认";
        this.age = 18;
    }

    public Student(String name, int age) {  // 带参数构造方法
        this.name = name;
        this.age = age;
    }
}

---

6. 封装

• 封装是面向对象的三大特征之一，将数据（成员变量）和操作这些数据的行为（成员方法）组合成一个类，避免外部直接访问数据。
• 使用**private来隐藏类的内部数据，通过提供get和set**方法来安全地访问数据。

示例：

public class Student {
    private String name;
    private int age;

    public String getName() {  // getter方法
        return name;
    }

    public void setName(String name) {  // setter方法
        this.name = name;
    }
}

---

7. 面向对象的三大特征

1. 封装：隐藏对象的实现细节，只暴露接口给外界。
2. 继承：子类可以继承父类的属性和方法，代码重用性高。
3. 多态：同一方法在不同对象中有不同的表现。

---

8. 综合案例

（1）逢七跳过

需求：打印出 1 到 100 之间的数字，遇到包含7或是7的倍数时输出“过”。

思路：

for (int i = 1; i <= 100; i++) {
    if (i % 7 == 0 || String.valueOf(i).contains("7")) {
        System.out.println("过");
    } else {
        System.out.println(i);
    }
}

（2）数组元素求和

需求：求出数组 {68, 27, 95, 88, 171, 996, 51, 210} 中符合条件（偶数且个位和十位不含7）的元素和。

int[] arr = {68, 27, 95, 88, 171, 996, 51, 210};
int sum = 0;
for (int num : arr) {
    if (num % 2 == 0 && num % 10 != 7 && num / 10 % 10 != 7) {
        sum += num;
    }
}
System.out.println("满足条件的数组元素和：" + sum);

（3）判断两个数组是否相同

需求：判断两个数组是否内容相同（顺序和长度都必须一致）。

public static boolean areArraysEqual(int[] arr1, int[] arr2) {
    if (arr1.length != arr2.length) {
        return false;
    }
    for (int i = 0; i < arr1.length; i++) {
        if (arr1[i] != arr2[i]) {
            return false;
        }
    }
    return true;
}

（4）查找元素在数组中的索引

需求：查找数组中某个元素的索引。

public static int findIndex(int[] arr, int target) {
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;  // 未找到元素
}

---

9. 总结

• 类和对象：类是模板，对象是实例。通过类来定义对象的属性和行为。
• 封装：通过私有化数据，提供公有方法访问，增强数据的安全性。
• 构造方法：用于初始化对象，支持重载。
• 面向对象三大特征：封装、继承、多态，提升代码复用性和可维护性。

🚀 继续通过实践巩固面向对象的知识，深入了解继承和多态的应用！

day08 Java 字符串基础笔记

---

1. 字符串的基本概念

• String 类：在 Java 中，所有用双引号包裹的字符串都是 String 类的对象。字符串在创建后内容不可更改，但是它们可以被共享。

String 类特点

• 字符串是 不可变的：创建后内容不能修改，修改操作会返回一个新的字符串。
• 共享性：Java 会将常量字符串存储在 字符串常量池 中，多个相同的字符串会共享同一个内存地址。

---

2. String 类常见方法

（1）字符串比较

• equals()：比较字符串内容是否相等。
• equalsIgnoreCase()：忽略大小写，比较字符串内容是否相等。

String s1 = "abc";
String s2 = "ABC";
System.out.println(s1.equals(s2));  // false
System.out.println(s1.equalsIgnoreCase(s2));  // true

（2）字符获取

• charAt(int index)：返回指定索引位置的字符。
• toCharArray()：将字符串转换为字符数组。

String str = "hello";
char c = str.charAt(0);  // 'h'
char[] chars = str.toCharArray();

（3）长度获取

• length()：返回字符串的长度。

String str = "hello";
System.out.println(str.length());  // 5

（4）字符串截取

• substring(int beginIndex)：从指定索引位置截取到字符串末尾。
• substring(int beginIndex, int endIndex)：从 beginIndex 到 endIndex 截取字符串（不包含 endIndex）。

String str = "hello world";
System.out.println(str.substring(6));  // "world"
System.out.println(str.substring(0, 5));  // "hello"

（5）字符串替换

• replace(CharSequence target, CharSequence replacement)：替换字符串中的某些字符。

String str = "hello world";
String newStr = str.replace("world", "Java");
System.out.println(newStr);  // "hello Java"

（6）字符串分割

• split(String regex)：根据给定的正则表达式分割字符串，返回字符串数组。

String str = "apple,banana,orange";
String[] fruits = str.split(",");
System.out.println(Arrays.toString(fruits));  // [apple, banana, orange]

（7）字符串连接

• concat(String str)：连接两个字符串。

String str1 = "hello";
String str2 = "world";
System.out.println(str1.concat(str2));  // "helloworld"

---

3. StringBuilder 类

（1）StringBuilder 的作用

• StringBuilder 是 可变的字符序列，用于高效地修改字符串。
• 与 String 类不同，StringBuilder 允许在原有字符串上进行修改，不会产生新的对象。

（2）常用方法

• append(String str)：将指定的字符串追加到当前字符串的末尾。
• insert(int offset, String str)：在指定位置插入字符串。
• delete(int start, int end)：删除指定范围内的字符。
• reverse()：反转字符串。

StringBuilder sb = new StringBuilder("hello");
sb.append(" world");  // "hello world"
sb.insert(5, ",");    // "hello, world"
sb.reverse();         // "dlrow ,olleh"
System.out.println(sb.toString());

---

4. 字符串常见问题

（1）字符串常量池

• 字符串常量池：Java 会将常量字符串存储在一个池中，相同内容的字符串会共享相同的内存地址。

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);  // true

（2）字符串的拼接与性能问题

• 字符串拼接：使用 + 进行拼接时，会创建多个中间字符串，造成性能问题，推荐使用 StringBuilder 来高效拼接。

String s1 = "hello";
String s2 = "world";
String s3 = s1 + s2;  // 会创建多个临时字符串对象

• 使用 StringBuilder：

StringBuilder sb = new StringBuilder("hello");
sb.append("world");
System.out.println(sb.toString());  // "helloworld"

---

5. 实践案例

（1）用户登录

需求：模拟用户登录，正确的用户名和密码是 "admin" 和 "1234"。用户最多有三次输入机会。

import java.util.Scanner;

public class Login {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String correctUsername = "admin";
        String correctPassword = "1234";

        for (int i = 0; i < 3; i++) {
            System.out.print("请输入用户名: ");
            String username = sc.nextLine();
            System.out.print("请输入密码: ");
            String password = sc.nextLine();

            if (username.equals(correctUsername) && password.equals(correctPassword)) {
                System.out.println("登录成功！");
                break;
            } else {
                System.out.println("用户名或密码错误，剩余机会: " + (2 - i));
            }
        }
    }
}

---

（2）统计字符出现次数

需求：键盘录入一个字符串，统计其中大写字母、小写字母和数字字符的出现次数。

import java.util.Scanner;

public class CharCount {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入字符串: ");
        String input = sc.nextLine();

        int upperCount = 0, lowerCount = 0, digitCount = 0;
        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            if (Character.isUpperCase(c)) upperCount++;
            else if (Character.isLowerCase(c)) lowerCount++;
            else if (Character.isDigit(c)) digitCount++;
        }

        System.out.println("大写字母: " + upperCount);
        System.out.println("小写字母: " + lowerCount);
        System.out.println("数字: " + digitCount);
    }
}

---

6. 总结

• String 类：用于处理不可变的字符串，提供了多种方法来操作字符串，如 equals()、substring()、replace() 等。
• StringBuilder 类：用于处理可变字符串，推荐在需要频繁修改字符串的情况下使用，以提高效率。
• 字符串常量池：相同内容的字符串会共享内存，减少内存消耗。

🚀 继续练习字符串相关的操作，并熟悉字符串方法的应用！

day09 Java 集合基础笔记

---

1. 什么是集合？

• 集合是一种容器，用于存储多个元素。它类似于数组，但不同的是集合的大小是可变的，能够动态地添加和删除元素。
• 在开发中，集合比数组更常用，因为它们提供了更多的操作方法和更高的灵活性。

数组与集合的对比

特性	数组	集合
大小	固定不变	动态变化
类型	存储同类型元素	存储任意类型的元素
访问方式	通过索引访问元素	通过迭代器或方法访问元素

---

2. 常见集合类

（1）List 接口

• ArrayList、LinkedList、Vector：这些类实现了 List 接口，支持按索引访问元素。ArrayList 是最常用的实现。

（2）Set 接口

• HashSet、LinkedHashSet、TreeSet：这些类实现了 Set 接口，不允许重复元素。HashSet 无序，LinkedHashSet 有序，TreeSet 按自然顺序排序。

（3）Map 接口

• HashMap、LinkedHashMap、TreeMap：这些类实现了 Map 接口，用于存储键值对。

---

3. ArrayList 集合

（1）ArrayList 的特点

• 动态数组：ArrayList 的底层是一个动态数组，初始容量为 10。当容量不足时，会扩容到原数组的 1.5 倍，并将原数组数据拷贝到新数组中。
• 常用操作：
  • add()：添加元素
  • get()：获取指定索引的元素
  • remove()：删除指定元素或索引的元素
  • size()：返回集合的元素个数

示例：

ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

for (String language : list) {
    System.out.println(language);  // 遍历并打印所有元素
}

---

4. 集合的基本操作

（1）集合存储字符串并遍历

需求：创建一个存储字符串的集合，存储 3 个字符串元素，并在控制台遍历该集合。

ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.add("C++");

for (String language : list) {
    System.out.println(language);  // 输出：Java, Python, C++
}

（2）集合存储学生对象并遍历

需求：创建一个存储学生对象的集合，存储 3 个学生对象，使用程序遍历该集合。

class Student {
    String name;
    int age;

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

ArrayList<Student> students = new ArrayList<>();
students.add(new Student("Alice", 20));
students.add(new Student("Bob", 22));
students.add(new Student("Charlie", 21));

for (Student student : students) {
    System.out.println(student.name + ", " + student.age);
}

---

5. 集合元素删除

（1）删除集合中的元素

需求：删除集合中所有的 "test" 字符串，删除后打印剩余的元素。

ArrayList<String> list = new ArrayList<>(Arrays.asList("test", "John", "test", "Alice"));
list.removeIf(s -> s.equals("test"));

for (String item : list) {
    System.out.println(item);  // 输出: John, Alice
}

---

6. 集合元素筛选

（1）筛选年龄低于 18 的学生

需求：筛选出年龄小于 18 岁的学生，存入新的集合中。

ArrayList<Student> students = new ArrayList<>();
students.add(new Student("Alice", 20));
students.add(new Student("Bob", 17));
students.add(new Student("Charlie", 15));

ArrayList<Student> under18 = new ArrayList<>();
for (Student student : students) {
    if (student.age < 18) {
        under18.add(student);
    }
}

for (Student student : under18) {
    System.out.println(student.name + ", " + student.age);  // 输出 Bob, 17 和 Charlie, 15
}

---

7. 学生管理系统（简易版）

（1）需求：使用集合来管理学生数据，实现学生的增删改查功能。

示例代码：

class Student {
    String name;
    int age;

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

    public String toString() {
        return "Name: " + name + ", Age: " + age;
    }
}

ArrayList<Student> students = new ArrayList<>();
students.add(new Student("Alice", 20));
students.add(new Student("Bob", 22));

// 查找学生
for (Student student : students) {
    if (student.name.equals("Alice")) {
        System.out.println(student);
    }
}

// 删除学生
students.removeIf(s -> s.name.equals("Bob"));

---

8. 总结

• 集合提供了更灵活的数据存储和操作方式，相比于数组，集合的大小是动态可变的。
• ArrayList 是最常用的集合类之一，提供了简单有效的添加、获取、删除元素的方法。
• 学会使用 removeIf()、add()、size() 等方法来操作集合，了解如何遍历和筛选数据。
• 学生管理系统示例展示了如何使用集合存储和操作对象数据。

🚀 通过练习，继续巩固集合的基本使用和应用！