第一章：JAVA环境搭建

1. Java背景介绍

1.1 Java简介

• 由James Gosling于1995年在Sun公司开发

• 2009年被Oracle公司收购

1.2 James Gosling简介

• 1955年出生于加拿大

• 1977年获卡尔加里大学计算机学士学位

• 1983年获卡内基梅隆大学计算机博士学位

• 被誉为"Java之父"

1.3 学习Java能做什么

• 企业级应用开发（如淘宝）

• 桌面应用开发（使用IDEA、Eclipse）

• 移动应用开发（Android）

• 服务器系统（应用后台）

• 大数据开发（Hadoop）

• 游戏开发（如《我的世界》）

1.4 Java三大技术平台

• JavaSE（标准版）：Java技术的核心和基础

• JavaEE（企业版）：企业级应用开发解决方案

• JavaME（小型版）：移动设备应用解决方案

1.5 小结

• Java是高级编程语言

• 由Sun公司研发，现属于Oracle公司

• Java之父：James Gosling

• 主要应用于企业服务端开发

• 三大平台：JavaSE、JavaEE、JavaME

2. JDK工具的下载和安装

2.1 JDK简介

• Java Development Kit（Java开发工具包）

• 必须安装JDK才能开发Java程序

2.2 JDK版本

• LTS版本：JDK 8、11、17、21

• 企业常用版本：JDK 8、11

2.3 下载步骤

1. 访问Oracle官网：Java Downloads | Oracle中国

2. 选择JDK版本（推荐LTS版本）

3. 选择操作系统版本

4. 选择安装包类型（压缩包或安装程序）

2.4 安装验证

• 命令行输入：

java -version
javac -version

• 成功显示版本号即安装成功

2.5 JDK组成

• JVM（Java虚拟机）

• 核心类库

• 开发工具（javac、java等）

2.6 小结

• 必须安装JDK才能开发Java程序

• 下载地址：Oracle官网

• 推荐LTS版本：JDK 8、11、17、21

• 验证安装：java -version和javac -version

• JDK核心组件：JVM、核心类库、开发工具

3. 第一个Java程序HelloWorld

3.1 开发步骤

1. 编写代码（保存为.java文件）

2. 编译代码（javac HelloWorld.java）

3. 运行程序（java HelloWorld）

3.2 代码示例

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

}

3.3 常见错误

1. 文件扩展名未勾选

2. 代码未保存

3. 文件名与类名不一致

3. 大小写错误/拼写错误/中文符号

4. 括号不配对

5. 编译/执行工具使用不当

3.4 小结

• 开发三步骤：编写、编译、运行

• 文件要求：

• 后缀必须是.java

• 文件名必须与类名一致

• 使用英文符号

4. Java程序执行原理

4.1 编程语言发展

• 机器语言（0/1）

• 汇编语言

• 高级语言（Java）

4.2 Java跨平台原理

• 通过JVM实现跨平台

• 不同操作系统安装对应版本的JVM

4.3 小结

• 最终都要翻译为机器语言（0/1）

• Java跨平台原理：安装对应JVM

5. Java环境配置

5.1 Path环境变量

• 作用：配置程序路径，方便任意目录启动程序

• 配置位置： 此电脑→属性→高级系统设置→高级→环境变量

5.2 JAVA_HOME

• 作用：告诉操作系统JDK安装位置

5.3 环境变量验证

• 命令行输入：

java -version
javac -version

5.4 小结

• Path环境变量：方便任意目录启动程序

• 新版JDK可能自动配置Path

• 建议手动配置PATH和JAVA_HOME

补充：DOS常用命令

总结

本文档详细介绍了Java开发环境搭建的全过程，包括Java背景、JDK安装、第一个程序开发、执行原理和环境配置等关键内容，适合作为Java初学者的入门指南。

第二章：IDEA开发工具

1. IDEA介绍和安装

1.1 IDEA概述

• IDEA全称：IntelliJ IDEA

• 定义：目前使用最多的Java开发集成环境(IDE)

• 核心特点：把代码编写、编译、执行、调试等多种功能综合到一起的开发工具

• 定位：领先的Java和Kotlin IDE，使开发更高效、更愉快

1.2 IDE集成环境概念

• 定义：将代码编写、编译、运行、调试等多种功能集成在一起的开发工具

• 优势：提高开发效率，简化开发流程

1.3 安装说明

• 官方下载：IntelliJ IDEA - the Leading Java and Kotlin IDE(jetbrains.com)

