抽象类中的非抽象方法能在子类中不用super直接调用吗

在Java中，如果一个父类有非抽象（即没有`abstract`关键字）的方法，那么这个方法是可以被子类直接调用而无需使用`super`关键字的。这是因为非抽象方法默认继承给子类，子类可以直接在其定义体中使用这些方法。

例如：

public abstract class ParentClass {
    // 非抽象方法
    public void nonAbstractMethod() {
        System.out.println("This is a method in the parent class.");
    }
}

public class ChildClass extends ParentClass {
    public void someOtherMethod() {
        // 直接调用父类的非抽象方法
        nonAbstractMethod();
    }
}

在这个例子中，`ChildClass`可以像这样直接调用`nonAbstractMethod()`，无需显式地通过`super.nonAbstractMethod()`来间接访问。

相关问题

要是子类有重写这个非抽象方法后，在抽象类中的另一个方法调用this.方法，那么是调用的子类重写的还是抽象类的

如果子类重写了抽象类中的非抽象方法，并且在抽象类的另一个方法中使用了 this.方法 来调用这个非抽象方法，那么实际上调用的是子类重写后的方法。

具体来说，如果抽象类中的非抽象方法被子类重写后，在子类对象中调用该方法时，实际上会调用子类重写后的方法。这是因为 Java 中的方法调用是基于实际对象类型的动态绑定（dynamic binding），即根据实际对象类型来确定要调用的方法。

例如，假设有一个抽象类 Animal，它有一个非抽象方法 eat()，实现如下：

public abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating...");
    }

    public void play() {
        this.eat();
    }
}

在这个例子中，play() 方法调用了 this.eat() 来调用 eat() 方法。如果具体的子类 Cat 重写了 eat() 方法，那么在 Cat 对象中调用 play() 方法时，实际上会调用 Cat 类中重写后的 eat() 方法。

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println(getName() + " is eating fish...");
    }
}

在这个例子中，Cat 类重写了 eat() 方法，将输出改为了 "is eating fish..."。如果创建一个 Cat 对象并调用 play() 方法，输出结果将为 "Cat is eating fish..."，而不是 "Cat is eating..."。

抽象类的子类调用父类方法

在面向对象编程中，当子类继承自抽象类时，它可以覆盖（override）父类的方法，也可以直接调用父类的方法。如果子类选择重写某个父类方法，它会提供自己的实现；如果不重写，则可以直接通过关键字`super`来调用父类的同名方法。

例如，在Java中：

abstract class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }

    // 子类也可以直接调用父类的方法
    public void doActions() {
        super.makeSound(); // 输出 "Animal makes a sound"
    }
}

在这个例子中，`Dog`类继承了`Animal`类，并重写了`makeSound()`方法。在`doActions()`方法中，`Dog`通过`super.makeSound()`调用了父类的原始方法。