Java基础总结

Java基础总结

李宇健 202402150671

一、初始 Java 与面向对象程序设计

1.1 Java 语言的特点

• 简单易学：语法相对简洁，容易理解和掌握。
• 面向对象：支持封装、继承和多态等面向对象的特性。
• 平台无关性：一次编写，到处运行，通过 Java 虚拟机（JVM）实现跨平台。
• 安全性高：具有严格的访问控制和安全机制。
• 健壮性强：提供了自动内存管理和错误处理机制。

1.2 JDK 与 JRE

• JDK（Java Development Kit）：包含了开发 Java 程序所需的工具和库，如编译器（javac）、调试器（jdb）等。
• JRE（Java Runtime Environment）：提供了运行 Java 程序所需的环境，包括 JVM 和核心类库。

二、Java 编程基础

2.1 基础语法

2.1.1 标识符与命名规范

• 标识符：用于给变量、方法、类等命名的字符序列。
• 命名规范：以字母、下划线_、美元符号$开头，后面可以跟字母、数字、下划线和美元符号；遵循驼峰命名法等规则。

int myVariable;  // 合法的标识符
int 123variable;  // 非法的标识符，不能以数字开头

2.1.2 数据类型

• 基本数据类型：byte（8 位整数）、short（16 位整数）、int（32 位整数）、long（64 位整数）、float（单精度浮点数）、double（双精度浮点数）、char（字符）、boolean（布尔值）。
• 引用数据类型：类、接口、数组等。

int num = 10;  // 整型变量
double price = 9.99;  // 双精度浮点数变量
char letter = 'A';  // 字符变量
boolean isTrue = true;  // 布尔变量

2.1.3 变量的定义与赋值

• 定义变量：指定数据类型和变量名。
• 赋值：给变量赋予具体的值。

int age;  // 定义一个整型变量
age = 20;  // 给变量赋值

2.1.4 常量

• 使用final关键字修饰的变量，其值不能被修改。

final int MAX_VALUE = 100;  // 定义常量

2.1.5 变量的类型转换

• 自动类型转换：范围小的数据类型自动转换为范围大的数据类型。
• 强制类型转换：范围大的数据类型强制转换为范围小的数据类型，可能会导致数据丢失。

int num1 = 10;
double num2 = num1;  // 自动类型转换

double num3 = 10.5;
int num4 = (int) num3;  // 强制类型转换，可能会丢失小数部分

2.2 选择结构

• if-else语句：根据条件执行不同的代码块。
• switch语句：根据表达式的值选择执行不同的分支。

int num = 5;
if (num > 10) {
    System.out.println("大于 10");
} else {
    System.out.println("小于等于 10");
}

int day = 2;
switch (day) {
    case 1:
        System.out.println("周一");
        break;
    case 2:
        System.out.println("周二");
        break;
    default:
        System.out.println("其他");
}

2.3 循环结构

• for循环：常用于已知循环次数的情况。
• while循环：在条件为真时执行循环体。
• do-while循环：先执行一次循环体，然后在条件为真时继续循环。

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

int count = 0;
while (count < 3) {
    System.out.println(count);
    count++;
}

int num = 0;
do {
    System.out.println(num);
    num++;
} while (num < 2);

2.4 方法重载

• 方法名相同，但参数列表不同（参数个数、参数类型、参数顺序）。

void print(int num) {
    System.out.println(num);
}

void print(String str) {
    System.out.println(str);
}

2.5 数组

• 数组的声明、创建和初始化。
• 访问数组元素。

int[] arr = new int[5];  // 创建一个整型数组
arr[0] = 1;  // 访问和赋值数组元素

2.6 二维数组

• 二维数组的声明和创建。
• 遍历二维数组。

int[][] arr2 = new int[2][3];  // 创建一个 2 行 3 列的二维数组

for (int i = 0; i < arr2.length; i++) {
    for (int j = 0; j < arr2[i].length; j++) {
        System.out.print(arr2[i][j] + " ");
    }
    System.out.println();
}

