Question

我有3节课。这似乎是基本问题。但我无法通过谷歌搜索找到答案。

public abstract class Test {

    void t1()
    {
        System.out.println("super");

    }

}
 public class concret extends Test{

    void t1()
    {
        System.out.println("child");

    }
    void t2()
    {
        System.out.println("child2");

    }

}

public class run {
    public static void main(String[] args) {
        Test t=new concret();

        t.t1();
    }

}

如何调用抽象类t1方法？由于我无法从抽象类创建对象，如何在抽象类中调用t1？谢谢。

Answer 1

要么创建一个不覆盖方法的具体类，要么在覆盖该方法的具体类中，您可以调用{{1 }}。例如：

super.t1()

如果您只有一个覆盖方法的对象实例，则无法从＆＃34;外部＆＃34; 调用原始方法这个类，因为这会破坏封装...覆盖的目的是替换原始方法的行为。

Answer 2

参见以下测试：

public abstract class BaseClass {

    public void doStuff() {
        System.out.println("Called BaseClass Do Stuff");
    }

    public abstract void doAbstractStuff();
}

public class ConcreteClassOne extends BaseClass{

    @Override
    public void doAbstractStuff() {
        System.out.println("Called ConcreteClassOne Do Stuff");
    }
}

public class ConcreteClassTwo extends BaseClass{

    @Override
    public void doStuff() {
        System.out.println("Overriding BaseClass Do Stuff");
    }
    @Override
    public void doAbstractStuff() {
        System.out.println("Called ConcreteClassTwo Do Stuff");
    }
}

public class ConcreteClassThree extends BaseClass{

    @Override
    public void doStuff() {
        super.doStuff();
        System.out.println("-Overriding BaseClass Do Stuff");
    }
    @Override
    public void doAbstractStuff() {
        System.out.println("Called ConcreteClassThree Do Stuff");
    }
}

public class Test {

    public static void main(String[] args) {
        BaseClass a = new ConcreteClassOne();
        a.doStuff(); //Called BaseClass Do Stuff
        a.doAbstractStuff(); //Called ConcreteClassOne Do Stuff

        BaseClass b = new ConcreteClassTwo();
        b.doStuff(); //Overriding BaseClass Do Stuff
        b.doAbstractStuff(); //Called ConcreteClassTwo Do Stuff

        BaseClass c = new ConcreteClassThree();
        c.doStuff(); //Called BaseClass Do Stuff
                        //-Overriding BaseClass Do Stuff
        c.doAbstractStuff(); //Called ConcreteClassThree Do Stuff
    }
}

Answer 3

使用关键字'super'来做到这一点

void t1()
     {  super.t1();
        System.out.println("child");

    }

请确保您在overriden方法中使用它。

Answer 4

抽象类表示该类在abstract关键字之前具有class修饰符。这意味着您可以声明抽象方法，这些方法仅在具体类中实现。

例如：

public abstract class Test {
     public abstract void foo();
}

public class Concrete extends Test {
    public void foo() {
        System.out.println("hey");
    }
}

Answer 5

您的代码似乎调用了t1（）。然而，这是调用具体的t1（），因为抽象的t1（）已被具体类覆盖。

如果您希望从主代码中调用抽象t1方法，请不要覆盖具体的t1（）。

或者您可以在具体类中创建一个方法，例如：

    public void invokeSuperT1(){
      super.t1();
    }

Answer 6

创建一个匿名的内部类

抽象类：

Test test = new Test() {

            @Override
            void t() {
                //you can throw exception here, if you want
            }
        };

以下是如何创建匿名内部类：

test.t1();

通过为抽象类

创建的对象调用该类

varchar(max)

Answer 7

您应该可以使用

Test test = new Test(){};
test.t1();

Answer 8

当我们希望从抽象类继承的每个类都应实现该抽象方法时，可以使用抽象类，因此必须实现该方法，否则会产生编译时错误。

void t1()
    {
        super.t1; // means the parent methods
        System.out.println("child");
    }

例如：Bird类具有sing（）方法，还有从其继承的其他类，例如麻雀，Pigeon，Duck，这些都具有sing方法，因此我们将Bird类设为Abstract并将sing（）方法设为abstract因此，每个实现Bird类的bird子代都应具有on实现的sing（）方法。

在抽象类java中调用非抽象方法

8 个答案: