子类父类方法的互相调用

我不是女神ヾ 2024-03-24 18:26 23阅读 0赞

### **子类调父类** ###

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

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

public class Parent {
        public void method() {
            // 父类方法实现
        }
    }
    
    public class Child extends Parent {
        public void anotherMethod() {
            // 调用父类的无参方法
            super.method();
        }
    }

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

public class Parent {
        public void method(String param) {
            // 父类方法实现
        }
    }
    
    public class Child extends Parent {
        public void anotherMethod() {
            // 调用父类的有参方法
            super.method("参数值");
        }
    }

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

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

### **父类调子类** ###

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

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

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); // 将父类引用强制转换为子类引用并调用子类方法
        }
    }

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

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() {
            // 可以在任何地方访问的逻辑
        }
    }

根据你的具体需求，选择合适的修饰符来控制方法的可见性和访问权限。