标签: abstract-class

为简单起见,假设我有一个"Base"抽象类:

public abstract class BaseClass
{
    public abstract void BaseMethod(object obj);

    public abstract void BaseMethod();
}

我想从这个"BaseClass"继承第二和第三类:

public class Class1 : BaseClass
{
    public override void BaseMethod(object obj)
    {
        //Some code
    }
}

public class Class2 : BaseClass
{
    public override void BaseMethod()
    {
        //Some code
    }
}

基本上,我希望每个类都实现一个方法而不实现另一个.上面的例子不起作用,因为对于每个类我都被提示实现另一个抽象方法.

我知道我可以实现另一种方法'空'.但是,我试图避免这种情况,因为我发现了以下声明:

可以在不实现抽象方法的情况下继承抽象类(尽管这样的派生类本身是抽象的)

这种说法有误吗？非常感谢有关此主题的任何意见.谢谢!

我在打字稿中有这个抽象类

export abstract class IGenericsReferenceDataService<T> {
    GetAll<T>(types:T) {
        return types;
    };
}

在另一个文件中，我有此类尝试实现以上内容

@Injectable()
export class TradeSourceServiceGenerics implements IGenericsReferenceDataService<tradeSources> {
    GetAll<T>(types:tradeSources):tradeSources {
        return types;
    }
}

在上面的文件中，我有一个名为tradeSources的对象数组

var tradeSources = [***thedata***] 

但是，在代码中，IGenericsReferenceDataService的“ tradeSources”用红色突出显示，错误消息为“无法找到名称tradesources”，这在Webstorm中的“ tradeSources”的其他两个实例中都是这样，我哪里出错了？

假设我有一个酒类,它有两个派生类:葡萄酒和啤酒.如果我将制作一个继承了Wine和Beer的类Cider,会发生什么？

在Cider类中会出现多少份酒精？

我知道它可以通过虚拟继承来完成而没有它,但会有什么区别？

在使用C++工作时遇到了麻烦.我已经在SO和其他地方尝试了几个答案(比如:从函数中返回一个抽象类,如何使抽象类正确返回另一个抽象类的具体实例？),但我仍然一直有麻烦 - 这些似乎并不完全适合......

我有一个抽象类,派生类:

class AbstractClass {
    virtual std::string virtMethod() = 0;
}

class Derived : public AbstractClass {
    std::string virtMethod();
}

另外,我是一个单独的类,我正在尝试获取抽象类的返回类型(当然,返回派生类的实例).

我尝试过使用指针和引用:

AbstractClass* methodFromOtherClass() {
    if (somethingIsTrue) {
        Derived d = Derived();
        return &d;
    }

    SomeOtherDerived s = SomeOtherDerived();
    return &s;
}

在Xcode中,它给了我警告:

返回与本地变量"d"关联的堆栈内存的地址

我尝试创建一个静态Derived对象,然后无法在调用我的"methodFromOtherClass()"的方法中销毁它.

我也尝试过智能指针(虽然有人可能会指出我明显误用它们):

std::unique_ptr<AbstractClass> methodFromOtherClass() {
    if (somethingIsTrue) {
        Derived d = Derived();
        return std::unique_ptr<AstractClass>(&d);
    }

    SomeOtherDerived s = SomeOtherDerived();
    return std::unique_ptr<AstractClass>(&s);
}

以上,也许不出所料,给了我一个段落错误.

我习惯于在Java中轻松地做到这一点...任何帮助将不胜感激.C++目前对我来说不是一种非常强大的语言,所以它可能是我忽略的非常基本的东西.

我有一个简单的容器类,指向一个抽象类,我有函数来获取/设置容器类中的指针.更具体地说,这个类看起来像这样:

class Container
{
    Abstract* thing;
public:
    void set(Abstract &obj)
    {
        thing = &obj; //danger of dangling pointer
    }

    Abstract* get()
    {
        return thing;
    }
};

Abstract是一个抽象类.可以看出,存在悬挂指针的危险.我知道我可以制作一个对象的副本(新),然后指向它.但我无法创建抽象类的实例.有什么解决方案吗？

以下是更多信息:

类定义

class Abstract
{
public:
    virtual void something() = 0;
};

class Base : public Abstract
{
    int a;
public:
    Base() {}
    Base(int a) : a(a){}
    virtual void something()
    {
        cout << "Base" << endl;
    }
};

