标签: abstract-class

我有一个JSON格式的树对象我试图用Gson反序列化.每个节点包含其子节点作为对象类型Node的字段.Node是一个接口,它有几个具体的类实现.在反序列化过程中,如果我不知道该节点属于哪种类型的先验,我如何与Gson通信哪个具体类在反序列化节点时要实现？每个节点都有一个指定类型的成员字段.当对象是序列化形式时,有没有办法访问该字段,并以某种方式将类型传递给Gson？

谢谢!

我被告知要让我的课抽象:

public abstract class Airplane_Abstract

并制作一个名为move virtual的方法

 public virtual void Move()
        {
            //use the property to ensure that there is a valid position object
            double radians = PlanePosition.Direction * (Math.PI / 180.0);

            // change the x location by the x vector of the speed
            PlanePosition.X_Coordinate += (int)(PlanePosition.Speed * Math.Cos(radians));

            // change the y location by the y vector of the speed
            PlanePosition.Y_Coordinate += (int)(PlanePosition.Speed * Math.Sin(radians));
        }

而另外4种方法应该是"纯虚拟方法".究竟是什么？

它们现在看起来都像这样:

public virtual void TurnRight()
{
    // turn right relative to the …

由于C++缺少interfaceJava和C#的特性,在C++类中模拟接口的首选方法是什么？我的猜测是抽象类的多重继承.在内存开销/性能方面有什么影响？这种模拟接口是否有任何命名约定,例如SerializableInterface？

通过直接调用abstract类的构造函数来创建对象是不可能的.abstract只能从派生类中调用类的构造函数.因此,在我看来,抽象类的构造函数必须是或者是protected私有的(后者用于限制将构造函数用于包中的派生类的异常情况).然而,Java允许abstract类的构造函数public.

有没有在它是任何情况下有用申报的构造函数abstract的类要public,而不是protected或包专用？

这与" 抽象类构造函数访问修饰符 " 这个问题并不完全相同:显然你可以声明一个构造函数public; 我想知道是否有过任何好的理由这样做.在我看来,没有.我看到C#具有类似的特性.

如果我想使类适应,并且可以从外部选择不同的算法 - C++中最好的实现是什么？

我主要看到两种可能性:

• 使用抽象基类并传递具体对象
• 使用模板

这是一个小例子,在各种版本中实现:

版本1:抽象基类

class Brake {
public: virtual void stopCar() = 0;  
};

class BrakeWithABS : public Brake {
public: void stopCar() { ... }
};

class Car {
  Brake* _brake;
public:
  Car(Brake* brake) : _brake(brake) { brake->stopCar(); }
};

版本2a:模板

template<class Brake>
class Car {
  Brake brake;
public:
  Car(){ brake.stopCar(); }
};

版本2b:模板和私有继承

template<class Brake>
class Car : private Brake {
  using Brake::stopCar;
public:
  Car(){ stopCar(); }
};

来自Java,我自然倾向于始终使用版本1,但模板版本似乎经常是首选,例如在STL代码中？如果这是真的,是因为内存效率等(没有继承,没有虚函数调用)？

我意识到版本2a和2b之间没有太大的区别,请参阅C++ …

我非常熟悉接口和抽象类的概念,但不熟悉mixins的概念.

现在,在Dart中,每个类都A定义了一个隐式接口,可以B通过使用implements关键字由另一个类实现.没有明确的方式来声明接口,例如,在Java中,接口只包含未实现的方法(最终是静态变量).在Dart中,由于接口是由类定义的,接口的方法A实际上可能已经实现,但实现的类B仍然需要覆盖这些实现.

我们可以从以下代码中看到这种情况:

class A {
  void m() {
    print("method m");
  }
}

// LINTER ERROR: Missing concrete implementation of A.m
// Try implementing missing method or make B abstract.
class B implements A {
}

在Dart中,mixin也是通过普通的类声明来定义的......

...原则上,每个类都定义了一个可以从中提取的mixin.但是,在此提议中,mixin只能从没有声明构造函数的类中提取.这种限制避免了由于需要在继承链上传递构造函数参数而引起的复杂化.

mixin基本上是一个可以定义未实现或实现的方法的类.这是一种将方法添加到另一个类而无需逻辑上使用继承的方法.在Dart中,mixin应用于超类,通过"正常"继承扩展,如下例所示:

class A {
  void m() {
    print("method m");
  }
}

class MyMixin {
  void f(){
    print("method f");
  }
}

class B extends A with MyMixin {
}

在这种情况下,我们应该注意到,B …

我有许多类都共享相同的方法,只有不同的实现.在Java中,让每个类实现一个接口或扩展一个抽象类是有意义的.Python有没有类似的东西,或者我应该采取替代方法？

假设我在抽象基类指针mypointer-> foo()上有一个虚函数调用foo().当我的应用程序启动时,根据文件的内容,它选择实例化一个特定的具体类,并将mypointer分配给该实例.对于应用程序的其余部分,mypointer将始终指向该具体类型的对象.我无法知道这个具体类型是什么(它可以由动态加载的库中的工厂实例化).我只知道在第一次生成具体类型的实例后,类型将保持不变.指针可能并不总是指向同一个对象,但该对象将始终具有相同的具体类型.请注意,类型在技术上是在'运行时'确定的,因为它基于文件的内容,但是在'启动'(加载文件)之后,类型是固定的.

但是,在C++中,每次在应用程序的整个持续时间内调用foo时,我都会支付虚函数查找成本.编译器无法优化查找,因为它无法知道具体类型在运行时不会发生变化(即使它是有史以来最令人惊奇的编译器,也无法推测动态加载的行为库).在JIT编译语言(如Java或.NET)中,JIT可以检测到反复使用相同类型并执行内联缓存.我基本上是在寻找一种方法来手动为C++中的特定指针执行此操作.

在C++中是否有任何方法可以缓存此查找？我意识到解决方案可能非常糟糕.我愿意接受ABI /编译器特定的黑客攻击,如果有可能编写发现ABI /编译器相关方面的配置测试,那么即使不是真正可移植的,它也"实际上是可移植的".

更新:对反对者:如果这不值得优化,那么我怀疑现代JIT会做到这一点.您是否认为Sun和MS的工程师正在浪费时间实施内联缓存,并没有对其进行基准测试以确保有所改进？

我有一个抽象类,它有一个泛型方法,我想通过用特定类型替换泛型参数来覆盖泛型方法.所以在伪代码中我有以下内容:

public abstract class GetAndParse {
  public SomeClass var;

  public abstract <T extends AnotherClass> void getAndParse(T... args);
}

public class Implementor extends GetAndParse {
  // some field declarations

  // some method declarations

  @Override
  public <SpecificClass> void getAndParse(SpecificClass... args) {
    // method body making use of args
  }
}

但由于某种原因,我不允许这样做？我是在做某种语法错误还是这种继承和覆盖是不允许的？具体来说,我收到一个错误,@Override因为eclipse IDE一直在提醒我实现getAndParse.

以下是我希望上述代码的工作方式.我的代码中的其他地方有一个方法,它需要实现的对象实例,GetAndParse这意味着它们有一个getAndParse我可以使用的方法.当我调用getAndParse该实例时,编译器会检查我是否T以正确的方式使用了特定的实例,因此特别T应该扩展AnotherClass它应该是SpecificClass.

我有一个包含纯虚函数的基类MyBase:

void PrintStartMessage() = 0

我希望每个派生类在它们的构造函数中调用它

然后我把它放在基类(MyBase)构造函数中

 class MyBase
 {
 public:

      virtual void PrintStartMessage() =0;
      MyBase()
      {
           PrintStartMessage();
      }

 };

 class Derived:public MyBase
 {     

 public:
      void  PrintStartMessage(){

      }
 };

void main()
 {
      Derived derived;
 }

但我收到链接器错误.

 this is error message : 

 1>------ Build started: Project: s1, Configuration: Debug Win32 ------
 1>Compiling...
 1>s1.cpp
 1>Linking...
 1>s1.obj : error LNK2019: unresolved external symbol "public: virtual void __thiscall MyBase::PrintStartMessage(void)" (?PrintStartMessage@MyBase@@UAEXXZ) referenced in function "public: __thiscall MyBase::MyBase(void)" (??0MyBase@@QAE@XZ)
 1>C:\Users\Shmuelian\Documents\Visual Studio 2008\Projects\s1\Debug\s1.exe : fatal …