• 对比工具：Eclipse(另一款流行的Java IDE)

1.4 小结

• IDEA是功能全面的Java开发IDE

• IDE的核心价值在于整合开发流程中的各项功能

2. IDEA中的第一个代码

2.1 项目结构

• 层级关系：

• Project(项目)

• Module(模块)

• Package(包)

• Class(类)

• 本质说明：

• Project、Module、Package本质上都是文件夹，用于管理类文件

2.2 典型项目结构示例

1. MallProject：

• 包含模块：goods-module(商品模块)、order-module(订单模块)、search-module(搜索模块)

• 文件结构：

MallProject E:\deaProjects\MallProject
> idea

> goods-module

> order-module

> idea

> search-module

MallProject.iml

√ goods-module

> external Libraries

√ Scratches and Consoles

2. BasicCodes：

• 基础篇项目结构：

BasicCodes E:\IdeaProjects\BasicCodes
> day01

> day02

> day03

BasicCodes.iml

> External Libraries

> Scratches and Consoles

• 开发规范：整个基础篇创建一个Project，每天创建一个新的Module

2.3 常用快捷键

• 生成main方法：

• 快捷键：psvm 或 main

• 生成打印语句：

• 快捷键：sout

2.4 小结

• 掌握IDEA的项目层级结构

• 熟悉基本的项目组织方式

• 记住常用快捷键提高编码效率

3. IDEA使用操作

3.1 基本文件操作

• 新建类文件

• 删除类文件

• 修改类文件

3.2 模块管理

• 新建模块

• 删除模块

• 修改模块

• 导入模块

3.3 项目管理

• 新建项目

• 打开项目

• 修改项目

3.4 IDE界面操作

• 常用菜单：

• File(文件)

• Edit(编辑)

• View(视图)

• Navigate(导航)

• Code(代码)

• Refactor(重构)

• Build(构建)

• 设置相关：

• Settings(设置)

• Project Structure(项目结构)

• Plugins(插件)

• Version Control(版本控制)

• Languages & Frameworks(语言和框架)

• Tools(工具)

3.5 实用技巧

• 中文支持：可安装中文插件(适合英文不习惯的用户)

• 学习建议：不急于一时，慢慢熟练

3.6 小结

• 掌握IDEA的基本操作流程

• 熟悉项目、模块、文件的管理方式

• 了解IDE界面和常用设置

4. 补充说明

• 开发工具价值：高级开发工具可以帮助我们编写程序、提高开发效率

• 学习态度：工欲善其事必先利其器，掌握好IDEA能显著提升开发效率

5. 总结

本章详细介绍了：

1. IDEA的基本概念和安装方法

2. 项目结构的组织方式

3. 基本使用操作和快捷键

4. 文件、模块、项目的管理方法

掌握这些内容将为后续的Java开发打下坚实基础。

第三章：JAVA基础语法

1. 注释

1.1 什么是注释

注释是写在程序中对代码进行解释说明的文字，方便自己和其他人查看，以便理解程序。

1.2 Java注释的三种写法

1. 单行注释：// 注释内容，只能写一行

2. 多行注释：/* 注释内容 */，可以写多行

3. 文档注释：/** 注释内容 */，通常用于生成API文档

1.3 注意事项

• 注释内容不会参与编译和运行

• 编译后的class文件中已经没有注释了

1.4 小结

• 注释是程序中的解释性文字

• Java支持三种注释方式：单行、多行和文档注释

• 注释不影响程序执行

2. 关键字

2.1 关键字介绍

关键字是被Java赋予了特定涵义的英文单词，如public、class等。

2.2 注意事项

• Java中的关键字已经被赋予特殊涵义，不允许作为标识符使用

2.3 小结

• 关键字是Java中具有特殊含义的保留字

• 不能使用关键字作为变量名、类名等标识符

3. 字面量

3.1 字面量介绍

字面量是程序中能直接书写的数据，重点在于掌握Java程序中数据的书写格式。

3.2 字面量练习

需求：打印个人信息（姓名、年龄、性别、身高、婚姻状况）

3.3 小结

1. 字面量是程序中直接书写的数据

2. 字符必须用单引号围起来，有且仅能一个字符

3. 字符串必须用双引号围起来

4. 特殊值书写格式：

• true、false表示布尔值

• null表示空值

4. 变量

4.1 变量的介绍和定义格式

变量是内存中的一块区域，用于存储程序要处理的数据。

定义格式：

数据类型 变量名称 = 变量值;
// 示例

int age = 18;

