子类父类方法的互相调用-蒲公英云

子类调父类

在子类中调用父类的方法，可以使用 `super` 关键字。`super` 关键字表示对父类的引用，可以用来调用父类的方法。以下是几种调用父类方法的常见方式：

调用父类的无参方法：使用 `super.methodName()` 调用父类的无参方法。

public class Parent {

 public void method() {
     // 父类方法实现
 }

}

public class Child extends Parent {

 public void anotherMethod() {
     // 调用父类的无参方法
     super.method();
 }

}

调用父类的有参方法：使用 `super.methodName(parameter)` 调用父类的有参方法。

public class Parent {

 public void method(String param) {
     // 父类方法实现
 }

}

public class Child extends Parent {

 public void anotherMethod() {
     // 调用父类的有参方法
     super.method("参数值");
 }

}

注意，在子类中使用 `super` 调用父类方法时，需要确保父类方法是可访问的（即不是 `private` 访问修饰符）。

通过使用 `super` 关键字，你能够在子类中调用父类的方法，并在其基础上进行扩展或重写。

父类调子类

在父类中调用子类的方法有一定的限制，因为父类对子类的具体实现是不可见的。但是，你可以通过某些技巧来实现父类调用子类方法的需求，常见的方法包括以下几种：

将父类作为参数传递给子类方法：可以在父类中定义一个方法，将当前父类的实例作为参数传递给子类的方法，在子类中调用该方法。

public class Parent {

 public void method() {
     // 父类方法实现
 }
 public void callChildMethod(Child child) {
     child.childMethod(); // 调用子类的方法
 }

}

public class Child extends Parent {

 public void childMethod() {
     // 子类方法实现
 }
 // ...

}

public class Main {

 public static void main(String[] args) {
     Parent parent = new Child();
     parent.callChildMethod((Child) parent); // 将父类引用强制转换为子类引用并调用子类方法
 }

}

使用模板方法设计模式：定义一个在父类中被调用的抽象方法，并在子类中重写该方法实现子类特有的逻辑。

public abstract class Parent {

 public final void method() {
     // 父类方法逻辑
     childMethod(); // 调用子类方法
     // 父类方法逻辑
 }
 protected abstract void childMethod(); // 抽象方法，在子类中实现

}

public class Child extends Parent {

 protected void childMethod() {
     // 子类方法实现
 }
 // ...

}

public class Main {

 public static void main(String[] args) {
     Parent parent = new Child();
     parent.method(); // 调用父类方法，间接调用子类的方法
 }

}

3.动态绑定实现，要让父类调用子类的insert方法，可以使用Java的多态性和动态绑定机制。

//在父类中声明一个没有具体实现的insert方法。
public class ParentClass {
    public void insert() {
        // 空实现或者抛出异常
    }
}
//在子类中重写（Override）insert方法，提供具体的实现。
public class ChildClass extends ParentClass {
    @Override
    public void insert() {
        // 子类的具体实现
    }
}
//创建子类对象并将其赋值给父类类型的变量。
ParentClass obj = new ChildClass();
//调用父类对象的insert方法。
obj.insert();
//通过这种方式，即使变量的类型是父类类型，实际上会调用子类中的insert方法，
//实现了父类调用子类的方法。这是因为Java会在运行时根据对象的实际类型来确定调用哪个方法，
//而不仅仅依赖于变量的声明类型。这就是多态性和动态绑定的特性。

通过这些方式，你可以在父类中间接调用子类的方法，以实现特定的需求。但是需要注意，在父类中调用子类的方法时，需要保证该方法是在子类中被重写或实现的。

注意：1.在父类中定义的childMethod必须是抽象的吗？

不，父类中定义的 `childMethod` 方法并不一定要是抽象的。是否将父类中的方法定义为抽象方法取决于你的设计需求。

如果你希望子类必须提供自己的实现逻辑，那么可以将 `childMethod` 声明为抽象方法。这将强制子类必须实现该方法。

public abstract class Parent {
    public void method() {
        // 父类方法逻辑
        childMethod(); // 调用子类方法
        // 父类方法逻辑
    }
    protected abstract void childMethod(); // 抽象方法，在子类中实现
}

如果你希望在父类中提供一个默认的实现，并允许子类选择性地重写该方法，那么可以将 `childMethod` 实现为具体的方法。子类可以选择性地重写该方法，或者直接使用父类提供的默认实现。

public class Parent {
    public void method() {
        // 父类方法逻辑
        childMethod(); // 调用子类方法
        // 父类方法逻辑
    }
    protected void childMethod() {
        // 父类提供的默认实现
    }
}

无论是抽象方法还是具体方法，父类中的 `childMethod` 都可以被调用，只是在具体的执行时，会根据子类是否重写了该方法来确定具体的行为。这样可以为子类提供一定的灵活性和选择性。

2.修饰符必须是protected 吗?

不，修饰符并不一定要是 `protected`。修饰符的选择取决于你的设计需求和访问控制的要求。

如果你希望 `childMethod` 只能在父类及其子类中被访问，可以将修饰符设置为 `protected`。

public class Parent {
    public void method() {
        // 父类方法逻辑
        childMethod(); // 调用子类方法
        // 父类方法逻辑
    }
    protected void childMethod() {
        // 子类可以访问的逻辑
    }
}

如果你希望 `childMethod` 只能在父类内部被访问，可以将修饰符设置为 `private`。

public class Parent {
    public void method() {
        // 父类方法逻辑
        childMethod(); // 调用子类方法
        // 父类方法逻辑
    }
    private void childMethod() {
        // 仅供父类内部使用的逻辑
    }
}

如果你希望 `childMethod` 能够在任何地方被访问，可以将修饰符设置为 `public` 或不加修饰符（默认为包级可见）。

public class Parent {
    public void method() {
        // 父类方法逻辑
        childMethod(); // 调用子类方法
        // 父类方法逻辑
    }
    public void childMethod() {
        // 可以在任何地方访问的逻辑
    }
}