问题标签 [run-time-polymorphism]

Is it possible in java to inherit some methods from the base class, but not all of them? Just to be clear, i will show you what I mean: Suppose we have the base class Visitor

From Visitor we create 2 more Objects, Client and Companion:

In Client, we create the method:

In order to achieve runtime polymorphism, we need to declare the method in Visitor as well:

The problem is that since we declare the method in Visitor, Companion inherits it as well. We don't want that. When I compile I get the following error:

The type Companion must implement the inherited abstract method Visitor.has_Companion()

There is no point in implementing the method has_Companion() for Companion because it will never be used. It's a waste of code. Can I avoid it in some way? Can the method has_Companion() be inherited only by Client, and not by Companion?

请不要陷入拼写错误。我不明白为什么教授的 saluer 函数正在使用屏幕输出中的教授参数。

代码输出：
Mes hommages pour ma / mon collègue Neumann！


我的 Person 类。

我的另一堂课（教授）

我的主要课程

假设我正在尝试实现一些数学向量类。

由于向量接口将在多个地方使用：基于数组的向量，矩阵返回列和行作为向量接口对象等。

我想为我的向量重载 +,- 运算符。每个运算符都应返回某个向量实现类的新构造对象。

但正如您所知，运算符重载应该返回一个值或一个引用。我无法返回值，因为我需要运行时多态性，所以我留下了引用。但是要有一个在函数调用对象之后不会死掉的引用应该在堆中创建。

那么我应该如何处理这种情况呢？

PS 我可以创建一个 shared_ptr 并返回对包含值的引用，但这看起来不是一个好习惯。

I present to you this code riddle:

Using this compiler:

user@bruh:~/test$ g++ --version

g++ (Ubuntu 7.3.0-16ubuntu3) 7.3.0 Copyright (C) 2017 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

...and this compile string:

g++ main.cpp class.cpp -o main -g

...and these files:

class.hpp:

class.cpp:

main.cpp:

...I get the following output:

My questions:

1. Why does this not segfault when the user supplied argument = 1?

2. Why does this segfault when the user supplied argument > 1?

My short explanation of what the code does:

Creates many objects derived from an abstract base class. Stores references to the objects in containers as std::reference_wrapper around abstract base class reference. Creates the containers of std::reference_wrapper slightly differently. Calls the derived override of pure virtual function via the std::reference_wrappers. Segfaults specifically in the case denoted in the source code above.

I implore the C++ experts... Please help me! This is fascinating and I have no idea why it is happening! I've probably done something dumb.

由于动态方法调度，在使用超类引用创建对象并通过该对象调用已在子类中覆盖的方法时，将调用子类中被覆盖的方法而不是超类中的原始方法。如果被覆盖的方法在另一个子类中再次被覆盖，会发生什么情况？

例如，假设 A 是父类，B 扩展 A，C 扩展 B。假设方法 void m1() 已在 A 中编写，然后在 B 中被覆盖，然后在 C 中再次被覆盖。现在如果我们创建和一个对象如下-

将调用哪个方法？B中的那个还是C中的那个？

我想知道是否为解析虚函数创建了两个“vptr”，一个在“基”类中，它将在 func1() 的派生类对象中继承，另一个在 func2() 的“派生”对象中。

我正在阅读 C++ 中后期绑定多态性的实现，并且了解了虚拟表和虚拟指针。

然后我搜索了 C++ 标准 ( ISO/IEC 14882:2011 ) 以获取有关如何实现此行为的更多信息。

不幸的是，除了 §10.3 中虚函数的定义之外，我发现在这个庞大的标准中没有任何相关性，所以我认为__vptrGCC 使用了的概念，但可以以不同的方式实现。

是否有描述应如何实现虚拟方法的标准或论文？

如何定义同时支持其键和内容String的HashMap？&str我尝试了以下方法：

但它没有编译，说：