4.2 变量的特点

• 变量里装的数据可以被替换

• 示例：

int age = 18;
age = 19;

System.out.println(age);

age = age + 1;

System.out.println(age);

4.3 变量的应用场景

• 编写程序对数据进行处理非常方便

4.4 变量的注意事项

1. 变量要先声明才能使用

2. 变量是什么类型，就必须装什么类型的数据

3. 变量只在自己所归属的{}范围内有效

4. 同一个范围内，变量的名称不能一样

5. 变量定义的时候可以不赋初始值，但在使用时，变量里必须有值

6. 一条语句可以定义多个变量，中间使用逗号分隔

4.5 小结

• 变量是内存中的数据存储单元

• 使用变量可以使代码更灵活、管理更方便

• 变量有明确的命名规则和使用限制

5. 标识符

5.1 标识符概述

标识符是给类、方法、变量等起名字的符号。

5.2 标识符命名规则

1. 由数字、字母、下划线(_)和美元符($)组成

2. 不能以数字开头

3. 不能是关键字

4. 区分大小写

5.3 不符合规则的变量名示例

5.4 标识符命名规范

小驼峰命名法（变量、方法）

1. 一个单词：所有字母小写，如name

2. 多个单词：从第二个单词开始首字母大写，如firstName

大驼峰命名法（类）

1. 一个单词：首字母大写，如Student

2. 多个单词：每个单词首字母大写，如GoodStudent

5.5 小结

• 标识符是程序中各种元素的名称

• 必须遵守命名规则和规范

• 见名知义，使用驼峰命名法

6. 数据类型

6.1 基本数据类型

6.1.1 数据类型分类

6.1.2 取值范围和内存占用

6.2 引用数据类型

• 类

• 接口

• 数组

6.3 小结

1. Java数据类型分为基本数据类型和引用数据类型

2. 整数类型首选int

3. 小数类型首选double

4. 字符串类型使用String

6.4 编码表

• ASCII码表：美国信息交换标准代码

• 包含128个字符的编码

第四章：运算符

1. 算数运算符

1.1 基本运算符

1.2 注意事项

• /和%的区别：

• /取结果的商

• %取结果的余数

• 整数操作只能得到整数结果，要想得到小数必须有浮点数参与运算

1.3 数值拆分案例

需求：将数字123拆分出个位、十位、百位后打印在控制台

计算方法：

1. 个位：数值%10 → 123%10=3

2. 十位：数值/10%10 → 123/10=12 → 12%10=2

3. 百位：数值/10/10%10 → 123/10=12 → 12/10=1 → 1%10=1

通用公式：

• 个位：数值%10

• 十位：数值/10%10

• 百位：数值/10/10%10

• 千位：数值/10/10/10%10

1.4 小结

• 整数相除不能直接得到小数结果，需要加入浮点数运算

• 五位数65536获取千位的公式：数值/10/10/10%10

2. 字符串拼接操作

2.1 拼接规则

• 当+操作中遇到字符串时，+变为字符串连接符

• 示例：

• "年龄为:"+23 → "年龄为:23"

• "年龄为:23"+1 → "年龄为:231"

2.2 小结

• +号操作中遇到字符串就会变成字符串拼接

3. 自增自减运算符

3.1 基本运算符

3.2 使用位置

• 可以放在变量前边或后边

• 单独使用时前后无区别

• 参与运算时：

• ++在前：先自增再操作

• ++在后：先操作再自增

3.3 限制

• 只能操作变量，不能操作字面量

3.4 小结

• ++、--单独使用前后无区别

• 参与运算时位置影响结果

• 只能用于变量操作

4. 类型转换

4.1 类型分类

1. 隐式转换(自动类型转换)

2. 强制转换(显式类型转换)

4.2 隐式转换

• 特点：小范围数据→大范围变量

• 运算过程中的隐式转换：

• 小范围数据与大范围数据运算时，小范围数据会先提升为大范围类型

• byte、short、char三种数据在运算时会先提升为int类型

4.3 强制类型转换

• 格式：目标数据类型 变量名=(目标数据类型)被强转的数据

• 特点：

• 可能造成精度损失

• 不允许直接赋值(大范围→小范围)

4.4 小结

• 基本隐式转换：小→大

• 运算隐式转换：小→大(运算时自动提升)

• 强制转换：大→小(需显式转换，可能损失精度)

5. 赋值运算符

5.1 基本赋值运算符

5.2 扩展赋值运算符

5.3 小结

• 基本赋值运算符：=

