知识点1: 一维数组
一维数组是Java中最基础的数据结构。它可以存储一组固定数量的同类型元素，并且这些元素在内存中是连续存放的。
声明:
声明一个数组非常简单。你只需要指定数据类型与数组名称并用方括号包裹起来。声明仅仅创建了一个数组变量，而不是数组本身。
例如：
int[] numbers;
创建:
实际的数组是用new关键字创建的，后面跟着数据类型与方括号内指定数组的大小。
例如：
numbers = new int[10]; // 创建一个可以存储10个整数的数组
使用:
访问数组元素通过下标索引，下标从0开始。
例如：
numbers[0] = 100; // 将第一个元素设置为100
int x = numbers[0]; // 读取第一个元素的值
要获取数组的长度，可以使用.length属性：
int length = numbers.length;
内存分配:
当我们在Java中创建数组时，JVM（Java虚拟机）在堆内存中为其分配空间。数组被视为对象，数组的变量其实是指向堆内存中数组对象的引用。
class ArrayExample {
public static void main(String[] args) {
int[] myArray = new int[5]; // 声明并创建数组
for (int i = 0; i < myArray.length; i++) { // 使用数组
myArray[i] = i * 2; // 初始化数组元素
}
for (int i = 0; i < myArray.length; i++) { // 读取数组元素
System.out.println("Element at index " + i + ": " + myArray[i]);
}
}
}
| 概念 | 说明 |
|---|---|
| 声明 | 使用数据类型和数组名，加上方括号声明数组 |
| 创建 | 使用new关键字，指定数据类型和数组大小 |
| 使用 | 通过下标访问和修改元素。 |
| 长度 | 使用.length属性获取数组大小 |
| 内存 | 堆内存中分配，视为对象 |
知识点2: 多维数组
多维数组，常见的是二维数组，它类似于一个表格，包含行和列。
声明:
多维数组的声明通过添加额外的方括号来实现。
例如：
int[][] matrix;
创建:
创建多维数组也使用new关键字，然后为每个维度提供大小。
例如：
matrix = new int[3][4]; // 创建一个3行4列的二维数组
使用:
使用多个下标访问或修改多维数组的元素。
例如：
matrix[0][0] = 1; // 设置第一行第一列的元素为1
内存分配:
在多维数组中，实际上是数组的数组。每个数组元素本身是一个数组引用。
class MultiArrayExample {
public static void main(String[] args) {
int[][] multiArray = new int[3][3]; // 创建3x3数组
for (int i = 0; i < multiArray.length; i++) {
for (int j = 0; j < multiArray[i].length; j++) {
multiArray[i][j] = i + j; // 初始化数组元素
}
}
for (int i = 0; i < multiArray.length; i++) {
for (int j = 0; j < multiArray[i].length; j++) {
System.out.print(multiArray[i][j] + " "); // 打印数组元素
}
System.out.println();
}
}
}
| 概念 | 说明 |
|---|---|
| 声明 | 使用多个方括号声明 |
| 创建 | 使用new关键字创建，指定每个维度大小 |
| 使用 | 使用下标访问和修改元素 |
| 内存 | 主数组中存储引用，每行是独立数组 |
知识点3: 不规则数组
不规则数组，又称为交错数组，是指在多维数组中并不要求每一行的列数相同。
声明:
声明一个不规则数组与声明多维数组类似，但并不在声明时指定列数。
int[][] irregularArray;
创建:
不规则数组的创建是分行进行的。每行可以根据需要独立地创建与初始化。
例如：
irregularArray = new int[3][]; // 创建一个具有3行的数组，但是不指定列数
irregularArray[0] = new int[3]; // 第一行有3个元素
irregularArray[1] = new int[5]; // 第二行有5个元素
irregularArray[2] = new int[2]; // 第三行有2个元素
使用:
访问或修改不规则数组的元素通过与多维数组相同的方式，即通过行和列的下标。
例如：
irregularArray[1][3] = 10; // 设置第二行第四个元素为10
class IrregularArrayExample {
public static void main(String[] args) {
int[][] irregularArray = new int[3][]; // 声明不规则数组
irregularArray[0] = new int[]{1, 2, 3}; // 直接初始化
irregularArray[1] = new int[]{4, 5, 6, 7, 8};
irregularArray[2] = new int[]{9, 10};
for (int i = 0; i < irregularArray.length; i++) {
for (int j = 0; j < irregularArray[i].length; j++) {
System.out.print(irregularArray[i][j] + " ");
}
System.out.println();
}
}
}
| 概念 | 说明 |
|---|---|
| 声明 | 与多维数组类似，列数不固定 |
| 创建 | 行与行之间的长度可以不同 |
| 使用 | 使用行列下标访问和修改元素 |
| 特点 | 行内元素长度不一致，更灵活 |
知识点4: 面向对象程序设计 (OOP)
面向对象程序设计，是一种程序设计范型，将问题拆分为一系列相互作用的对象。
类:
类是创建对象的模板，包含属性（状态）和方法（用于操作状态的函数）。
对象的创建:
Java中，对象是通过使用new关键字以及类的构造方法创建的。
对象的使用:
对象的属性和方法可通过点操作符.进行访问和调用。
构造方法:
构造方法是特别的方法，用于在创建对象时初始化其状态。
内存分配:
对象在堆内存上进行分配，并且对象的清理工作是由Java的垃圾收集器自动管理的，无需手动释放内存。
class Car {
// 属性
int speed;
// 构造方法
Car(int initialSpeed) {
speed = initialSpeed; // 初始化速度属性
}
// 方法
void accelerate(int increment) {
speed += increment;
}
}
public class OOPExample {
public static void main(String[] args) {
Car myCar = new Car(0); // 使用new关键字创建对象
myCar.accelerate(10); // 调用方法来改变对象状态
System.out.println("Current speed: " + myCar.speed);
}
}
| 概念 | 说明 |
|---|---|
| 类 | 定义对象的属性和方法的模板 |
| 对象 | 类的实例，通过new关键字创建 |
| 构造方法 | 初始化对象的方法 |
| 内存分配 | 对象存储在堆内存中，由垃圾回收管理 |
知识点5: 变量
局部变量:
在方法内部定义，只在方法调用期间存在。
实例变量:
对每个类实例都独有的变量，存储在堆上的对象中。
类变量:
使用static修饰符声明，属于类本身，所有实例共享该变量。
class VariableExample {
static int classVariable = 0; // 类变量
int instanceVariable; // 实例变量
void method() {
int localVariable = 5; // 局部变量
System.out.println("Local: " + localVariable);
}
public static void main(String[] args) {
VariableExample example = new VariableExample();
example.instanceVariable = 10;
example.method();
System.out.println("Instance: " + example.instanceVariable);
System.out.println("Class: " + VariableExample.classVariable);
}
}
| 变量类型 | 说明 |
|---|---|
| 局部变量 | 方法内部定义，生命周期短 |
| 实例变量 | 对象创建时分配，跟随对象生命周期 |
| 类变量 | 使用static定义，所有实例共享 |
知识点6: 方法
实例方法:
可以访问类的实例变量和实例方法。若在实例方法中引用当前对象，可以使用this关键词。
类方法:
用static修饰符声明的方法，不依赖于对象实例。
传递参数:
方法调用时可以传递参数，参数作为局部变量在方法内部使用。
方法重载:
在同一类中，可以有多个同名方法，只要它们的参数列表不同。
返回值:
方法执行后可以返回一个值，使用return关键字。
class MethodExample {
static void classMethod() {
System.out.println("Class Method");
}
void instanceMethod(int number) {
System.out.println("Instance Method, number: " + number);
}
int add(int a, int b) {
return a + b; // 返回值
}
// 方法重载，相同方法名不同参数
double add(double a, double b) {
return a + b;
}
public static void main(String[] args) {
MethodExample example = new MethodExample();
example.instanceMethod(10);
MethodExample.classMethod();
int result = example.add(5, 7); // 使用int版的add
double resultDouble = example.add(5.0, 7.0); // 使用double版的add
System.out.println("Addition result for integers: " + result);
System.out.println("Addition result for doubles: " + resultDouble);
}
}
| 方法类型 | 说明 |
|---|---|
| 实例方法 | 操作实例变量和方法 |
| 类方法 | 不依赖对象实例，可直接调用 |
| 传参 | 方法调用时传递，局部变量使用 |
| 方法重载 | 参数不同，方法同名 |
| 返回值 | 方法执行完返回结果 |
各种代码块
匿名代码块: 定义在类中，不属于任何方法，每次创建类实例时都会执行。
class BlockExample {
// 静态代码块
static {
System.out.println("Static Block - This executes when class is loaded");
}
// 匿名代码块
{
System.out.println("Anonymous Block - This executes every time an object is created");
}
public static void main(String[] args) {
new BlockExample();
new BlockExample();
}
}
这段代码会首先执行静态代码块一次，随后每次创建BlockExample对象时都会执行匿名代码块。
| 代码块类型 | 说明 |
|---|---|
| 匿名代码块 | 对象创建时执行，用于初始化 |
| 静态代码块 | 类被加载时执行一次，用于静态初始化 |
