Java父类调用案例如何实现

本文目录导读：

1. 子类调用父类方法（使用super关键字）
2. 父类调用子类方法（通过方法重写）
3. 使用模板方法模式（父类定义框架，子类实现细节）
4. 使用回调接口实现父类调用子类方法
5. 多层级继承调用示例

在Java中，父类调用子类方法或子类调用父类方法是一个常见的面试和编程问题,我来给你详细讲解几种不同的实现案例：

子类调用父类方法（使用super关键字）

// 父类
class Animal {
    String name = "动物";
    public void eat() {
        System.out.println("动物正在吃东西");
    }
    public void sleep() {
        System.out.println("动物正在睡觉");
    }
}
// 子类
class Dog extends Animal {
    String name = "小狗";
    @Override
    public void eat() {
        // 调用父类的eat方法
        super.eat();
        System.out.println("小狗正在吃骨头");
    }
    public void showInfo() {
        // 调用父类的属性
        System.out.println("父类name: " + super.name);
        System.out.println("子类name: " + this.name);
        // 调用父类的方法
        super.sleep();
    }
}
// 测试类
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();      // 输出：动物正在吃东西 小狗正在吃骨头
        dog.showInfo(); // 显示父类和子类的属性
    }
}

父类调用子类方法（通过方法重写）

class Shape {
    public void draw() {
        System.out.println("绘制图形");
        // 这个方法会被子类重写
        drawSpecific();
    }
    // 设计为被子类重写的方法
    public void drawSpecific() {
        System.out.println("绘制具体图形");
    }
}
class Circle extends Shape {
    @Override
    public void drawSpecific() {
        System.out.println("绘制圆形");
    }
}
class Rectangle extends Shape {
    @Override
    public void drawSpecific() {
        System.out.println("绘制矩形");
    }
}
public class TestShape {
    public static void main(String[] args) {
        Shape circle = new Circle();
        Shape rectangle = new Rectangle();
        circle.draw();    // 输出：绘制图形 绘制圆形
        rectangle.draw(); // 输出：绘制图形 绘制矩形
    }
}

使用模板方法模式（父类定义框架，子类实现细节）

abstract class DataProcessor {
    // 模板方法 - 定义处理流程
    public final void process() {
        readData();
        processData();
        saveData();
        cleanup();
    }
    // 具体方法 - 所有子类共享
    private void readData() {
        System.out.println("读取数据");
    }
    private void saveData() {
        System.out.println("保存数据");
    }
    // 抽象方法 - 子类必须实现
    protected abstract void processData();
    // 钩子方法 - 子类可以选择性重写
    protected void cleanup() {
        System.out.println("清理资源");
    }
}
class CSVProcessor extends DataProcessor {
    @Override
    protected void processData() {
        System.out.println("处理CSV数据");
    }
    @Override
    protected void cleanup() {
        System.out.println("关闭CSV文件流");
    }
}
class JSONProcessor extends DataProcessor {
    @Override
    protected void processData() {
        System.out.println("处理JSON数据");
    }
}
public class TestProcessor {
    public static void main(String[] args) {
        DataProcessor csv = new CSVProcessor();
        DataProcessor json = new JSONProcessor();
        csv.process();
        System.out.println("---");
        json.process();
    }
}

使用回调接口实现父类调用子类方法

// 定义回调接口
interface TaskCallback {
    void onTaskComplete(String result);
}
class ParentTask {
    public void executeTask(TaskCallback callback) {
        System.out.println("父类开始执行任务");
        // 模拟任务执行
        String result = "任务结果";
        // 通过回调调用子类的方法
        callback.onTaskComplete(result);
        System.out.println("父类任务结束");
    }
}
class ChildTask {
    public void start() {
        ParentTask parent = new ParentTask();
        // 使用匿名内部类实现回调
        parent.executeTask(new TaskCallback() {
            @Override
            public void onTaskComplete(String result) {
                System.out.println("子类处理结果: " + result);
                System.out.println("子类继续执行后续操作");
            }
        });
    }
}
public class TestCallback {
    public static void main(String[] args) {
        ChildTask child = new ChildTask();
        child.start();
    }
}

多层级继承调用示例

class GrandParent {
    public void method() {
        System.out.println("GrandParent的方法");
    }
}
class Parent extends GrandParent {
    @Override
    public void method() {
        super.method(); // 调用GrandParent的方法
        System.out.println("Parent的方法");
    }
}
class Child extends Parent {
    @Override
    public void method() {
        super.method(); // 调用Parent的方法（实际也会调用GrandParent的方法）
        System.out.println("Child的方法");
    }
}
public class TestInheritance {
    public static void main(String[] args) {
        Child child = new Child();
        child.method();
        // 输出：
        // GrandParent的方法
        // Parent的方法
        // Child的方法
    }
}

核心要点：

1. 子类调用父类：使用 super 关键字

2. 父类调用子类：

   • 通过方法重写（多态）
   • 使用模板方法模式
   • 使用回调接口

3. 最佳实践：

   • 避免在构造方法中调用可被重写的方法
   • 明确设计哪些方法允许重写（使用 protected 或 public）
   • 使用 abstract 关键字强制子类实现某些方法
   • 考虑使用 final 防止不需要被重写的方法

理解这些模式对于设计灵活、可维护的面向对象程序非常重要。