Java面向对象编程全面教程

一、类与对象基础

1. 类的定义

类是对某一类事物的抽象描述，对象是类中具体的个体。

[修饰符] class 类名 [extends 父类名] [implements 接口名]{
    // 成员变量
    [修饰符] 数据类型 变量名 [=值];
    
    // 成员方法
    [修饰符] [返回值类型] 方法名([参数]){
        [return 返回值]
    }
}

2. 访问控制修饰符

• private: 当前类可以访问
• default(默认): 当前包可以访问
• protected: 当前类、包、以及其他包内的子类
• public: 所有类都可以访问

3. 对象创建与使用

// 创建对象
类名 对象名 = new 类名();

// 使用对象
对象引用.对象成员
new 类名().对象成员  // 匿名对象，使用后即成为垃圾对象

内存分配：

• 栈内存：存放基本数据类型变量、对象的引用变量
• 堆内存：存放new创建的对象和数组

二、封装

将对象的状态信息隐藏在对象内部，通过提供的方法来访问。

实现步骤：

1. 属性私有化，使用private修饰
2. 提供公共的访问方法(getter/setter)

三、方法重载与递归

1. 方法重载

定义多个方法名相同，参数不同的方法。

2. 递归

在有结束条件的情况下，在方法内部调用自身。

四、构造方法

[修饰符] 类名([参数]){
    // 方法体
}

特点：

• 方法名必须和类名相同
• 没有返回值类型声明
• 可以使用return结束方法，但不能返回值

注意事项：

• 每个类至少有一个构造方法
• 如果没有显式定义，系统会自动创建默认无参构造方法
• 如果定义了构造方法，系统不再提供默认构造方法
• 构造方法不能用private修饰

五、this关键字

指代当前对象，类似Python的self。

用法：

this.成员变量名
this.成员方法名()
this([参数])  // 调用构造方法

构造方法中使用this调用其他构造方法的规则：

1. 必须在构造方法的第一行
2. 只能出现一次
3. 不能在一个类中的构造方法互相调用

六、static关键字

static修饰的数据在内存中只有一份，被类的所有实例共享。

1. 静态变量

static 数据类型 变量名 [=值];
// 使用：类名.变量名

2. 静态方法

[修饰符] static 方法名([参数]){
    // 方法体
}
// 使用：类名.方法名()

注意：静态方法内部只能访问类中被static修饰的成员。

3. 静态代码块

static {
    // 初始化代码
}

类被加载时执行，只执行一次，通常用于初始化静态成员。

七、继承

[修饰符] class 子类名 extends 父类名 {
    // 类体
}

特点：

1. 子类继承父类所有公共成员
2. Java是单继承，一个类只能有一个父类

1. 方法重写

子类重写父类方法需要：

• 相同的方法名
• 相同的参数列表
• 相同的返回值类型
• 不能使用比父类更严格的访问权限

2. super关键字

用于访问父类成员，包括被重写的方法。

super.成员变量
super.成员方法([参数])
super([参数])  // 调用父类构造方法

注意事项：

• 使用super调用父类构造方法必须写在子类构造方法的第一行
• 只能调用一次
• 如果子类构造方法中没有使用super，默认调用父类无参构造方法

3. Object类

所有类的父类，被称为超类、基类或根类。如果一个类没有显式继承其他类，则默认继承Object类。

八、final关键字

修饰类、变量、方法，表示不可改变。

• final类：不能被继承
• final方法：不能被子类重写
• final变量：常量，只能赋值一次

九、抽象类与接口

1. 抽象类

[修饰符] abstract class 类名{
    [修饰符] abstract [返回值类型] 方法名([参数]);
}

特点：

• 包含抽象方法的类必须是抽象类
• 抽象类可以有非抽象方法
• 抽象类不能实例化，必须通过子类继承并实现所有抽象方法

2. 接口

[修饰符] interface 接口名 [extends 父接口...] {
    // 常量
    [修饰符] [static] [final] 常量类型 常量名 = 常量值;
    
    // 抽象方法
    [public] [abstract] 返回值类型 方法名([参数]);
    
    // 默认方法(JDK8+)
    [public] default 返回值类型 方法名([参数]){
        // 方法体
    }
    
    // 静态方法(JDK8+)
    [public] static 返回值类型 方法名([参数]){
        // 方法体
    }
}

实现接口：

[修饰符] class 类名 [extends 父类名] implements 接口1, 接口2... {
    // 必须实现所有抽象方法
}

特点：

• 接口可以多继承
• 实现类必须实现接口中所有抽象方法
• 静态方法通过"接口名.静态方法名"调用
• 抽象方法和默认方法通过实例对象调用

十、多态

多态是指不同类的对象调用同一个方法时呈现的不同行为。

实现条件：

1. 继承
2. 方法重写
3. 父类引用指向子类对象

1. 向上转型

父类 变量名 = new 子类();

只能调用父类和子类共有的方法(子类重写过的方法)

2. 向下转型

子类 变量名 = (子类)父类引用变量;

可以调用子类特有的方法

3. instanceof运算符

对象 instanceof 类/接口

判断对象是否是某个类或接口的实例

十一、内部类

1. 成员内部类

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

2. 局部内部类

定义在方法内部，有效范围局限于方法内部

3. 静态内部类

外部类名.静态内部类名 变量名 = new 外部类名.静态内部类名();

4. 匿名内部类

new 接口/父类(){
    // 实现部分
}

十二、JDK8的Lambda表达式

1. 语法

([参数]) -> {表达式主体}

简化规则：

• 只有一个参数时可省略括号
• 表达式主体只有一条语句时可省略{}
• 只有一条return语句时可省略return

2. 函数式接口

有且仅有一个抽象方法的接口，可用@FunctionalInterface注解标注

3. 方法引用

类名::方法名
对象名::方法名
类名::new  // 构造器引用

十三、异常处理

1. 异常体系

Throwable
├── Error
└── Exception
    ├── RuntimeException  // 运行时异常
    └── 其他异常          // 编译时异常

2. try-catch-finally

try{
    // 可能发生异常的代码
}catch(异常类型 变量名){
    // 异常处理
}finally{
    // 无论是否发生异常都会执行的代码
}

3. throws

指明方法可能抛出的异常

4. throw

抛出异常对象

5. 自定义异常

继承Exception或其子类

十四、垃圾回收

1. 对象状态

• 可用：有引用变量引用
• 可恢复：无引用变量引用，等待finalize()
• 不可用：finalize()后仍无引用

2. 强制垃圾回收

System.gc();
// 或
Runtime.getRuntime().gc();

3. finalize()方法

对象被回收前自动调用

protected void finalize() throws Throwable{
    // 资源清理
}