动力节点Java教程2024笔记（1-304集）

以下内容为B站动力节点的JAVA基础课程2024全部内容，课程链接如下：https://www.bilibili.com/video/BV1a5411y77c，该笔记根据课程资料整理，顺序按照课程PPT截图整理，附有部分个人的问题和重点整理，如有侵权请联系下架，后续会持续更新整理课程中的重难点，课程中有很多重点和细节部分值得反复思考、消化，个人觉得是很不错的JAVA课程

Idea快捷键

第一章 JAVA开发环境搭建

常用的windows组合键

• win + D 回到桌面
• win + E 打开资源管理器
• win + R 打开运行窗口
• win + L 锁屏
• alt + tab 应用间的切换

常用的dos命令

通用的文本编辑快捷键

JAVA特性

掌握环境变量CLASSPATH

// 深度剖析一段代码
// public表示公开的
// class表示定义一个类
// HelloWord 是给这个类起个名
public class HelloWorld {
    // 类体
    /**
    *	这是main方法，程序的入口，程序就是从这里进来开始执行的
    *	@param args 这个是main方法的参数
    */
    
    // 1. 这是main方法，也叫做主方法
    // 2. main方法是JVM规定的，固定写法，照抄即可。程序就是从这个位置进来执行的。这是程序的入口。
    // 3. 对于main方法来说，能修改的就只有args这个变量名
    // 4. public表示公开的
    // 5. static表示静态的
    // 6. void表示main方法执行结束后不再返回任何数据
    public static main(String[] args){
        // 这行代码的作用：将字符串"Hello World!"打印输出到控制台。并在输出后进行换行
        // 注意: 在一个java程序中，如果符号是语法的一部分，需要使用英文半角符号。不可使用中文。
        // 以下程序中双引号和分好都是半角的。不能是中文。
        System.out.println("Hello World!");
        
        // 方法体
        // 方法体当中由一行一行的java语句组成
        // 任何一条java语句必须以";"结尾。
        // 方法体中的代码是有执行顺序的，遵循自上而下的顺序依次逐行执行
        
        System.out.println("动力节点，一家只教授Java的培训机构");
        
        // 没有ln是不换行的
        System.out.println("abc");
        System.out.println("def");
        System.out.println("efg");
        // 添加了ln是换行的
        System.out.println("123");
    }
    
    // 类体
    // 编译报错，类体中不能直接输出Java语句
    // System.out.println("Hello World!");
}

第二章 Java基础语法

什么是关键字？

在java语言当中，具有特殊含义的单词

每个关键字都已经被java语言本身占用了，不能拿关键字做标识符

java语言中所有的关键字都是全部小写

什么是字面量？

程序中的数据就是字面量，字面量是Java中最基本的表达式，无需转换，直接使用即可

什么是变量？

1. 变量是内存当中的一块空间，是计算机中存储数据最基本的单元

2. 变量三要素：

   1. 数据类型（决定空间大小）
   2. 变量名（只要是合法的标识符即可）
   3. 变量值（变量中具体存储的数据）

3. 变量的声明、赋值、访问
   

变量中需要注意的细节：

1. 变量必须先声明，再赋值，才能进行访问
2. 方法体中的代码遵循自上而下的顺序依次逐行执行，变量先访问，再声明是绝对不行的
3. 一行代码可以同时声明多个变量
4. 在同一个作用域中，变量名不能重名，可以重新赋值
5. 变量值的数据类型必须和变量的数据类型一致，不允许的情况：String name = 100; 变量的值与数据类型不匹配就会报错

变量的作用域：

1. 作用域就是变量的有效范围，即出了{ }以后就不认识了
2. 作用域的不同，主要是因为声明在不同位置的变量具有不同的生命周期。所谓的生命周期就是：从内存开辟再到内存释放的过程
3. Java遵循就近原则

变量的分类

1. 局部分类
2. 成员变量
   1. 静态变量
   2. 实例变量

原码反码补码

数据类型-概述

整数型详解

浮点类型

字符编码

算术运算符

自增自减

栈和堆

自增自减的实现底层逻辑

关系运算符

逻辑运算符

int x = 99;
int y = 100;
// 逻辑与 & 在该过程中，条件一false，条件二仍然执行
System.out.println(x > y & x > ++y);
System.out.println("y = " + y); // y = 101

int x = 99;
int y = 100;
// 短路与&& 在该过程中，条件一false，条件二不执行
System.out.println(x > y && x > ++y);
System.out.println("y = " + y);// y = 100

如何快速让2变成8？

移位运算符，左移两位

三元运算符

控制语句

第三章 面向对象

面向对象概述

JVM虚拟机栈Java图解

初识this关键字

封装

构造方法/构造器

static关键字

JVM

设计模式

继承

方法覆盖和方法重写

多态

super关键字

final关键字

抽象类

接口