• 扩展赋值运算符：+=、-=、*=、/=、%=

• 扩展赋值运算符隐含强制转换效果

6. 关系运算符

6.1 基本运算符

6.2 特点

• 最终返回boolean类型结果

• 注意==和=的区别

6.3 小结

• 关系运算符用于比较操作

• 返回值为boolean类型

• 注意不要混淆==和=

7. 逻辑运算符

7.1 基本概念

• 用于连接多个布尔表达式

• 最终返回boolean类型结果

7.2 运算符分类

1. 普通逻辑运算符：

• &：逻辑与(遇false则false)

• |：逻辑或(遇true则true)

• ^：逻辑异或(相同false，不同true)

• !：逻辑非(取反)

2. 短路逻辑运算符：

• &&：短路与(左边false则右边不执行)

• ||：短路或(左边true则右边不执行)

7.3 使用示例

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

7.4 小结

• 常用逻辑运算符：&&、||、!

• &和&&区别：&&有短路效果

• |和||区别：||有短路效果

8. 三元运算符

8.1 基本语法

格式：判断条件?值1:值2

8.2 执行流程

1. 计算判断条件的值

2. 条件为true，返回值1

3. 条件为false，返回值2

8.3 特点

• 根据条件从两份数据中选择其一

9. 运算符优先级

9.1 优先级顺序(从高到低)

1. 括号()

2. 单目运算符：++、--、!

3. 算术运算符：*、/、%、+、-

4. 关系运算符：>、>=、<、<=

5. 相等运算符：==、!=

6. 逻辑运算符：&&、||

7. 赋值运算符：=、+=、-=、*=、/=、%=

10. Scanner键盘录入

10.1 使用步骤

1. 导包：import java.util.Scanner;

2. 创建对象：Scanner sc = new Scanner(System.in);

3. 调用方法接收数据：

• sc.nextInt()：接收整数

• sc.next()：接收字符串

• sc.nextDouble()：接收浮点数

10.2 小结

• 使用Scanner类实现键盘输入

• 需要三个固定步骤

• 支持多种数据类型输入

补充说明

• 本章内容涵盖了Java基础运算符的完整知识体系

• 重点掌握各类运算符的使用场景和注意事项

• 特别注意类型转换和运算符优先级问题

• 实际开发中最常用的是赋值运算符、关系运算符和逻辑运算符

第五章：方法

1. 方法的介绍

1.1 方法定义

• 方法(函数)：一段具有独立功能的代码块，不调用就不执行

• 方法的作用：

• 将臃肿代码按功能分类管理，提高维护性

• 提高代码复用性

1.2 示例说明

public class VariableDemo {
  public static void main(String[] args) {
  
    查看全部商品(50行代码)
    
    上架商品(50行代码)
    
    下架商品(50行代码)
    
    修改商品(50行代码)
  
  }

}

1.3 小结

• 方法是将功能封装的代码块

• 通过方法可以提高代码的组织性和复用性

2. 方法的基本定义和调用

2.1 定义和调用格式

• 定义格式：[具体格式见后续章节]

• 调用格式：方法名();

• 示例：show();

2.2 案例：计算两个整数最大值

• 需求：定义方法求两个整数最大值

• 实现步骤：

1. 编写方法(小驼峰命名法)

2. 方法内定义两个int变量

3. 使用三元运算符求最大值

4. 调用方法执行逻辑

3. 方法的执行流程

3.1 内存分配

• 方法未被调用时：存储在方法区的字节码文件中

• 方法被调用时：进入栈内存运行

3.2 执行流程示例

public class MethodDemo1 {
  public static void main(String[] args) {
  
    System.out.println("开始");
    
    getMax(); // 方法调用进入栈内存
    
    System.out.println("结束");
  
  }
  
  public static void getMax() {
  
    int num1 = 10;
    
    int num2 = 20;
    
    int max = num1 > num2 ? num1 : num2;
    
    System.out.println(max);
  
  }

}

3.3 内存变化图示

1. 方法区加载：main、getMax方法字节码

2. 栈内存变化：

• main方法入栈

• getMax方法调用时入栈

• getMax执行完毕后出栈

• main方法继续执行

3.4 小结

• 方法区：存储字节码文件

• 栈内存：方法运行时入栈，结束后出栈

4. 带参数的方法

4.1 问题分析

• 原始方法局限：getMax(10,20)只能计算固定值

• 改进需求：方法参数应可灵活传入

4.2 定义和调用格式

• 定义格式：方法名(参数类型 参数名, ...);

