本文章知识点为蔡豪辉所总结，若有错误请指正
第一章：初识JAVA与面向对象程序
一、Java简介
Java是一种高级编程语言，最初由Sun Microsystems的James Gosling等人于1995年开发，最初被称为Oak，由于Oak名字已经被注册，最终改名为Java。Java语言的设计目标是“一次编写，到处运行”，这使得它在跨平台应用中超级受欢迎。Java语言具有简单性、面向对象、分布式、健壮性、安全性、体系结构中立、可移植性、高性能、多线程和动态性等特点，这些特点使得Java成为开发企业级应用的理想选择。Java的跨平台特性主要得益于JVM（Java Virtual Machine），JVM是一个虚拟机，可以在不同的操作系统上运行。Java代码首先被编译成字节码，然后由JVM解释执行，这种方式使得Java代码可以在任何支持JVM的平台上运行。
二、面向对象程序设计
面向对象程序设计（Object-Oriented Programming，OOP）是一种编程范式，它将数据和处理数据的方法绑定在一起，形成对象。OOP强调的是对象之间的交互，而不是具体的步骤。这种范式有助于提高代码的复用性和可维护性。面向对象程序设计相较于面向过程程序设计，更加强调数据的封装、继承和多态等特性。这些特性使得代码更加模块化，易于扩展和维护。
三、Java开发环境搭建
JDK与JRE：
JDK（Java Development Kit）是Java开发工具包，包含了JRE（Java Runtime Environment）以及一些开发工具，如javac编译器、javadoc文档生成器等。
JRE是Java运行时环境，包含了JVM和一些基础类库，用于运行Java应用程序。
安装JDK：
需要下载合适的版本，并按照安装向导进行安装。
安装过程中需要注意选择合适的路径，并确保安装成功。
配置环境变量：
为了能够在命令行中使用Java命令，需要配置环境变量。
通常需要设置JAVA_HOME变量指向JDK的安装目录，并将%JAVA_HOME%in添加到PATH变量中
。
四、第一个Java程序：HelloWorld
显示文件扩展名：在Windows系统中，默认情况下文件扩展名是隐藏的，可以通过修改文件夹选项来显示文件扩展名。
编写代码：创建一个名为HelloWorld.java的文件，并在其中编写以下代码：
五、Java常用开发工具
Eclipse：一款流行的Java IDE（Integrated Development Environment），提供了丰富的功能，如代码编辑、调试、版本控制集成等。
IntelliJ IDEA：另一款强劲的Java IDE，以其智能代码补全、快速导航和高效的重构功能而闻名。
六、总结
本章主要重点是要能够正确的配置和安装使用IDEA，要注意IDEA的环境配置问题
第二章：JAVA编程基础
一、Java基础概念
变量与常量
变量：在Java中，变量必须先声明再使用，且变量名需要遵守小写字母开头的驼峰规则。变量可以改变值。
常量：在变量声明前加上final关键字，常量一旦被赋值，不可改变。
例如
// 变量声明与赋值
int number = 10;
double pi = 3.14;
char letter = ‘A’;
boolean flag = true;
// 常量声明与赋值
final int MAX_VALUE = 100; // 常量不可改变
数据类型
Java中的数据类型分为基本数据类型和引用数据类型。
基本数据类型包括整型（byte, short, int, long）、浮点型（float, double）、字符型（char）和布尔型（boolean）。
引用数据类型包括类、接口、数组等。
数据类型转换
自动类型转换：占用字节数少的数据类型的值可以直接赋值给占用字节数多的数据类型的变量。
强制类型转换：强制性地占用字节数多的数据类型的数据转换成占用字节数少的数据类型的数据，但这个转换可能存在数据精度丢失问题。
例如：
double a = 5.7;
int b = (int) a; // 强制类型转换，结果为5
二、运算符与表达式
运算符
算术运算符：+，-，*，/，%，++，–等。
例如：
int sum = 5 + 3; // 加法
int diff = 5 – 3; // 减法
int product = 5 * 3; // 乘法
int quotient = 5 / 2; // 除法，结果为2（整数除法）
int remainder = 5 % 2; // 取余，结果为1
赋值运算符：=，+=，-=，*=，/=等。
关系运算符：>，<，>=，<=，==，!=等。
逻辑运算符：&&，||，!等。
例如：
boolean x = true;
boolean y = false;
boolean andResult = x && y; // 逻辑与，结果为false
boolean orResult = x || y; // 逻辑或，结果为true
boolean notResult = !x; // 逻辑非，结果为false
位运算符：&，|，^，~，<<，>>等。
三元运算符：? :。
表达式
表达式由运算符和操作数组成，用于计算值或产生效果。
三、选择结构与循环结构
选择结构
if语句：根据条件判断执行不同的代码块。
例如：
int score = 85;
if (score >= 90) {
System.out.println(“优秀”);
} else if (score >= 60) {
System.out.println(“及格”);
} else {
System.out.println(“不及格”);
}
switch语句：根据表达式的值选择执行不同的代码块，适用于多个准确值的判断。
例如：
char grade = ‘B’;
switch (grade) {
case ‘A’:
System.out.println(“优秀”);
break;
case ‘B’:
case ‘C’:
System.out.println(“良好”);
break;
default:
System.out.println(“其他”);
}
循环结构
for循环：常用于知道边界的循环。
例如：
for (int i = 0; i < 5; i++) {
System.out.println(“i = ” + i);
}
while循环：常用于不知道边界的循环。
例如：
int count = 0;
while (count < 5) {
System.out.println(“count = ” + count);
count++;
}
do-while循环：至少执行一次循环体，之后再判断表达式是否成立，成立则再次执行循环体，否则循环结束。
例如：
int num = 0;
do {
System.out.println(“num = ” + num);
num++;
} while (num < 5);
四、方法
方法声明与调用
方法必须先声明才能在其代码中调用。方法声明包括修饰符、返回值类型、方法名和参数列表。
方法调用通过方法名和参数进行，调用后方法体中的代码被执行。
例如：
// 方法声明
public int add(int a, int b) {
return a + b;
}
// 方法调用
int result = add(3, 4); // 调用add方法，结果为7
方法重载
方法重载是指同一个类中可以有多个方法名一样但参数个数或类型不同的方法。重载的方法具有不同的功能。
例如：
// 方法重载示例
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
// 调用重载的方法
int sumInts = add(3, 4); // 调用int类型的add方法
double sumDoubles = add(3.5, 4.5); // 调用double类型的add方法
五、数组
数组声明与初始化
数组是一种数据结构，用于存储一样类型的多个元素。数组元素可以通过索引进行访问。
数组声明包括元素类型和数组名，初始化可以通过赋值语句或new关键字进行。
例如：
// 静态初始化
int[] numbers = {1, 2, 3, 4, 5};
// 动态初始化
String[] names = new String[5];
names[0] = “Alice”;
names[1] = “Bob”;
数组操作
可以对数组进行遍历、排序、查找等操作
例如：
// 遍历数组
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
// 查找数组中的最大值
int max = numbers[0];
for (int i = 1; i < numbers.length; i++) {
if (numbers[i] > max) {
max = numbers[i];
}
}
System.out.println(“Max value: ” + max);
六、总结
本章中主要是对java基础编程的一些概念性的话术进行总结，主要是要学会对一些数据的区分还有最重大的循环语句进行举例说明，使读者能够通过运算符，还有对变量的执行运算等从而实现一些简单的事件判断和数据运算，同时还讲述了方法的创建，使用和调用，递归等，简化代码的复杂性，将数组和循环结合起来达到用最小的时间取到想要的数组数据
第三章 面向对象程序设计（基础）
概念：面向对象（Object Oriented，简称OO）是一种计算机编程的思想和方法，其核心是将程序中的行为主体定义为对象。以下是关于面向对象概念的详细解释：
一、基本概念
对象：对象是面向对象程序的基本构成单元，它包含了数据（属性）和操作数据的方法。对象可以看作是现实世界中的实体，例如人、汽车、动物等，它们都具有一些属性和行为。
类：类是对象的抽象，它定义了对象的结构和行为。类是具有一样特性（数据元素）和行为（功能）的对象的抽象。因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象。类实际上就是一种数据类型，它包含了类变量（定义在类中且在函数体之外的变量）和类方法（类中定义的函数）。
二、基本特性（对象，封装，多态）
类和对象的关系：
类是对一类事物的抽象，提取共有属性和行为。
对象是类的具体实例，具有确定的属性值。例如，“学生”是类，“具体的某个学生”是对象。
封装：
隐藏对象内部细节，仅提供公共访问方式，确保数据安全和使用简便。
继承：
子类可继承父类的属性和方法，实现代码复用与功能扩展。
多态：
同一方法调用因对象不同而产生不同行为，增强程序灵活性与扩展性。
类定义：
使用class关键字定义类，一个.java文件可包含多个类，但只能有一个public类且类名与文件名一致。
类名遵循大写字母开头的驼峰命名规则，由变量（字段）和方法组成。
成员变量和方法：
变量定义格式为“修饰符 变量类型 变量名 = [默认值];”。
方法定义格式为“修饰符 返回值类型 方法名(形参列表) {}”。
对象创建：
通过new关键字创建对象，语法为“类名称 对象名称 = new 类名称();”。
成员变量和成员方法隶属于对象，不同对象的成员变量独立存储，互不干扰。
构造方法：
用于对象初始化，给成员变量赋初始值，名称与类名一样，无返回值且不能有return关键字。
每个类必须有构造方法，若未定义，编译器自动提供默认无参构造方法。
例如：
public class Person {
private String name;
private int age;
// 无参构造方法
public Person() {
this.name = “Unknown”;
this.age = 0;
}
// 带参构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
this关键字：
在成员方法或构造方法中代表当前对象，用于调用当前对象的成员变量、成员方法或构造方法。
例如：
public class Person {
String name;
public Person(String name) {
this.name = name;
}
public Person setName(String name) {
this.name = name;
return this; // 返回当前对象
}
public void printName() {
System.out.println(this.name);
}
public static void main(String[] args) {
Person person = new Person(“David”).setName(“Eva”).printName(); // 输出: Eva
}
}
static关键字：
修饰成员变量（静态变量或类变量）、成员方法和构造代码块。
静态变量优先于对象存在，随类加载而存在，类的所有实例共享同一静态变量。
静态方法属于类，优先于对象存在，可通过“类名.方法名”调用，不能使用this关键字，不能调用成员变量和成员方法（非静态）
例如：
// Student.java
package com.yyds.unit3.demo;
public class Student {
String name;
int age;
static String grade; // 静态变量
// 静态方法
public static void goHome() {
System.out.println(“学生回家”);
}
public static void main(String[] args) {
// 通过类名调用静态变量和方法
Student.grade = “三年级”;
Student.goHome();
// 通过对象名调用静态变量（不推荐）
Student student1 = new Student();
System.out.println(student1.name + “在” + Student.grade + “学习”);
}
}
包
概念：包是Java命名空间机制的一部分，它使用树形结构来组织相关的类、接口和子包。通过使用包，开发者可以将相关的功能模块分组，使代码更加模块化、结构化和易于管理。在Java源代码文件中，包的声明位于文件的最顶部，使用package关键字进行声明
总结
在深入学习Java面向对象程序设计的第三章后，我深刻感受到了面向对象编程（OOP）的强劲与灵活性。这一章的学习加深了我对类和对象的概念,分别介绍了类的定义方式和对象的创建与使用,。接着介绍了构造方法,使用户能够更加灵活地创建对象,并对对象中的成员变量进行更便捷的初始化,而当成员变量和局部变量存在重名时,成员变量需要加上 this关键字,这一点需要注意再者,介绍了 static 关键字的使用,分别演示了静态变量、静态方法、静态代码块与非静态变量、方法、代码块的区别。还概述了关键字package的思想以及介绍了package的使用。
第四章 面向对象程序设计（进阶版）
一、继承
继承的概念
继承是面向对象编程中的一个核心概念，允许子类继承父类的属性和方法。
通过继承，子类可以重用父类的代码，实现代码的扩展和复用。
类的继承关系
使用extends关键字来实现类的继承。
Java只支持单继承，即一个类只能有一个直接父类。
子类可以拥有父类的属性和方法，也可以增加新的属性和方法。
方法重写
子类可以重写父类中的方法，以提供特定的实现。
重写的方法必须具有一样的名称、返回类型和参数列表。
重写的方法可以使用@Override注解来明确标识。
super关键字
super用于引用父类的构造方法、属性和方法。
在子类的构造方法中，如果需要使用父类的构造方法，则必须使用super()调用。
通过super可以调用父类的属性和方法，实现子类对父类行为的复用和扩展。
访问修饰符
访问修饰符用于控制类、接口、变量、方法的访问权限。
Java中的访问修饰符包括：private（私有）、默认（无修饰符，包访问权限）、protected（受保护）和public（公有）。
二、多态性
多态性的概念
多态性允许父类类型的引用变量指向子类对象。
通过多态性，可以在运行时动态地确定调用哪个类的方法，实现方法的动态绑定。
对象的类型转换
向上转型：子类对象转换为父类对象，这是安全的。
向下转型：父类对象转换为子类对象，需要显式地进行类型转换，并可能引发ClassCastException异常。
instanceof关键字
使用instanceof关键字可以检查一个对象是否是某个类的实例。
这在进行向下转型之前超级重大，可以避免类型转换错误。
三、类
父类和子类的定义
定义一个父类，包含一些属性和方法。
定义一个子类，继承父类，并可以重写父类的方法或增加新的方法。
构造方法的调用
在子类的构造方法中，使用super()调用父类的构造方法。
方法的重写和调用
在子类中重写父类的方法，并通过父类类型的引用调用子类重写的方法。
对象的类型转换和检查
使用instanceof关键字检查对象的类型，并进行必要的类型转换。
代码示例：
// 父类：动物
class Animal {
String name;
// 父类的构造方法
Animal(String name) {
this.name = name;
}
// 父类的方法
void makeSound() {
System.out.println(name + ” makes a generic animal sound”);
}
}
// 子类：狗
class Dog extends Animal {
// 子类的构造方法，调用父类的构造方法
Dog(String name) {
super(name); // 使用super调用父类的构造方法
}
// 重写父类的方法
@Override
void makeSound() {
System.out.println(name + ” barks”);
}
// 子类特有的方法
void fetch() {
System.out.println(name + ” is fetching a ball”);
}
}
// 子类：猫
class Cat extends Animal {
// 子类的构造方法，调用父类的构造方法
Cat(String name) {
super(name); // 使用super调用父类的构造方法
}
// 重写父类的方法
@Override
void makeSound() {
System.out.println(name + ” meows”);
}
// 子类特有的方法
void scratch() {
System.out.println(name + ” is scratching a post”);
}
}
public class InheritancePolymorphismDemo {
public static void main(String[] args) {
// 父类类型的引用指向子类对象（多态性）
Animal myDog = new Dog(“Buddy”);
Animal myCat = new Cat(“Whiskers”);
// 调用的是子类重写的方法
myDog.makeSound(); // 输出：Buddy barks
myCat.makeSound(); // 输出：Whiskers meows
// 使用instanceof关键字检查对象的类型，并进行类型转换
if (myDog instanceof Dog) {
Dog dog = (Dog) myDog;
dog.fetch(); // 输出：Buddy is fetching a ball
}
if (myCat instanceof Cat) {
Cat cat = (Cat) myCat;
cat.scratch(); // 输出：Whiskers is scratching a post
}
}
}
三、接口的基本概念
定义：接口是一个引用类型，是一种抽象的类型，它是方法声明的集合。一个类通过继承接口，从而继承接口中声明的方法。但方法的实现由类来完成。
作用：
定义行为：接口为类提供了一种规范，规定了类必须实现哪些方法。
解耦：通过接口，可以降低类之间的耦合度，提高系统的可扩展性和灵活性。
多态：接口是实现多态的基础，允许使用接口的引用来指向实现了该接口的类的实例。
接口的特点
抽象性：接口中的方法都是抽象的，没有方法体。
多重继承：一个类可以实现多个接口，从而继承多个接口中的方法。这是Java等语言支持的一种特性，而C++中的多重继承是通过多重基类来实现的，但存在二义性和复杂性等问题。
隐藏具体实现：接口只关心方法名、参数和返回类型，而不关心方法的具体实现。
互操作性：接口提供了一种在不同模块或不同系统之间进行通信的标准方式。
接口与类的关系
继承：一个类可以使用关键字implements来实现一个或多个接口。
实现：类必须提供接口中所有方法的实现，否则该类必须声明为抽象类。
默认方法和静态方法（Java 8及以上版本）：接口可以包含默认方法和静态方法，这为接口的进化提供了更多的灵活性。
默认方法：使用default关键字修饰，允许在接口中提供方法的默认实现。
静态方法：使用static关键字修饰，可以通过接口名直接调用。
接口与抽象类的区别
抽象类：
可以包含抽象方法和具体方法。
可以包含字段（成员变量）。
只能单继承（一个类只能继承一个抽象类）。
接口：
只能包含抽象方法（直到Java 8引入了默认方法和静态方法）。
不能包含字段（直到Java 8引入了静态字段，但不允许实例字段）。
可以多实现（一个类可以实现多个接口）。
例如：
// 定义一个接口
public interface Animal {
void eat();
void sleep();
// Java 8引入的默认方法
default void breathe() {
System.out.println(“Breathing…”);
}
// Java 8引入的静态方法
static void info() {
System.out.println(“This is an Animal interface.”);
}
}
// 实现接口的类
public class Dog implements Animal {
@Override
public void eat() {
System.out.println(“Dog is eating.”);
}
@Override
public void sleep() {
System.out.println(“Dog is sleeping.”);
}
// 可以选择性地覆盖默认方法
@Override
public void breathe() {
System.out.println(“Dog is breathing through lungs.”);
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
myDog.eat();
myDog.sleep();
myDog.breathe();
// 调用接口的静态方法
Animal.info();
}
}
内部类概述
内部类是指定义在另一个类内部的类。根据使用场景和定义方式的不同，内部类主要可分为以下几种类型：
成员内部类：这是最常见的内部类类型，它看起来像是外部类的一个成员，并拥有与外部类成员类似的访问权限。成员内部类可以访问外部类的所有成员，包括私有成员。
局部内部类：局部内部类是定义在方法或者作用域内的类，它仅在该方法或代码块内有效。局部内部类可以访问外部类的所有成员，但不能有访问修饰符和static修饰符。
匿名内部类：匿名内部类是没有名称的内部类，通常用于简化代码编写，常见于实现接口或继承抽象类的实例化。
静态内部类：静态内部类是使用static关键字修饰的内部类，它不同于成员内部类，静态内部类不依赖于外部类的实例，可以直接通过外部类名访问。静态内部类不能访问外部类的非静态成员，但可以访问静态成员。
总结
本章以面向对象的三大特性:封装、继承、多态为核心,介绍了许多知识点,这些知识点都是为这三大特性服务的。
首先,介绍了访问修饰符和get()、set()方法的使用,从而将变量进行了封装,使外界无法直接访问变量,取而代之的则是提供了公共的访间方法,从而保障了变量的安全性。接着,介绍了继承,使类与类之间存在了必定的联系,为后面的多态打下了基础。在继承中,变量和方法的访问不同,通过一个内存图解介绍了super关键字的使用。接着介绍了final关键字和Object类,并对继承进行了详细介绍。
之后以前面的知识点为基础,介绍了多态特性,并通过抽象类、接口的使用,使程序的展性、复用性更强。实际上,抽象类、接口、内部类都是为多态服务的,通过合理使用多态,可以让程序的耦合性更小,代码更易扩展。
第五章 异常
一、异常的基本概念
定义：异常是程序在运行时出现的不正常情况或错误，这些错误会打断程序的正常执行流程。
异常类型：
Error：系统级错误，通常由JVM抛出，无法被程序员捕获和处理。
Exception：程序级异常，可以被程序员捕获并处理。其中，RuntimeException及其子类称为运行时异常，其他异常称为受检异常（checked exception）。
二、异常的处理机制
try-catch语句：
try块：包含可能产生异常的代码。
catch块：用于捕获并处理try块中抛出的异常。可以有多个catch块来捕获不同类型的异常。
finally块：
finally块中的代码无论是否发生异常都会执行，常用于释放资源，如关闭文件、数据库连接等。
throws关键字：
在方法签名中使用throws关键字声明该方法可能抛出的异常类型。调用该方法的代码需要处理这些异常或继续向上声明。
throw关键字：
用于显式地抛出一个异常实例。通常与自定义异常类一起使用。
三、常见的异常类型
空指针异常（NullPointerException）：当应用程序尝试在需要对象的地方使用null时抛出。
数组越界异常（ArrayIndexOutOfBoundsException）：当索引超出字符串或数组的长度时抛出。
类型转换异常（ClassCastException）：当尝试将对象强制转换为不是实则例的类时抛出。
数字格式异常（NumberFormatException）：当应用程序尝试将字符串转换为一种数值类型，但该字符串没有有效的转换格式时抛出。
文件未找到异常（FileNotFoundException）：当尝试打开指定路径名表明的文件失败时抛出。
算术异常（ArithmeticException）：如整数除零时抛出。
四、自定义异常
定义：程序员可以根据自己的需求定义新的异常类。
实现：自定义异常类通常通过继承Exception类或其子类来实现，并可以重载有参构造方法来传递异常信息。
五、异常处理的原则
避免异常：在编写代码时，应尽可能避免异常的发生。例如，在访问数组元素之前检查索引的有效性，在调用对象方法之前检查对象是否为null等。
捕获并处理异常：对于可能发生的异常，应使用try-catch语句块进行捕获和处理。在处理异常时，应根据异常的类型和上下文信息选择合适的处理方式。
不要滥用异常：异常不应被用作程序流程控制的手段。过度使用异常可能会导致代码的可读性和可维护性降低。
记录异常信息：在处理异常时，应记录异常的相关信息，如异常类型、异常消息、异常发生的堆栈跟踪等。这些信息对于调试和定位问题超级有协助。
示例1：基本的异常处理机制
public class BasicExceptionHandling {
public static void main(String[] args) {
try {
// 可能抛出异常的代码
int[] numbers = {1, 2, 3};
System.out.println(numbers[5]); // 这将抛出ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
// 捕获并处理ArrayIndexOutOfBoundsException
System.out.println(“数组索引越界：” + e.getMessage());
} catch (Exception e) {
// 捕获并处理其他所有异常（虽然在这个例子中不会被捕获到）
System.out.println(“发生了一个异常：” + e.getMessage());
} finally {
// 无论是否发生异常，都会执行的代码
System.out.println(“这是finally块，无论是否发生异常都会执行。”);
}
}
}
示例2：自定义异常
// 自定义异常类
class MyCustomException extends Exception {
public MyCustomException(String message) {
super(message);
}
}
public class CustomExceptionHandling {
public static void main(String[] args) {
try {
// 调用可能抛出自定义异常的方法
checkAge(-5);
} catch (MyCustomException e) {
// 捕获并处理自定义异常
System.out.println(“捕获到自定义异常：” + e.getMessage());
}
}
public static void checkAge(int age) throws MyCustomException {
if (age < 0) {
throw new MyCustomException(“年龄不能为负数！”);
}
System.out.println(“年龄检查通过，年龄是：” + age);
}
}
五、方法重写异常
子类重写父类方法时，编译时异常声明遵循如下两点即可。运行时异常不受这两点约束。
父类方法没有声明异常，子类重写该方法不能声明异常，如下所示。
父类方法声明了异常，子类重写该方法可以不声明异常，或者只声明父类的异常或该异常的子类，如下所示
总结
本章主要介绍了异常的使用。首先对异常的概念和体系进行了介绍,通过继承关系讲述了异常的分类,以及异常与错误的区别。然后介绍了异常的抛出、声明、捕获,要求开发者对能够预知到的异常必须进行处理。接着介绍了自定义异常,开发者可以尽可能地根据业务场景定义出对应的异常,从而便于在生产环境中排查错误。
第六章：Java常用的类
一、包装类
定义：Java为每种基本数据类型提供了对应的包装类，使得基本数据类型可以作为对象来处理。
特点：包装类是不可变的，即一旦构造了包装器对象，就不能修改包装在其中的值。包装类还是final类，因此不能定义它们的子类。
用途：在需要将基本数据类型作为对象传递或需要对象特性的场合（如使用集合类时），可以使用包装类。
代码示例：
public class WrapperClassExample {
public static void main(String[] args) {
// 使用自动装箱将基本数据类型转换为包装类对象
Integer num1 = 10;
// 使用构造方法创建包装类对象
Integer num2 = new Integer(20);
// 使用包装类对象的方法
System.out.println(“num1的值: ” + num1.intValue()); // 将包装类对象转换为基本数据类型
System.out.println(“num2的字符串表明: ” + num2.toString());
// 比较包装类对象（注意：比较值应使用equals方法，而不是==）
Integer num3 = 100;
Integer num4 = 100;
System.out.println(num3 == num4); // false，由于num3和num4指向不同的对象（对于-128到127之间的值，Java会进行缓存）
System.out.println(num3.equals(num4)); // true，由于值相等
}
}
二、String类
定义：String类代表字符串，是Java中常用的类之一。
不可变性：String类的对象是不可变的，即创建后不能修改其内容。
常用方法：包括length()、charAt()、substring()、indexOf()、trim()、toLowerCase()、toUpperCase()等，用于获取字符串长度、字符、子字符串、查找字符位置、去除空格、转换大小写等操作。
代码示例：
public class StringExample {
public static void main(String[] args) {
String str1 = “Hello”;
String str2 = “World”;
// 字符串拼接
String str3 = str1 + ” ” + str2;
System.out.println(str3); // 输出：Hello World
// 获取字符串长度
int length = str3.length();
System.out.println(“字符串长度: ” + length);
// 查找字符位置
int index = str3.indexOf(“World”);
System.out.println(“World的索引位置: ” + index);
// 去除空格
String trimmedStr = ” Hello World “.trim();
System.out.println(“去除空格后的字符串: ” + trimmedStr);
// 转换大小写
String lowerStr = str3.toLowerCase();
String upperStr = str3.toUpperCase();
System.out.println(“小写字符串: ” + lowerStr);
System.out.println(“大写字符串: ” + upperStr);
}
}
三、StringBuffer和StringBuilder类
定义：StringBuffer和StringBuilder类都表明可变的字符序列，与String类的不可变性形成对比。
区别：StringBuffer是线程安全的，而StringBuilder是非线程安全的。因此，在单线程环境下，StringBuilder的性能通常比StringBuffer更高。
常用方法：包括append()、insert()、reverse()、delete()等，用于在字符串缓冲区中追加、插入、反转、删除字符或字符串。
代码示例：
public class StringBuilderExample {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder(“Hello”);
// 追加字符
sb.append(” “);
sb.append(“World”);
// 插入字符
sb.insert(5, “!”);
// 反转字符串
sb.reverse();
// 删除字符
sb.delete(0, 1); // 删除第一个字符
// 获取字符串
String str = sb.toString();
System.out.println(str); // 输出：!dlroW olleH（注意：反转后的结果）
}
}
四、时间和日期相关类
旧版类：在Java早期版本中，常用的时间和日期类包括Date、Calendar和GregorianCalendar等。Date类表明特定的瞬时、年、月、日、时、分、秒。Calendar类是一个抽象类，为操作年、月、日、时、分、秒等日历字段提供方法。GregorianCalendar是Calendar的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。
新版类：Java 8引入了新的时间和日期API，包括LocalDate、LocalTime、LocalDateTime、ZonedDateTime等类，这些类位于java.time包下，提供了更强劲、更灵活的时间和日期处理能力。
代码示例：
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
public class DateTimeExample {
public static void main(String[] args) {
// 获取当前日期和时间
LocalDate date = LocalDate.now();
LocalTime time = LocalTime.now();
LocalDateTime dateTime = LocalDateTime.now();
// 打印日期和时间
System.out.println(“当前日期: ” + date);
System.out.println(“当前时间: ” + time);
System.out.println(“当前日期和时间: ” + dateTime);
// 创建自定义的日期和时间
LocalDate customDate = LocalDate.of(2023, 10, 1);
LocalTime customTime = LocalTime.of(14, 30, 45);
LocalDateTime customDateTime = LocalDateTime.of(customDate, customTime);
// 打印自定义的日期和时间
System.out.println(“自定义日期: ” + customDate);
System.out.println(“自定义时间: ” + customTime);
System.out.println(“自定义日期和时间: ” + customDateTime);
}
}
五、其他常用类
Math类：提供了基本的数学运算方法和常数，如sin()、cos()、sqrt()、PI等。
Random类：用于生成伪随机数。
UUID类：用于生成全局唯一的标识符。
枚举类：使用enum关键字定义，表明一组固定的常量。枚举类是一个特殊的类，它继承自java.lang.Enum类。
代码示例：
import java.util.Random;
public class OtherClassesExample {
public static void main(String[] args) {
// 使用Math类
double randomNum = Math.random(); // 生成0.0到1.0之间的随机数
double sinValue = Math.sin(Math.PI / 2); // 计算正弦值
System.out.println(“随机数: ” + randomNum);
System.out.println(“sin(π/2)的值: ” + sinValue);
// 使用Random类
Random rand = new Random();
int randomInt = rand.nextInt(100); // 生成0到99之间的随机整数
System.out.println(“随机整数: ” + randomInt);
}
}
六、Object类
定义：Object类是Java中所有类的超类，即每个类都直接或间接地继承自Object类。
常用方法：
equals()：用于比较两个对象是否相等。
hashCode()：用于获取对象的哈希码，哈希码是一个整数，表明对象的存储地址（或某种与对象存储相关的数值）。两个相等对象的哈希码必定相等。
toString()：返回对象的字符串表明形式。
getClass()：返回对象的运行时类。
代码示例：
public class ObjectExample {
public static void main(String[] args) {
Object obj1 = new Object();
Object obj2 = new Object();
// 使用toString方法
System.out.println(obj1.toString()); // 输出对象的哈希码和类名（默认实现）
// 使用equals方法比较对象
System.out.println(obj1.equals(obj2)); // false，由于obj1和obj2指向不同的对象
// 使用hashCode方法获取对象的哈希码
System.out.println(obj1.hashCode());
// 使用getClass方法获取对象的运行时类
System.out.println(obj1.getClass().getName()); // 输出对象的类名
}
}
总结
本章主要介绍Java开发中常见的一些类的使用,包括包装类、字符串、时间日期、工具类等都是在开发中常常用到的类。本章首先介绍了包装类的用处,以及包装类与基本数类型之间的转换,进而引出自动拆箱、装箱机制;接着介绍了3种字符串:String、StringBufeStringBuilder的使用方式,以及它们之间的区别,并通过一个程序演示了三者之间的性能耗,读者需要能够根据不同的场景选择不同的字符串类;之后介绍了日期相关类及其用法包括如何获取日期、格式化日期、对日期进行计算等
暂无评论内容