UML类图

访问控制权限

Object类

克隆图解

内部类

第四章 数组

数组概述

一维数组

数组的内存图

一维数组的扩容

二维数组

JUnit单元测试

数据结构与算法

数据的排序算法

数组的查找算法

Arrays工具类

第五章 异常

异常概述

异常的继承结构

自定义异常

异常的处理

异常的常用方式

Finally语句块

图书管理系统练习

第六章 常用类

String类

正则表达式

StringBuffer和StringBulider

StringBuilder

​ StringBuilder 是Java中一个用于创建和操作字符串的类，它属于 java.lang 包。与 String 类相比，StringBuilder 提供了一种更加灵活和高效的方式来处理字符串，特别是在涉及到频繁修改字符串内容的场景下。

以下是 StringBuilder 的一些关键特性：

1. 可变性： StringBuilder 对象的内容是可变的，这意味着你可以在不创建新对象的情况下修改它的内容。
2. 性能： 由于 String 类的不可变性，每次对字符串进行修改时，都会创建一个新的 String 对象。这在循环或频繁修改字符串的情况下会导致性能问题。相比之下，StringBuilder 可以在原有对象上进行修改，避免了不必要的对象创建和垃圾回收。
3. 线程安全性： StringBuilder 是非线程安全的，这意味着它在单线程环境中性能更优。如果你需要在多线程环境中使用，可以使用 StringBuffer，它是 StringBuilder 的线程安全版本。
4. 容量自动扩展： 当向 StringBuilder 中添加更多的字符时，如果超出了当前容量，它会根据需要自动扩展。
5. 方法丰富： StringBuilder 提供了多种方法来操作字符串，如 append(), insert(), delete(), replace(), substring() 等。
6. 使用场景： 当你需要构建或修改字符串时，特别是当你知道最终字符串的大小可能会变化时，使用 StringBuilder 是一个好选择。

StringBuilder和StringBuffer的区别和联系

StringBuffer 和 StringBuilder 都是Java中用于操作字符串的类，它们提供了一种方式来构建和修改字符串，而不需要像使用 String 类那样每次修改都创建一个新的对象。尽管它们在功能上有很多相似之处，但它们之间存在一些关键差异：

StringBuffer

1. 线程安全： StringBuffer 是线程安全的。这意味着它的方法是同步的，可以在多线程环境中安全使用，而不必担心数据不一致的问题。
2. 性能： 由于同步的开销，StringBuffer 在单线程环境下的性能不如 StringBuilder。
3. 使用场景： 当你需要在多线程环境中操作字符串时，应该使用 StringBuffer。

StringBuilder

1. 非线程安全： StringBuilder 是非线程安全的。这意味着它的方法不是同步的，因此在单线程环境中性能更优。
2. 性能： 在单线程环境中，StringBuilder 通常比 StringBuffer 有更好的性能，因为它避免了同步带来的开销。
3. 使用场景： 当你确定你的代码运行在单线程环境中，或者你已经通过其他方式处理了线程安全问题时，使用 StringBuilder 是更好的选择。

共同点

• 两者都继承自 AbstractStringBuilder 类，这意味着它们共享许多基本的字符串操作方法，如 append(), insert(), delete(), replace() 等。
• 两者都允许在字符串上进行修改操作，如追加、插入、删除和替换，而不需要创建新的字符串对象。
• 两者都提供了一个可变的字符序列的动态数组，可以根据需要自动扩展。

示例代码：

// StringBuffer示例
StringBuffer stringBuffer = new StringBuffer("Hello");
stringBuffer.append(" World");
System.out.println(stringBuffer.toString()); // 输出 "Hello World"

// StringBuilder示例
StringBuilder stringBuilder = new StringBuilder("Hello");
stringBuilder.append(" World");
System.out.println(stringBuilder.toString()); // 输出 "Hello World"

在选择使用 StringBuffer 还是 StringBuilder 时，需要根据你的具体需求和运行环境来决定。如果你的代码将在多线程环境中运行，并且多个线程可能会同时修改同一个字符串对象，那么使用 StringBuffer 是更安全的选择。如果你确定你的代码是单线程的，或者你已经通过其他方式确保了线程安全，那么 StringBuilder 将提供更好的性能。

包装类

拆箱装箱

整数型常量池

大数字

数字格式化

日期处理

Java8新API

Math类

枚举

Random

System系统类的使用方法

UUID

Integer.valueOf(int i)和new Integer(int i)方法的区别

1. 使用 Integer.valueOf(int i) 方法：
   • 这个方法使用了缓存机制。Java虚拟机（JVM）会缓存从 -128 到 127 范围内的 Integer 对象。如果你使用 Integer.valueOf 并传入这个范围内的值，它将返回缓存中的 Integer 对象，而不是每次都创建一个新的对象。
   • 例如，如果你调用 Integer.valueOf(100)，JVM 会检查缓存中是否有 100 的 Integer 对象，如果有，就直接返回它，否则创建一个新的对象并加入缓存。