• 调用格式：方法名(实参1, 实参2, ...);

• 示例：

• call("钢门吹雪");

• add(10,20);

4.3 内存图解示例

public class MethodDemo2 {
  public static void main(String[] args) {
  
    getMax(10,20); // 实参
    
    System.out.println("----------");
    
    getMax(30,40);
    
  }
  
  public static void getMax(int num1, int num2) { // 形参
  
    int max = num1 > num2 ? num1 : num2;
    
    System.out.println(max);
  
  }

}

4.4 形参和实参

• 形参：方法定义时声明的参数

• 实参：方法调用时传入的具体值

4.5 小结

• 带参数方法提高了灵活性

• 形参是方法定义时的占位符

• 实参是调用时传入的具体值

5. 带返回值的方法

5.1 需求场景

• 当A方法需要将数据传递给B方法时

• 示例：

public static void methodB() {
  int result = methodA(10,20); // 获取返回值
  
  System.out.println(result % 2 == 0);

}

5.2 定义和调用格式

• 定义格式：方法名(...):返回类型

• 调用格式：

• 方法名(参数...); (不接收返回值)

• 数据类型变量名 = 方法名(参数...); (接收返回值)

• 示例：int result = add(10,20);

5.3 小结

• 返回值通过return关键字传递

• 返回值回到方法调用处

• 需要接收返回值时应使用变量存储

6. 方法通用定义格式

6.1 标准格式

public static 返回值类型 方法名(参数) {
  方法体;
  
  return 数据;

}

6.2 要素说明

• 参数：方法的输入材料

• 方法体：处理逻辑

• 返回值：方法输出结果

6.3 定义方法要点

1. 明确参数：

• 参数类型

• 参数数量

2. 明确返回值类型：

• 有结果：指定数据类型

• 无结果：void

6.4 案例需求

1. 计算2个小数和

2. 计算3个整数最小值

3. 打印用户个人信息

6.5 小结

• 定义方法需明确两个关键点：参数和返回值类型

7. 方法注意事项

7.1 核心规则

1. 方法不调用就不执行

2. 方法间是平级关系，不能嵌套定义

3. 编写顺序与执行顺序无关

4. void方法可以省略return

5. return后不能跟代码(不可达语句)

7.2 错误示例

public class MethodDemo {
  public static void method() {
  
    // 代码片段
    
    return; // 后面不能有代码
    
    System.out.println("这行不会执行");
  
  }

}

7.3 小结

• 掌握方法调用的基本规则

• 避免常见的方法定义错误

8. 方法重载

8.1 定义

• 同一个类中，方法名相同但参数不同的方法构成重载

• 参数不同包括：

• 参数个数不同

• 参数类型不同

• 参数顺序不同

8.2 示例代码

public class Test {
  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 double add(double a, double b, double c) { return a + b + c; }
  
}

8.3 重载识别要点

• 只看方法名和参数(类型、个数、顺序)

• 与返回值无关

8.4 重载好处

• 不需要记忆多个方法名

• 提高代码可读性

8.5 小结

• 方法重载是多态的一种表现

• 通过参数区分同名方法

9. IDEA安装AI插件

9.1 传统编程方式

• 程序员需要逐行思考和编写代码

9.2 AI辅助编程

• 现代IDE(如IDEA)可集成AI编程插件

• 推荐插件：阿里巴巴通义灵码

• 下载地址： https://lingma.aliyun.com/lingma/download

9.3 小结

• AI插件可以提升编码效率

• 智能辅助编程是发展趋势

第六章：流程控制语句

1. 流程控制语句分类

1.1 顺序结构

• Java程序默认的执行流程

• 

• 没有特定的语法结构

• 按照代码的先后顺序依次执行

• 示例代码：

public class Test {
  public static void main(String[] args) {
  
    System.out.println("A");
    
    System.out.println("B");
    
    System.out.println("C");
  
  }

}

• 执行流程：开始 → 语句A → 语句B → 语句C → 结束

1.2 分支结构

• if语句

• switch语句

1.3 循环结构

• for循环

• while循环

• do...while循环

1.4 其他控制语句

• break

• continue

• Random生成随机数

2. 分支结构 if

2.1 if第一种格式

if (判断条件) {
  语句体;

}

执行流程：

1. 计算判断条件的结果

2. 如果为true执行语句体

3. 如果为false不执行语句体

2.2 if第二种格式

if (判断条件) { 
  语句体1;
  
} else {

  语句体2;

}

