标签: polymorphism

我正在创建一个接受对象列表作为参数的新类.

但是我想这样做,所以这些对象可以是任何东西,只要它们有某些方法,例如.getValue()返回单个double的.getTimestamp()方法,或返回单个的方法long等.

可以这样做吗？

大多数语言对类使用单继承.这样做的模式相当明显(例如在下面的Swift代码中).我仍然试图在JavaScript中围绕模式来创建对象层次结构并重用类函数和覆盖类函数

class animal {
    func talk() {
        print ("?")
    }
}

class bird : animal {
    override func talk() {
        print("tweet tweet")
    }
    func fly() {
        print("flap flap")
    }
}

class parrot : bird {
    override func talk() {
        print("polly want a cracker")
    }
}

var a = animal()
var b = bird()
var p = parrot()

a.talk()  /// ?
b.talk()  /// tweet tweet
b.fly()   /// flap flap
p.talk()  /// polly want a cracker
p.fly()   /// flap flap

我认为我的问题是Javascript代码看起来不像这样.什么是等效的Javascript代码,所以我可以找出模式？

我想我陷入了思考以下问题的多态性解决方案中：

假设我有BaseTX struct一个交易字段。现在我有两种特殊类型的交易：RewardTX struct和AllowanceTX struct。

RewardTX struct此刻只有 的组成BaseTX struct。

AllowanceTX struct具有BaseTX struct和 的组成AddField。

我还有一个函数logicAndSaveTX()，它对来自的字段有一些逻辑，BaseTX但最后是使用序列化整个对象json.Marshal()并将其保存在byte[]某处。

type TXapi interface {
    logicAndSaveTX()
}

type BaseTX struct {
    Field1 string
    Field2 string
}

type RewardTX struct {
    BaseTX 
}

type AllowanceTX struct {
    BaseTX 
    AddField string
}

func (tx BaseTX) logicAndSaveTX() {
    // logic on BaseTX fields; simplified:
    tx.Field1 = "overwritten"
    tx.Field2 …

我正在尝试使用具有相同基类的不同子类指针的向量。该向量设置为基类指针，但是添加到该向量的任何内容都无法获得其子类的全部功能。在错误日志中可以看到，它被视为基类，因此未获得扩展功能。

我查看了很多问题，人们说要按照我的方式去做，但是由于某种原因，它没有用。

该代码位于公共仓库中：

https://repl.it/@cubingminer8/inheritance-with-vectors-testing

任何帮助将不胜感激！

编辑：确定，所以我将在c ++ sdl2游戏引擎中将其用于子画面组系统。将有一个基本的Sprite类，其中包含一些基本的东西，例如render和move，而我需要的任何sprite都是它们自己的继承自Sprite的类，它们将具有自己的独特行为，因此虚函数是不切实际的。将有一个sprite组对象，可以将继承自Sprite的对象存储在其中。这样就可以一次全部渲染它们。

如果您曾经使用过pygame，那么它几乎与那里使用的sprite和spritegroup系统相同。 https://www.pygame.org/docs/tut/SpriteIntro.html

#include <iostream>
#include <vector>

class Base {
public:
    char A = 'A';
};

class Sub : public Base {
public:
    char B = 'B';
};

class Sub2 : public Base {
public:
    char C = 'C';
};

int main() {
    std::vector<Base*> List;
    List.push_back(new Sub());
    List.push_back(new Sub2());

    std::cout << List[0]->B << std::endl; // it should be able to print B
    std::cout << List[1]->C << std::endl; // but it is …

我不明白为什么下面的代码不能编译。

我很困惑为什么 Go 说HistoryReader没有正确实现IReader。HistoryBook实现IBook. 当尝试将 a 添加到 s 的切片时，为什么Read(book Ibook)和不能同时接受？Read(book HistoryBook)HistoryReaderIReader

package main

type IReader interface {
   Read(book IBook)
}

// HistoryReader implements IReader
type HistoryReader struct{}

func (r *HistoryReader) Read(book HistoryBook) {
   // ...
}

type IBook interface{}

// HistoryBook implements IBook
type HistoryBook struct{}

func main() {
   var readerSlice []IReader

   _ = append(readerSlice, &HistoryReader{})
}

package main

type IReader interface {
   Read(book IBook)
}

// …

我正在尝试std::unique_ptr类继承（即多态性）。我正在运行的代码如下：

#include<iostream>
#include<memory>

class polygon {
    public:
    int side;
    polygon(int i): side(i) {std::cout<<"polygon created"<<std::endl;}
    virtual int perimeter() = 0;
    ~polygon() {std::cout<<"polygon destroyed"<<std::endl;}
};
class triangle : public polygon {
    public:
    triangle(int i): polygon::polygon{i} {std::cout<<"triangle created"<<std::endl;}
    int perimeter() { return side*3; }
    ~triangle() {std::cout<<"triangle destroyed"<<std::endl;}
};
class square : public polygon {
    public:
    square(int i): polygon::polygon{i} {std::cout<<"square created"<<std::endl;}
    int perimeter() { return side*4; }
    ~square() {std::cout<<"square destroyed"<<std::endl;}
};

int main() {
    std::unique_ptr<polygon> pp = std::make_unique<square>(5); // (1)
    std::cout << …

我非常需要这个问题的答案 - 使用代码示例的泛型和多态之间的差异.我知道它相关的编译时间或绑定的东西,但我不确定..请帮助

鉴于上课

public class Dog extends Animal implements Friend{

  ...
}

以下哪项性能更为昂贵？

Dog myDog = (Dog) someAnimal;//where Animal someAnimal

要么

Dog myDog = (Dog) someFriend;//where Friend someFriend

我理解这个问题可能需要一些专业知识来回答,所以谢谢你的帮助.请提供一些有价值的解释.

在查看从旧版本的Visual Studio(6)移植到新版本(2017)的继承项目时,我们偶然发现了这个运行时错误,因为我们在使用dynamic_cast<>()基类后得到了意外的NULL .这是一个代表性的样本:

鉴于此代码:

class a { public: a() {}; virtual ~a() {}; };

class b :public a { public: b() {};  virtual ~b() {}; };

class c : public b { public: c() {};  virtual ~c() {}; };

int main()
{
    a *a_ = new b();
    b *b_ = new c();
    c *c_1 = dynamic_cast<c*>(b_); //<-- returns c_1 = non-null(actual pointer value)
    c *c_2 = dynamic_cast<c*>(a_); //<-- returns c_2 = NULL
}

我相信作者已经正确设置了所有课程dynamic_cast<>().类c'是'a类似乎看起来很满意,而类c'是'类b'所以看起来很满意.

我想知道问题是否存在于a_ …

我在 java 项目中有一个继承的对象，我试图调用子对象中的重写方法。由于某种原因，正在调用该方法的父版本。我对多态性的理解是，总是调用方法的最低版本。为什么调用父版本？

public class Generator
{
    public static void acceptPending()
    {
        System.out.println("top level is called");
    }
}

public class GeneratorNeo extends Generator
{
    public static void acceptPending()
    {
        System.out.println("neo level is called");
    }
}

public class Driver()
{
    public static void main(String[] args)
    {
        Generator gen = null;
        gen = new GeneratorNeo();
        gen.acceptPending(); // prints top level is called
    }
}