标签: abstract-methods

我有一个抽象方法和具体实现方法的特征,所以这样的事情:

trait MyTrait extends BaseClass {
    def myAbstractMethod: MyReturnType
    def myConcreteMethod = { /*implementation*/ }
}

现在我混合了这个特质:

class MyClass extends BaseClass with MyTrait {

}

BaseClass不实现抽象方法.我期望scala编译器在混合特征时强制执行抽象方法(就像Java接口一样).但是没有编译器错误.

我的具体情况比较复杂.我无法测试运行时发生的事情.

1. 为什么scala编译器不强制执行抽象方法？
2. 我可以让scala编译器强制执行抽象方法吗？
3. 我必须在某处添加摘要或覆盖吗？
4. 当我尝试创建和使用MyClass的实例时,在运行时会发生什么？

为了解释我的问题,这里有一个例子

namespace CheckAbstarct
{

class Program
{
    static void Main(string[] args)
    {
        myAbstarctClass mac1 = ObjectFactory.ObjectCreator("aaa");
        myAbstarctClass mac2 = ObjectFactory.ObjectCreator("bbb");
        mac1.changeMyString();
        mac2.changeMyString();
        string myString = (string)mac2.returnMyObject();
        DateTime myObject = (DateTime) mac1.returnMyObject();

        object obj1 = mac1.returnMyObject();
        object obj2 = mac2.returnMyObject();

        myMethod(obj1);  //---> This is not compiling
        myMethod(obj2);  //---> This is not compiling

        myMethod(myString);  //---> works fine
        myMethod(myObject);  //---> works fine

        Console.ReadKey();
    }
    public static void myMethod(DateTime dt)
    {
    }
    public static void myMethod(string st)
    {
    }
}
abstract class myAbstarctClass
{ …

并没有真正处理抽象方法,而是在抽象类中查看抽象方法.

    protected abstract bool Validate()
    {
    }

当我创建上面的类时,我得到一个错误,告诉我需要按照常规方法指定返回类型.这是正确的还是我做错了什么？

我有一个抽象类,有一个抽象的方法:

public abstract SomeClass Do(SomeClass o1, SomeClass o2);

然后,当我在一个具体类中实现时,该类扩展了具有之前方法的抽象类,我得到一个错误:

@Override 
public AClass Do(AClass o1, AClass o2) //AClass extends Someclass
{
//
}

为什么我得到错误,因为AClass是SomeClass的子类型？

错误是:方法...必须覆盖或实现超类型方法

我有一个名为Answer的抽象类.它需要是抽象的,因为假设,可以有许多不同类型的答案,如字符串答案,视频答案,音频答案等.

public abstract class Answer {

abstract public void display();

abstract public Answer getAnswer();

abstract public boolean isEqual();

}

现在在StringAnswer中,我想覆盖这些方法.

public class StringAnswer extends Answer
{
String text;

public StringAnswer(String text)
{
    this.text = text;
}

@Override
public void display()
{
    System.out.println(text);
}

@Override
**public String getAnswer()
{
    return text;
}**

@Override
public boolean isEqual()
{
    // TODO Auto-generated method stub
    return false;
}
}

getAnswer给我带来了问题,因为我正在尝试返回一个字符串,但它期待回复.从抽象的意义上讲,我想回答一个答案.但是,StringAnswer的内容显然是一个String.

那么,当它期待一个答案时,如何将它作为字符串返回？

我有一个抽象类:

abstract class Shape {

    public String color;
    public Shape() {
    }
     public void setColor(String c) {
        color = c;
    }
    public String getColor() {
        return color;
    }

    public double area() {
        return 0;
    }
}

哪个提供非抽象方法然后我想初始化它像:

     Shape object = new Shape();

所以在初始化时,它仍然给我一个错误,但为什么呢？如果我在类中提供一个抽象方法,那么可以理解该类无法初始化.在这种情况下,为什么还会出错？任何帮助,将不胜感激

在javaFX中Application是一个抽象类。在这个抽象类中，有一些抽象方法在扩展抽象应用程序类的主类中被重写，并且在抽象类应用程序中也有静态 launch() 方法。launch() 方法从主类中的 main 方法调用。现在 launch() 方法如何调用这些抽象方法，并且对于这些调用，执行主类中的重写方法？请帮助我了解这个程序实际上是有效的。我知道非静态方法不能从静态方法调用，并且不可能创建抽象类的实例。抽象方法不能是静态方法。

我不想创建主类的对象。因为launch()方法不知道主类的名称是什么。

给我写一段java代码，这个过程很好地说明了这一点。像这样

public class main extends Application{
    public static void main(String[] args)
        launch();                       // launch() was a static method in Application class
    }
    @override
    public void init(){                 // init() was an abstract method in Application class
        System.out.println("hello");
    }
}

public abstract class Application {
    public static void launch(){
        init();
    }
    public abstract void init();
}

我想得到输出：你好