执行流程：

1. 计算判断条件的结果

2. 如果为true执行语句体1

3. 如果为false执行语句体2

2.3 if第三种格式

if (判断条件1) {
  语句体1;

} else if (判断条件2) {

  语句体2;

}

...

else {

  语句体n+1;

}

执行流程：

1. 计算判断条件1的值

2. 如果为true执行语句体1，否则计算判断条件2的值

3. 依此类推，如果所有条件都不满足则执行else语句体

2.4 应用场景

• 根据条件选择执行某段程序

• 示例：考试奖励

• 90~100分：奖励笔记本电脑

• 80~89分：奖励平板电脑

• 60~79分：奖励书籍

• 60分以下：没有奖励

2.5 if语句注意事项

1. 如果大括号控制的是一条语句，大括号可以省略

2. if语句的()和{}之间不要写分号

3. if语句的()中需要产生boolean类型的结果

3. 分支结构 switch

3.1 执行流程

1. 计算表达式的值

2. 与case后的值进行匹配

3. 匹配成功执行对应case块的代码，遇到break跳出switch

4. 如果全部不匹配执行default块的代码

3.2 格式

switch(表达式) {
  case 值1:

  语句体1;
  
  break;
  
  case 值2:
  
  语句体2;
  
  break;

  ...
  
  default:
  
  语句体n+1;
  
  break;

}

3.3 if与switch比较

• if适合：条件是区间判断的情况

• switch适合：条件是比较值的情况，代码更优雅，性能较好

3.4 switch语句注意事项

1. 表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String

2. case值不允许重复，且只能是字面量，不能是变量

3. 正常使用switch时要写break，否则会出现穿透现象

4. Debug工具

4.1 概念

• 程序调试工具

• 用于查看程序执行流程

• 用于追踪程序执行过程来调试程序

4.2 断点调试

• 断点是一个标记，告诉Debug从标记的地方开始查看

• 调试功能：

• 程序向下执行一步

• 跳出当前方法

5. 循环结构 for

5.1 概念

• 让一段代码重复执行多次

5.2 格式

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

}

5.3 执行流程

1. 初始化语句

2. 条件判断语句(结果为true继续，false结束)

3. 循环体语句

4. 条件控制语句

5. 回到步骤2

5.4 应用案例

1. 打印10次"黑马程序员"

2. 模拟计时器(打印13和31)

3. 求1-100之间的偶数和

4. 输出水仙花数(三位数，各位数字立方和等于原数)

5.5 for循环注意事项

1. 循环{}中定义的变量在每一轮循环结束后释放

2. 循环()中定义的变量在整个循环结束后释放

3. 循环语句()和{}之间不要写分号

5.6 循环嵌套

• 在循环语句中继续出现循环语句

• 外循环执行一次，内循环执行一圈

• 示例：

• 打印4行5列的矩形

• 打印5行的直角三角形

6. 循环结构 while

6.1 格式

初始化语句;
  while(判断语句) {
  
  循环体语句;
  
  控制语句;

}

6.2 应用案例

• 珠穆朗玛峰折叠问题：

• 纸张厚度0.1毫米

• 山峰高度8848860毫米

• 计算折叠多少次可以达到山峰高度

6.3 while与for比较

• 功能完全相同

• 使用规范：

• 知道循环次数使用for

• 不知道循环次数使用while

7. 循环结构 do...while

7.1 格式

初始化语句;
do {
  
  循环体语句;
  
  条件控制语句;

} while(循环条件);

7.2 特点

• 先执行后判断

• 至少执行一次循环体

7.3 三种循环区别

1. for和while：先判断后执行

2. do...while：先执行后判断

3. for循环变量只在循环中使用，while循环变量在循环后还可以使用

8. break、continue

8.1 break

• 终止循环体内容的执行

• 结束当前整个循环

• 可以用于switch语句

8.2 continue

• 跳过某次循环体内容的执行

• 继续下一次的执行

8.3 注意事项

1. break只能在循环和switch中使用

2. continue只能在循环中使用

3. 循环嵌套时默认操作内层循环，可以使用标号控制

9. Random生成随机数

9.1 基本使用

import java.util.Random;
Random r = new Random();

int num = r.nextInt(n); // 生成0~n-1的随机数

9.2 生成指定范围随机数

• 生成1~100的随机数：

int num = r.nextInt(100) + 1;

9.3 应用案例

• 猜数字小游戏：

1. 生成1~100的随机数

2. 用户输入猜测数字

3. 比对结果给出提示