我有 3 节课，其中一节是 the super class，另外两节是sub classes. 他们有print()共同的方法。从我调用print()方法时，main()我已经将对象向上转换为super classthen 是不是它必须调用方法super class而不是subclasses. 我在这里有点困惑。这怎么可能？java中的这种行为有什么原因吗？

这是我的代码

程序的输出是

根据我的输出应该是

我在这里错过了什么吗？？？

在我提出问题之前，让我解释一下我的理解和意见。

• 除非有向上转换，否则仅通过覆盖我们无法实现多态性。由于它只能在运行时看到，人们可能将其命名为运行时多态。（我不反对将多态称为运行时多态）
• 我反对将方法重载称为编译时多态性或多态性。

我同意方法重载是静态绑定（编译时绑定），但我看不到多态性。

根据 javadoc，只有polymorphism。没有编译时或运行时多态性。

根据 javadoc 在名为Defining Methods的部分中，它解释了方法的重载。但是没有关于编译时多态性。

据我说：

如果将多态性归入运行时多态性类别，则在更改 JDK 版本时只能看到“编译时多态性”：

如果您从较高的 JDK 版本切换到较低的版本，您将开始看到编译错误。相同的代码在编译时表现不同，例如：lambda 表达式、菱形运算符、switch case 中的字符串、泛型等。

让我阐述一下我的观点，我对运行时多态性和编译时多态性如何出现在博客/教程中的预测：

对话1

开发人员 1：嘿，我今天读到了多态性。如果对接口进行编码，则可以实现多态性。编写代码不是与类紧密耦合，而是通过松散耦合将其写入接口，调用超类方法或接口方法实际上调用子类的方法，具体取决于传递的实例。

开发人员 2：对不起，我没听懂你。

开发人员 1：在运行时很简单，您将传递哪个对象实例，然后执行该实例方法。

开发人员 2：哦！运行时间。我知道了。

开发人员 1：是的，同一段代码，但在运行时传递的实例不同。

开发人员 2：**运行时间！好的，我明白了。

对话2

开发人员 2：嘿，昨天我遇到了开发人员 1，他正在讲述一些运行时多态性。通过覆盖子类中的方法，我们可以实现它。

开发人员 3：通过重写方法实现运行时多态性？那么什么是超载呢？编译时多态？

开发人员 2：您如何将重载称为编译时多态性？

开发人员 3：因为它只在编译时决定。

开发人员 2：安静！

接口的多态性和编码最好的例子是 java.sql：

根据注册的驱动程序，同一段代码的行为不同。这意味着，如果我们注册 Mysql 驱动程序，由于多态性，这段代码会执行 mysql 实例的方法。即它执行被覆盖的方法。如果您注册了 Oracle 驱动程序，它适用于 Oracle，依此类推。

上面我们发现相同的代码表现不同。

现在任何人都可以向我展示在编译时表现不同的相同代码。或者换句话说add(3,4)，在编译期间向我展示绑定到不同方法（其他签名方法）的方法？

根据 javadoc，

Java 编程语言支持重载方法，Java 可以区分具有不同方法签名的方法。

该方法将根据匹配的签名执行。方法名称相同并不意味着存在多态性，因为调用方法的签名不同：

问题1：如果您不更改调用方法签名，它会调用与签名匹配的方法不同的方法吗？在任何情况下，它的行为都会有所不同吗？

让我们看一下方法重载：

问题 1：如果方法重载是多态，那么在上面的代码块中哪段代码的行为不同？这里的多态性在哪里？

问题2：add(3,4);在什么场景下显示多态的方法调用，除非它被修改为add(3,4,5)？

---

编辑
@FutureVisitor，因为这个线程没有找到支持方法重载作为一种多态性的答案（即使在提出一个月的问题之后），没有任何理由接受支持方法重载的答案不是多态性，如果有任何答案点问题在我关于方法重载不是多态的论点中将被接受并支持他们的观点。