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

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

---

目录

1. 包（Package）
2. final关键字
3. 权限修饰符
4. 代码块
5. 抽象类与抽象方法
6. 接口
7. 内部类
8. 接口多态与匿名内部类

---

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与权限修饰符：控制变量、方法、类的访问与修改。
• 抽象类与接口：定义规范，实现多态与解耦。
• 内部类：增强封装性，灵活设计复杂对象关系。

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