面向对象编程核心细节与进阶技巧-CSDN博客

本文链接：https://blog.csdn.net/2401_84722456/article/details/147888330

面向对象编程核心细节与进阶技巧

1. 包（Package）

1.1 包的作用

组织代码：包是Java中管理类的文件夹，用于分类组织不同功能的代码，便于维护和扩展。
避免命名冲突：不同包中允许存在同名类，通过包名区分。
访问控制：结合权限修饰符控制类的可见性。

1.2 包名规则

命名规范：公司域名反写 + 功能描述，全小写，见名知意。
- 示例：com.itheima.domain（描述领域模型相关类）。

代码示例：

package com.itheima.domain;
public class Student {
    // 成员变量、构造方法、成员方法
}

1.3 导包规则

不需要导包的情况：
- 同一包中的类。
- java.lang包中的类（如String、System）。

需要导包的情况：

使用其他包中的类。
同名类冲突：需使用全类名（包名.类名）。

import com.itheima.domain.Student;

public class Test {
    public static void main(String[] args) {
        Student s = new Student(); // 导包后直接使用
        java.util.Date date = new java.util.Date(); // 全类名避免冲突
    }
}

2. final关键字

2.1 修饰变量

基本类型：值不可变（常量）。

引用类型：地址不可变，但对象内部属性可修改。

final double PI = 3.14; // 基本类型常量
final Student s = new Student("张三", 23);
s.setName("李四"); // 允许修改对象属性
// s = new Student(); // 报错：地址不可变

2.2 修饰方法

不可重写：final方法禁止子类覆盖。

public class Parent {
    public final void show() {
        System.out.println("父类最终方法");
    }
}

2.3 修饰类

不可继承：final类无法被其他类继承（如String类）。

public final class ImmutableClass {
    // 最终类，不可被继承
}

3. 权限修饰符

3.1 分类与作用范围

修饰符	同类	同包	不同包子类	不同包无关类
`private`	✔️	❌	❌	❌
`默认`	✔️	✔️	❌	❌
`protected`	✔️	✔️	✔️	❌
`public`	✔️	✔️	✔️	✔️

3.2 使用规范

成员变量私有化：用private封装数据，通过Getter/Setter访问。
方法公开化：对外提供功能的方法用public修饰。
工具方法私有化：若方法仅用于内部代码复用，使用private。

4. 代码块

4.1 局部代码块

作用：限制变量生命周期（已淘汰，现代开发中较少使用）。

public void method() {
    int a = 10;
    {
        int b = 20; // 仅在此代码块内有效
    }
}

4.2 构造代码块

作用：提取多个构造方法的重复逻辑。

public class Student {
    {
        System.out.println("创建对象时执行"); // 每次构造都执行
    }
}

4.3 静态代码块（重点）

作用：类加载时初始化静态资源（如数据库连接）。

public class Config {
    static {
        System.out.println("加载配置文件"); // 类加载时执行一次
    }
}

5. 抽象类与抽象方法

5.1 定义规则

抽象方法：只有声明，无方法体（abstract修饰）。

抽象类：包含抽象方法的类必须声明为abstract。

public abstract class Animal {
    public abstract void eat(); // 抽象方法
    public void drink() {
        System.out.println("喝水"); // 普通方法
    }
}

5.2 注意事项

不可实例化：抽象类不能直接创建对象。

子类约束：子类必须重写所有抽象方法，否则自身需声明为抽象类。

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

6. 接口

6.1 接口的特性

成员变量：默认public static final（常量）。

成员方法：

JDK8前：仅抽象方法（public abstract）。
JDK8+：支持默认方法（default）和静态方法（static）。
JDK9+：支持私有方法（private）。

public interface Swim {
    // 常量
    String TYPE = "游泳接口";

    // 默认方法
    default void start() {
        System.out.println("开始游泳");
    }

    // 静态方法
    static void stop() {
        System.out.println("停止游泳");
    }
}

6.2 接口与类的关系

类与接口：实现关系（implements），可多实现。

接口与接口：继承关系（extends），可多继承。

public class Frog implements Swim, Jump { // 多实现
    // 实现接口方法
}

public interface Amphibian extends Swim, Jump { // 多继承
}

7. 内部类

7.1 成员内部类

定义：位于外部类的成员位置，可直接访问外部类所有成员。

创建对象：

public class Car {
    class Engine {
        void start() {
            System.out.println("引擎启动");
        }
    }
}

// 创建对象
Car.Engine engine = new Car().new Engine();

7.2 静态内部类

定义：用static修饰，只能访问外部类的静态成员。

public class Outer {
    static class Inner {
        void show() {
            System.out.println("静态内部类");
        }
    }
}

// 创建对象
Outer.Inner inner = new Outer.Inner();

7.3 匿名内部类

定义：无显式类名，直接实现接口或继承抽象类。

Runnable task = new Runnable() {
    @Override
    public void run() {
        System.out.println("匿名内部类任务");
    }
};

8. 接口多态与匿名内部类

8.1 接口多态

参数传递：方法参数为接口时，可传递任意实现类对象。

public static void invokeSwim(Swim s) {
    s.swim();
}

// 调用
invokeSwim(new Swim() {
    @Override
    public void swim() {
        System.out.println("匿名实现游泳");
    }
});

8.2 匿名内部类的本质

语法糖：本质是接口/抽象类的子类对象，通过重写方法实现功能。
应用场景：简化一次性使用的实现类代码。

总结

包与导包：组织代码结构，避免命名冲突。
final与权限修饰符：控制变量、方法、类的访问与修改。
抽象类与接口：定义规范，实现多态与解耦。
内部类：增强封装性，灵活设计复杂对象关系。

掌握这些细节，能显著提升代码的可维护性与扩展性！ 🚀