4. 直到猜中为止

总结

本章详细介绍了Java中的流程控制语句，包括：

1. 顺序结构：程序默认执行方式

2. 分支结构：if和switch语句及其应用场景

3. 循环结构：for、while和do...while循环及其应用案例

4. 控制语句：break和continue的使用

5. 调试工具：Debug的基本使用

6. 随机数生成：Random类的使用方法

掌握这些流程控制语句是Java编程的基础，能够实现程序的各种逻辑控制需求。

第七章：数组

一、数组基础概念

1. 数组定义：

• 数组是一种容器，可以存储同种类型的多个值

• 主要用于管理系统数据的多个值

2. 使用场景：

• 当需要操作的数据有多个，并且这些数据属于一个整体时使用数组

二、数组的定义和静态初始化

1. 数组定义格式：

• 格式一：数据类型[]数组名 (示例：int[] array)

• 格式二：数据类型数组名[] (示例：int array[])

2. 数组静态初始化：

• 初始化过程：在内存中为数组容器开辟空间，并将数据存入容器

• 完整格式：数据类型[]数组名 = new 数据类型[]{元素1,元素2,元素3...}

• 示例：int[] array = new int[]{11,22,33}

• 示例：double[] array2 = new double[]{11.1,22.2,33.3}

• 简化格式：数据类型[]数组名 = {元素1,元素2,元素3...}

• 示例：int[] array = {11,22,33}

• 示例：double[] array2 = {11.1,22.2,33.3}

3. 内存地址显示：

