标签: abstract-class

我是一个编程新手,所以请耐心等待我.我搜索并找不到可以回答这个问题的现有主题.我写了下面的代码,它应该根据用户是将安全对象识别为股票还是债券来吐出stock.toString()或bond.toString()罐头短语.但是,我得到"安全无法解决"的编译错误.我想这是一个问题,因为安全对象的类没有在编译时定义.真的吗？如果是这样,有没有办法解决这个问题而不采用反思方法？谢谢!

public static void main(String[] args) {

    double thePrice;
    double theShares;
    double theEarnings;
    double theRate;
    String securityType;

    Scanner in = new Scanner(System.in);

    System.out.println("Is it a stock or a bond?");
    securityType = in.nextLine();

    if (securityType.compareToIgnoreCase("stock") == 0) {
        System.out.println("Successfully set to STOCK");
        System.out.println("What are the earnings?");
        theEarnings = in.nextDouble();
        Stock security = new Stock();
        security.setEarnings(theEarnings);
    }

    else if (securityType.compareToIgnoreCase("bond") == 0) {
        System.out.println("Successfully set to BOND");
        System.out.println("What is the rate?");
        theRate = in.nextDouble();
        Bond security = new Bond();
        security.setRate(theRate);
    }

    System.out.println("What …

更新:我的类比这更复杂,我只是停留在ArrayList行

我有以下课程:

class CatList {

    List<Cat> cats = new ArrayList<Cat>();

}

和

class DogList {

    List<Dog> dogs = new ArrayList<Dog>();

}

猫和狗都是数据类.

但我想创建一个抽象类:

abstract class AnimalList {

    List<???> animals;

    AnimalList(Class animal) {

        animals = new ArrayList<???>();

    }
}

这样我就可以继承我的课程

AnimalList CatList = new AnimalList(Cat);
AnimalList DogList = new AnimalList(Dog);
AnimalList CowList = new AnimalList(Cow);

希望这更有意义.我的问题是什么？位？

我正在考虑如何使用抽象方法编写一个抽象基类,该抽象方法将采用一个两个Int值.就像是:

abstract class Foo {
  def doSomething(???): Unit
}

到目前为止,我能想到的最好的方法Vector[Int]是将一个参数声明为一个或两个值,或者更好地强制执行最多两个值a Tuple2[Int, Int].

我想这样做,因为我想在Actor系统中传递算法,并且我希望某些消息强制执行算法的类型而不是传递Any,因此抽象基类.

这是最好的方式,还是有更好的方法？

这里有一种否定的怀疑(另一个来自我:P)

关于我正在阅读的一本书:

• 一个抽象基类(ABC)是通过纯虚方法的声明来实现的.
• 使方法成为纯虚方法的原因在于= 0声明的最后.
• 您可以将此声明为:virtual void f() = 0;这样您就不需要在ABC中定义它,但派生类必须实现它自己的版本.
• 但是你也可以声明一个这样的虚方法:void f() = 0;这样你需要在ABC中定义方法,派生类可以像这样使用它.ABC需要这种方法,其方法通常由其派生类应用.

如果以上所有要点都是真的,我不明白的是:什么是虚拟方法？

因为void f() = 0;看起来像是我的常规方法.ABC将定义它,派生对象将使用ABC的定义,就像任何其他公共方法一样.是否存在对这两个实例具有吸引力的虚拟方法的定义？

纯虚函数或纯虚方法是一种虚函数,需要由非抽象派生类实现

此定义是从本网站的另一个问题中挑选出来的.所以我的猜测是我读的那本书错了吗？void f() = 0;声明该类是ABC,但它不是纯虚方法.有人可以证实这一点或向我解释一下吗？

看看这堂课

abstract class LolCat<T> {
    T execute() throws Err, Arr {
        T lol = doSomething();
        if (lol == null)
            lol = doSomething();

        return lol;
     }

    abstract T doSomething();
    abstract T doSomething() throws Err, Arr;
}

现在我们在LolCat的某些方法中有一个匿名实现,就像这样

final UhmLetsSayCat cat = new ImplLolCat<UhmLetsSayCat>() {
    @Override
    UhmLetsSayCat doSomething() {
        return null; // somehow a UhmLetsSayCat is returned for real sometimes null
    }

    @Override
    UhmLetsSayCat doSomething() throws Err,Arr {
        return null; // really it does right thing, whatever
    }
 }.execute();

现在我的问题是,为什么第一次调用doSomething()会转到不抛出Err,Arr但第二次调用的方法,如果lol为null,则运行抛出Err,Arr的doSomething实现.如何区分运行哪些方法!？

编辑:错误报警.我的天啊.我一定是整个晚上一直都是瞎​​子,做某事实际上是不一样的方法名称,他们叫做querryAll和QuerryAl1,我会找到那个做过它并揍他的人.

EDIT2:谢谢大家.

我有一堆类,我试图重构和抽象他们的常见成员变量和方法.

我在每个类中看到的一种方法是一个名为MethodFoo()的方法.这个方法有一个Common体,但每个类都添加了一些更多的东西......例如对于一个类,它是这样的:

private method MethodFoo()
{

   // common stuff ...// wow! a Goto Statement ..seriously!  //1

   **// NON-common stuff just for the method of this class**  //2

   Goto: // bunch of COMMON stuff again   //3
}

所以模板总是像第1部分和第3部分在不同的类中对于这个方法是相同的但是在eaxch类中它的不同之处是第2部分...而且也不要忘记那个丑陋的goto语句:)

所以考虑到这张图片,你有没有办法在我的抽象课程中加入一部分内容？

我有一个名为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.

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

这是代码的格式:

class C
{
public:
    C();
    virtual ~C() = 0;
};

class D : public C
{
public:
    D();
    ~D();
};

C::C(){
}

C::~C(){
}

D::D(){
}

D::~D(){
}

int main(){
    C *c = new C();
    D *d = new D();
    return 0;
}

当我尝试实例化时,c我收到以下错误:

1>c:\main.cpp(59): error C2259: 'C' : cannot instantiate abstract class

我知道我无法调用虚拟析构函数,但在概念上有一些我不知道的东西.有人可以解释一下吗？

我目前正在使用一个抽象类,我将通过另一个名为People的类进行扩展

public abstract class MediaContainer<T> {
    abstract T DisplayName(T dispname);
}

但是当我试图在第二次覆盖它时我得到一个错误

public class People<T> extends MediaContainer<T> {
    @Override public T DisplayName(T person){
        return System.out.println(person);
    }
}

我正在编写Acellerated c ++第15章的代码.我或多或少地直接从本书中复制了代码,除了在某些地方他们在头文件的类体中定义了类似构造函数的东西,然后我把它们分开了避免链接错误.

以下是代码; 我试图在Visual Studio 2010中编译它,但不幸的是它失败了.它告诉我它不能创建"String_Pic"和其他派生类(Frame_Pic,HCat_Pic和VCat_Pic)的实例,因为它说它们仍然是抽象类.它说罪魁祸首是"显示"功能,它说是未定义的.但是,我清楚地为每个派生类定义它,如下所示.

这里发生了什么？

标题:

#ifndef _GUARD_PIC_BASE_H
#define _GUARD_PIC_BASE_H

    #include "Ptr.h"
    #include <iostream>
    #include <string>
    #include <vector>


    class Picture;

    class Pic_base {
        friend std::ostream& operator<<(std::ostream&, const Picture&);
        friend class Frame_Pic;
        friend class HCat_Pic;
        friend class VCat_Pic;
        friend class String_Pic;


        typedef std::vector<std::string>::size_type ht_sz;
        typedef std::string::size_type wd_sz;


        virtual wd_sz width() const = 0;
        virtual ht_sz height() const = 0;
        virtual void display(std::ostream, ht_sz, bool) const = 0;

    public:
        virtual ~Pic_base(){ }

    protected:
        static void pad(std::ostream&, wd_sz, wd_sz);
    }; …