2.7 Arrays 工具类

• 用于对数组进行操作的工具方法，如排序、查找等。

import java.util.Arrays;

int[] arr = {5, 3, 1, 2, 4};
Arrays.sort(arr);  // 对数组进行排序

2.8 JVM 中的堆内存与栈内存

2.8.1 堆和栈

• 堆：用于存储对象和数组等动态分配的内存。
• 栈：用于存储方法的局部变量、参数等。

2.8.2 数据类型传递

• 基本数据类型：按值传递，传递的是值的副本。
• 引用数据类型：按引用传递，传递的是对象的引用。

void changeValue(int num) {  // 基本数据类型参数
    num = 20;
}

void changeArray(int[] arr) {  // 引用数据类型参数
    arr[0] = 100;
}

int num = 10;
changeValue(num);  // num 的值不会改变

int[] arr = {1, 2, 3};
changeArray(arr);  // arr 的元素值会改变

3. 面向对象程序设计（基础）

3.1 面向对象的特性

• 封装：将数据和操作数据的方法封装在一个类中，隐藏内部实现细节，只对外提供必要的接口。
• 继承：子类可以继承父类的属性和方法，实现代码复用和扩展。
• 多态：同一行为在不同的对象上有不同的实现方式，包括方法重载和方法重写。

3.2 面向对象编程

3.2.1 类的定义

类是具有相同属性和行为的对象的抽象描述，包含成员变量和成员方法的定义。

class Person {
    String name;  // 成员变量
    int age;

    void showInfo() {  // 成员方法
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

3.2.2 对象的创建与使用

通过 new 关键字创建类的对象，然后可以使用对象访问成员变量和调用成员方法。

Person person = new Person();
person.name = "Alice";
person.age = 20;
person.showInfo();

3.2.3 成员变量默认值

不同数据类型的成员变量有默认的初始值，如整型为 0，布尔型为 false，引用类型为 null 等。

3.3 构造方法

用于对象创建时的初始化操作，与类同名，没有返回值类型。

class Person {
    String name;
    int age;

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

3.4 this 关键字

在方法内部指代当前对象，可以用于区分成员变量和局部变量，调用本类的其他构造方法。

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }

    void printName() {
        System.out.println(this.name);
    }
}

3.5 static 关键字

• 修饰成员变量为静态变量，所有对象共享。
• 修饰成员方法为静态方法，可以通过类名直接调用，不依赖于对象。

class StaticExample {
    static int count = 0;  // 静态变量