• 打印数组名会看到数组在内存中的十六进制地址值(如[I@10f87f48)

1. 小结：

• 数组定义格式：数据类型[]数组名

• 静态初始化格式：

• 完整格式：数据类型[]数组名 = new 数据类型[]{元素1,元素2,元素3...}

• 简化格式：数据类型[]数组名 = {元素1,元素2,元素3...}

• 打印数组名会显示十六进制内存地址

三、数组元素访问

1. 访问格式：

• 数组名[索引]

• 索引是数组容器中空间的编号，从0开始逐个+1增长

2. 相关属性：

• 数组名.length：动态获取数组的长度(元素的个数)

四、数组遍历操作

1. 遍历概念：

• 依次访问数组中的每一个元素

2. 案例1：求偶数和

• 需求：数组{11,22,33,44,55}，求偶数元素和

• 实现步骤：

1. 静态初始化数组

2. 定义求和变量

3. 遍历数组取出每一个元素

4. 判断当前元素是否是偶数，是则累加

5. 打印求和结果

3. 案例2：求最大值

• 需求：数组{5,44,33,55,22}，找出最大值

• 实现步骤：

1. 定义max变量记录最大值

2. 数组0号元素先赋值给max

3. 从1号索引开始遍历

4. 逐个比较，更新max值

5. 打印max值

4. 案例3：数组元素反转

• 需求：数组{11,22,33,44,55}反转为{55,44,33,22,11}

• 实现方法：

1. 使用两个指针变量start和end

2. 交换arr[start]和arr[end]

3. start++，end--

4. 交换条件：start < end

5. 具体交换过程：

• 第一次：arr[0]和arr[4]

• 第二次：arr[1]和arr[3]

• 第三次：arr[2]和arr2

五、数组动态初始化

1. 动态初始化概念：

• 初始化时只指定数组长度，由系统分配初始值

2. 格式：

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

• 示例：int[] arr = new int[3]

3. 默认初始值：

4. 特点：

• 手动指定长度，系统自动分配默认值

• 适用于不明确具体元素值的情况

5. 静态初始化vs动态初始化：

• 静态初始化：手动指定元素，系统计算长度

• 动态初始化：手动指定长度，系统分配默认值

6. 案例：评委打分

• 需求：6个评委打分(0-100)，去掉最高分和最低分后求平均

• 实现思路：

1. 定义数组存储分数

2. 找出最大值和最小值

3. 求和后减去最大最小值

4. 计算平均分

六、数组内存图

1. Java内存分配：

• 栈：存储局部变量

• 堆：存储new出来的对象

• 方法区：存储字节码文件

• 本地方法栈：JVM调用操作系统功能

• 寄存器：CPU使用

2. 数组内存特点：

• 数组在堆内存中开辟空间

• 数组有length属性记录长度

• 数组名存储的是数组在堆中的地址

3. 两个数组指向相同内存：

• 当一个数组变量赋值给另一个数组变量时，两个变量指向同一块内存

• 修改其中一个会影响另一个

4. 方法参数传递：

• 基本数据类型：传递的是值

• 引用数据类型：传递的是地址

七、数组常见问题

1. 索引越界异常(ArrayIndexOutOfBoundsException)：

• 访问了不存在的数组索引时抛出

2. 空指针异常(NullPointerException)：

• 数组引用为null时仍尝试访问数组元素

八、二维数组(了解)

1. 概念：

• 二维数组是存储一维数组的容器

2. 定义格式：

• 标准格式：数据类型[][]数组名 = new 数据类型[][]{{元素1,元素2},{元素1,元素2}}

• 简化格式：数据类型[][]数组名 = {{元素1,元素2},{元素1,元素2}}

3. 元素访问：

• 数组名[索引][索引]

4. 使用场景：

• 当需要操作的一维数组有多个且属于同一整体时使用

5. 案例：二维数组遍历

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

• 实现思路：

1. 外层循环遍历二维数组获取每个一维数组

2. 内层循环遍历一维数组获取每个元素

九、实际应用示例

1. 销售管理系统：

• 存储销售数据

• 计算最大值、最小值

• 计算销售总额

2. 数组操作示例：

• 初始数据：int a=10; int d=40; int b=20; int f=60; int e=50; int i=90; int g=70; int h=80;

排序后：20 10 80 60 90 40 50 30 70 90 (示例数据)

• 可进行的操作：

• 找出最大值

• 找出最小值

• 计算销售总额

第八章：面向对象基础

1. 面向对象介绍

• 概念：面向对象并不是一种技术，而是一种编程的指导思想。它决定了我们如何组织代码和解决问题。

• 学习原因：因为在生活中，我们解决问题时就是采用这种指导思想。因此，写程序时采用面向对象的思想，会使编程变得简单且易于理解。

2. 对象的概念

• 对象：对象是面向对象编程的核心概念。它是现实世界中事物的抽象表示，包含了属性（数据）和行为（方法）。

3. 类和对象

• 类：类是对象的模板或蓝图，定义了一组相关的属性和行为。

• 对象：对象是类的实例，通过类来创建。

类和对象的关系

• 在Java中，必须先有类才能创建对象。

• 一个类可以创建多个对象。

类的组成

• 属性：成员变量，描述事物的名词。

• 行为：成员方法，描述事物的动词。

创建对象和使用对象

1. 创建对象：类名 对象名 = new 类名();

2. 使用成员变量：对象名.变量名;

3. 使用成员方法：对象名.方法名(实际参数);

4. 面向对象的重点

• 设计对象：学习如何自己设计对象。

• 使用已有对象：掌握如何使用已有的对象。

5. 类和对象内存图

• 单个对象内存图：展示了对象在内存中的存储方式。

• 两个对象内存图：展示了多个对象在内存中的存储方式。

• 两个引用指向相同内存图：展示了两个引用指向同一个对象的内存情况。

6. 成员变量和局部变量的区别

7. this 关键字

• 作用：this 代表当前类对象的引用，用于区分成员变量和局部变量。

• 使用场景：当局部变量和成员变量重名时，使用 this 访问成员变量。

8. 构造方法

• 概念：构造方法是用于初始化新创建对象的方法。

• 特点：

• 方法名与类名相同。

• 没有返回值类型。

• 没有具体的返回值。

• 注意事项：

• 如果没有定义构造方法，系统会提供默认的无参构造方法。

• 如果定义了构造方法，系统不再提供默认的无参构造方法。

9. 封装

• 概念：封装是将数据和操作数据的方法捆绑在一起，组成一个类，并通过访问修饰符控制对类中属性和方法的访问权限。

• 优点：

• 更好地维护数据。

• 使用者无需关心内部实现，只需知道如何使用。

10. JavaBean

• 标准 JavaBean：

• 成员变量私有化。

• 提供相应的 getXXX 和 setXXX 方法。

• 提供无参和带参构造方法。

11. static 关键字

• 概念：static 是静态修饰符，可以修饰成员变量和成员方法。

• 特点：

• 被修饰的成员被所有对象共享。

• 可以通过类名直接调用。

• 随着类的加载而加载，优先于对象存在。

• 使用场景：

• 成员变量：需要共享的数据。

• 成员方法：工具类的方法。

总结

面向对象编程是一种重要的编程思想，通过类和对象的组织方式，使得代码更加模块化和易于维护。掌握面向对象的基本概念和特性，如封装、继承和多态，对于编写高效、可读性强的代码至关重要。