2. 使用 new Integer(int i) 构造函数：
   • 每次使用 new Integer(100) 都会创建一个新的 Integer 对象，不管这个值是否在 -128 到 127 的范围内。
   • 这种方法不使用缓存，因此如果频繁地创建相同值的 Integer 对象，可能会导致更多的内存使用。

总结来说，推荐使用 Integer.valueOf 方法，因为它可以减少内存使用，并提高性能，特别是对于在 -128 到 127 范围内的整数。而对于超出这个范围的整数，虽然 Integer.valueOf 不再使用缓存，但仍然推荐使用它，因为它是Java语言规范中推荐的方式。

euqals()方法 和 == 运算符的区别和联系

在Java中，equals() 方法和 == 运算符是用于比较两个对象或基本数据类型的值的两种不同方式。它们之间有以下区别和联系：

区别：

1. 用途：

   • == 用于比较两个基本数据类型的值是否相等，或者两个对象引用是否指向内存中的同一位置（即是否是同一个对象）。
   • equals() 是一个方法，用于比较两个对象的内容或状态是否相等，通常用于对象类型。

2. 默认行为：

   • 对于原始数据类型，== 直接比较它们的值。
   • 对于对象，== 比较的是引用，即它们是否指向内存中的同一个位置。
   • equals() 默认行为是调用 == 来比较对象引用，但大多数类会重写这个方法，以比较对象的逻辑状态或内容。

3. 可重写性：

   • == 不能被重写，它的行为始终是检查引用是否相等。
   • equals() 方法可以被重写，允许开发者定义对象内容的相等性。

4. 语义：

   • == 通常用于检查对象的引用是否相同，即是否是同一个对象。
   • equals() 用于检查对象的内容或逻辑状态是否相同，即使它们不是同一个对象。

联系：

• 在Java中，对于对象引用，equals() 方法默认的行为是使用 == 来比较两个对象引用是否相同。这意味着，如果你没有重写 equals() 方法，equals() 和 == 的行为是相同的。

• 当你重写 equals() 方法时，通常也应该重写 hashCode() 方法，以保持 equals() 和 hashCode() 之间的一致性。这是为了确保当对象作为键在散列表（如 HashMap）中使用时，具有相同内容的对象具有相同的哈希码，并且被认为是相等的。

示例：

String s1 = new String("hello");
String s2 = new String("hello");

// 使用 == 比较引用
System.out.println(s1 == s2); // 输出 false，因为 s1 和 s2 是两个不同的对象

// 使用 equals() 比较内容
System.out.println(s1.equals(s2)); // 输出 true，因为内容相同

在这个例子中，尽管 s1 和 s2 引用了两个不同的对象，但它们的内容相同，因此 equals() 返回 true。如果 equals() 方法没有被重写，它将和 == 一样，返回 false。

InstanceOf的作用

在Java中，instanceof 是一个一元操作符，用于检查它左边的对象是否是其右边类或接口的实例。如果左边的对象是右边类或接口的实例，那么 instanceof 将返回 true；否则返回 false。

语法：

object instanceof class_or_interface

• object 是要检查的对象。
• class_or_interface 是要检查的类或接口。

示例：

Object obj = "Hello, World!";
System.out.println(obj instanceof String); // 输出 true，因为 obj 是 String 类的一个实例
System.out.println(obj instanceof Integer); // 输出 false，因为 obj 不是 Integer 类的实例

特点和用途：

1. 类型检查： instanceof 常用于多态情况下，检查对象的实际类型。
2. 安全转型： 在使用 instanceof 确认了对象的实际类型后，可以安全地将对象转型为那个类型，而不用担心 ClassCastException。
3. 接口检查： instanceof 也可以用来检查对象是否实现了某个接口。
4. 继承检查： 如果一个类继承自另一个类，该类的实例也将是父类的实例，instanceof 将返回 true。

注意事项：

• instanceof 操作符不会检查接口的实现，只有当对象实际是某个类的实例时，它才会返回 true。
• 对于数组和类，instanceof 的行为略有不同。例如，如果一个数组是某个类型的数组，使用 instanceof 检查该数组是否是该类型的数组将返回 true。

示例代码：

Integer num = 42;
System.out.println(num instanceof Number); // 输出 true，因为 Integer 继承自 Number
System.out.println(num instanceof Object);  // 输出 true，因为 Integer 继承自 Object
System.out.println(num instanceof int);     // 输出 false，因为 int 是基本数据类型，不是类或接口

在这个示例中，num 是 Integer 类的一个实例，Integer 类继承自 Number 和 Object 类，所以 instanceof 检查返回 true。然而，int 是一个基本数据类型，不是类或接口，所以返回 false。