    static void incrementCount() {  // 静态方法
        count++;
    }
}

3.6 静态代码块

使用 static 关键字定义的代码块，在类加载时执行，且只执行一次。

class StaticBlockExample {
    static {
        System.out.println("静态代码块执行");
    }
}

3.7 包

用于对类进行组织和管理，避免命名冲突，方便控制访问权限。

package com.example;  // 定义包

4. 面向对象程序设计（进阶）

4.1 封装

• 将类的属性私有化，并提供公共的方法来获取和设置属性值，以控制对属性的访问和修改，增强数据的安全性和一致性。

class Student {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

4.2 继承

4.2.1 继承的使用

• 子类通过 extends 关键字继承父类，可以继承父类的非私有成员变量和方法。

class Parent {
    void parentMethod() {
        System.out.println("Parent method");
    }
}

class Child extends Parent {
    // 子类可以直接使用父类的方法
}

4.2.2 方法重写

• 子类可以重写父类的方法，实现更具体的功能。

class Parent {
    void method() {
        System.out.println("Parent method");
    }
}

class Child extends Parent {
    @Override
    void method() {
        System.out.println("Child method");
    }
}

4.3 super 关键字

• 在子类中用于调用父类的构造方法、访问父类的成员变量和成员方法。

class Parent {
    int num = 10;

    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    void show() {
        System.out.println(super.num);  // 访问父类的成员变量
        super();  // 调用父类的无参构造方法
    }
}

4.4 final 关键字

• 修饰变量，其值不能被修改。
• 修饰方法，不能被重写。
• 修饰类，不能被继承。

final int FINAL_VAR = 5;

class Parent {
    final void finalMethod() {
        System.out.println("Final method");
    }
}

// 以下代码会报错，因为 final 修饰的类不能被继承
// class Child extends Parent {}

4.5 Object 类

• Java 中所有类的父类，包含一些通用的方法，如 toString()、equals() 等。

class MyClass extends Object {
    @Override
    public String toString() {
        return "MyClass instance";
    }
}

4.6 多态

• 分为编译时多态（方法重载）和运行时多态（方法重写）。
• 通过父类引用指向子类对象，实现动态的方法调用。

class Parent {
    void method() {
        System.out.println("Parent method");
    }
}

class Child extends Parent {
    @Override
    void method() {
        System.out.println("Child method");
    }
}

Parent parent = new Child();  // 多态
parent.method();  // 实际调用子类的方法

4.7 抽象类

• 包含抽象方法（只有方法声明，没有方法体）的类，不能被实例化。
• 子类必须实现抽象类中的抽象方法。

abstract class AbstractClass {
    abstract void abstractMethod();
}

class ConcreteClass extends AbstractClass {
    @Override
    void abstractMethod() {
        System.out.println("Implemented abstract method");
    }
}

4.8 接口

• 只包含常量和抽象方法的定义。
• 实现接口的类必须实现接口中的所有方法。

interface MyInterface {
    void interfaceMethod();
}

class MyClass implements MyInterface {
    @Override
    public void interfaceMethod() {
        System.out.println("Implemented interface method");
    }
}

4.9 内部类

• 定义在其他类内部的类，包括成员内部类、局部内部类、匿名内部类等。

class OuterClass {
    class InnerClass {
        void innerMethod() {
            System.out.println("Inner class method");
        }
    }

    public void outerMethod() {
        // 局部内部类
        class LocalInnerClass {
            void localMethod() {
                System.out.println("Local inner class method");
            }
        }

        new LocalInnerClass().localMethod();
    }
}

5. 异常

5.1 异常概述

• 介绍了在程序运行过程中可能出现的非正常情况，如错误的输入、资源不可用等。
• 异常分为受检异常（Checked Exception）和非受检异常（Unchecked Exception）。

5.2 异常处理

• 使用 try-catch 语句捕获和处理异常。
• 可以使用多个 catch 块来处理不同类型的异常。
• try 块中包含可能抛出异常的代码，catch 块用于处理特定类型的异常。
• 还可以使用 finally 块来执行无论是否发生异常都要执行的代码。

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e1) {
    // 处理 ExceptionType1 类型的异常
} catch (ExceptionType2 e2) {
    // 处理 ExceptionType2 类型的异常
} finally {
    // 无论是否有异常都会执行的代码
}

6. Java 常用类

6.1 包装类

6.1.1 包装类与基本数据类型

• 为基本数据类型提供了对应的类包装，如 Integer 对应 int ，Double 对应 double 等。

6.1.2 自动装箱与拆箱

• 自动将基本数据类型转换为对应的包装类称为自动装箱，反之称为自动拆箱。

Integer num = 10;  // 自动装箱
int value = num;  // 自动拆箱

6.1.3 大数字运算

• 对于超出基本数据类型范围的数字运算，可以使用包装类的相关方法。

6.2 String 类概述

• 字符串的不可变特性。
• 常见的字符串操作方法，如 length() 、 substring() 、 concat() 等。

6.3 StringBuffer 类与 StringBuilder 类

• StringBuffer 和 StringBuilder 类用于可变字符串的操作。
• StringBuffer 是线程安全的，而 StringBuilder 不是，但性能更好。

6.4 时间和日期相关类

• 如 java.util.Date 、 java.text.SimpleDateFormat 等类用于处理时间和日期。

6.5 其他常用类

• 例如 Math 类提供了数学计算的方法， Random 类用于生成随机数等。