class Derived : public Base
{
    int b;
public:
    Derived() {}
    Derived(int a, int …

我试图找出,如果有可能创建匿名内部类作为抽象.
我认为,它没有意义,因为我正在尝试创建抽象类的实例,但是来自编译器的消息使我感到困惑:

类'从Test派生的匿名类'必须被声明为abstract或实现抽象方法'方法( )'在测试中

码:

abstract class Test{
    abstract void method();
}
Test o = new Test(){};

如果可以将匿名类声明为抽象类,请告诉我如何执行此操作.
我很乐意回答.

我是斯卡拉的新手.我正在尝试创建一个扩展抽象类的Object,如下面的show所示

object Conversions extends UnitConversions
{
 override def inchesToCentimeters(inches:Int) = inches * 2.5
 override def gallonsToLiters(gallons:Int) = gallons * 3.78
 override def milesToKilometers(miles:Int) = miles * 1.6
}

abstract class UnitConversions
{
 def inchesToCentimeters(inches:Int)
 def gallonsToLiters(gallons:Int)
 def milesToKilometers(miles:Int)
}

当我尝试访问对象的成员函数时,我得()这个表达式作为输出.

Conversions.milesToKilometers(20) //I get output ()

更多是以下声明有效???

var ucv:UnitConversions = new Conversions
println(ucv.milesToKilometers(3)) // I get output () here as well

提前致谢 !

我在C++中有这个抽象类:

class A {
public:
  A(int size);
  virtual void doSomething(int inputSize) = 0;
protected:
  virtual bool checkSize(int inputSize);
private:
  int size;
}

A::A(int size) : size(size){}
bool A::checkSize(int inputSize) { return size == inputSize; }

现在,我想要保证的是,对于每个B派生的类A doSomething都是这样的:

class B : public A{
  void doSomething(int inputSize);
}

void B::doSomething(int inputSize){
  if(!checkSize(inputSize)){
     std::cerr<<"wrong inputSize!"<<std::endl;
     return;
  }
  //do something...
}

我怎么能保证从每个派生类A工具doSomething以这种方式开始？

假设我有一个抽象基类,Shape,然后是三个派生类:Triangle,Rectangle和Pentagon.必须根据需求创建派生类,这样我就可以拥有每个派生类中的几个.基类有很多字段,我一直在寻找一种方法只设置一次基类属性,然后稍后为派生类设置不同的字段.既然你无法实例化一个抽象类,那么最好的方法是什么？我想也许创建另一个派生自Shape的类,它只具有Shape的属性,设置那些属性然后转换它但这看起来效率低下并且在它上面写了代码味道.有人可以提出更好的方法吗？谢谢.下面我写了一些针对这种情况的伪代码

public abstract class Shape
{
    public int x, y, z;
}

public class Triangle : Shape
{
   public int a, b, c       
}

public class Facade : Shape
{
}

private Facade InitializeBaseProperties()
{
    Facade f = new Training
    {
       x = 1, y = 2, z = 3
    };
    return f;
}

private void someMethod()
{
   var tmp = InitializeBaseProperties();
   Triangle triangle = tmp;
}

我最近遇到了与类创建/建模相关的问题.

模型动物王国作为类.使用您的类创建表示为虚拟动物园的各种对象.将20只动物添加到这个虚拟动物园(在你的程序的主要方法中,让每只动物发出声音.这不应该是20种不同的物种).

我想到了这个问题,并决定使用抽象类Animal而不是接口.然后我添加了两个类Bird,Mammal由Animal继承.

我的实施

  public abstract class Animal{

      abstract Sound MakeSound();
    }

    public class Bird : Animal
    {
       private Sound _sound;
       public Bird(Sound sound){
       _sound = sound;
    }
    public Sound MakeSound(){
          return _sound;
       }
    }
//same as above with Mammals

public class Program
{
  Animal crow = new Bird("Crow sound");
  Console.WriteLine(crow.MakeSound());

 Animal dog = new Mammal("Dog sound");
  Console.WriteLine(dog.MakeSound());

// and so on with other animals
}

我的问题是 -

1. 我的实施有什么问题？
2. 按照oops概念设计动物王国的正确方法是什么？
3. 在什么情况下我们使用接口而不是抽象类,反之亦然.(用现实世界的例子)

请在网上找到一些重要信息,以便我可以改善这些问题.谢谢.