Java 和 C++ 在对象创建方面的主要区别是什么？

发布于 2024-09-25 16:45:02 字数 216 浏览 4 评论 0原文

我正在准备 Java 考试，之前考试的问题之一是：“Java 和 C++ 在对象创建方面的主要区别是什么？”

我想我知道对象创建的基础知识，例如如何调用构造函数、初始化块在 Java 中做什么，以及当一个类的构造函数调用另一个尚未构造的类的方法时会发生什么，等等，但我可以找不到任何明显的东西。答案应该是一两句话，所以我不认为用Java描述整个对象创建过程是他们想要的。

有什么想法吗？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

呆橘 2024-10-02 16:45:02

Java 和 C++ 在对象创建方面的主要区别是什么？

与 Java 不同，C++ 中的对象也可以在堆栈上创建。

例如，在 C++ 中，您可以编写

Class obj; //object created on the stack

在 Java 中，您可以编写

Class obj; //obj is just a reference(not an object)
obj = new Class();// obj refers to the object

What is the main difference in object creation between Java and C++?

Unlike Java, in C++ objects can also be created on the stack.

For example in C++ you can write

Class obj; //object created on the stack

In Java you can write

Class obj; //obj is just a reference(not an object)
obj = new Class();// obj refers to the object

回复收藏 0 原文

夏末 2024-10-02 16:45:02

除了其他出色的答案之外，还有一件事非常重要，并且通常被忽略/忘记或误解（这解释了为什么我详细介绍了下面的过程）：

在 Java 中，方法是虚拟的，即使从构造函数调用时也是如此（这可以导致错误）
在 C++ 中，从构造函数调用时虚拟方法不是虚拟的（这可能会导致误解）

什么？

让我们想象一个带有虚方法 foo() 的基类。
让我们想象一个继承自 Base 的 Derived 类，它重写了方法 foo()

C++ 和 Java 之间的区别是：

在 Java 中，从 Base 类构造函数调用 foo() 将调用 Derived.foo()
在 C++ 中，调用 foo( ) 从 Base 类构造函数中会调用 Base.foo()

为什么？

每种语言的“错误”是不同的：

在 Java 中，调用构造函数中的任何方法都可能导致微妙的错误，因为重写的虚拟方法可能会尝试访问在派生类中声明/初始化的变量。

从概念上讲，构造函数的工作是使对象存在（这可不是一件普通的事情）。在任何构造函数中，整个对象可能只是部分形成 - 您只能知道基类对象已被初始化，但您无法知道哪些类是从您继承的。然而，动态绑定的方法调用会“向前”或“向外”进入继承层次结构。它调用派生类中的方法。如果您在构造函数内执行此操作，则调用的方法可能会操作尚未初始化的成员 - 这肯定会导致灾难。
布鲁斯·埃克尔，http://www.codeguru.com/java/tij/tij0082 .shtml

在 C++ 中，必须记住 virtual 不会按预期工作，因为只会调用当前构造类的方法。原因是为了避免访问数据成员甚至尚不存在的方法。

在基类构造期间，虚函数永远不会进入派生类。相反，该对象的行为就像它是基本类型一样。通俗地说，在基类构造过程中，虚函数不是。
斯科特·迈耶斯，http://www.artima.com/cppsource/nevercall.html

In addition to other excellent answers, one thing very important, and usually ignored/forgotten, or misunderstood (which explains why I detail the process below):

In Java, methods are virtual, even when called from the constructor (which could lead to bugs)
In C++, virtual methods are not virtual when called from the constructor (which could lead to misunderstanding)

What?

Let's imagine a Base class, with a virtual method foo().
Let's imagine a Derived class, inheriting from Base, who overrides the method foo()

The difference between C++ and Java is:

In Java, calling foo() from the Base class constructor will call Derived.foo()
In C++, calling foo() from the Base class constructor will call Base.foo()

Why?

The "bugs" for each languages are different:

In Java, calling any method in the constructor could lead to subtle bugs, as the overridden virtual method could try to access a variable which was declared/initialized in the Derived class.

Conceptually, the constructor’s job is to bring the object into existence (which is hardly an ordinary feat). Inside any constructor, the entire object might be only partially formed – you can know only that the base-class objects have been initialized, but you cannot know which classes are inherited from you. A dynamically-bound method call, however, reaches “forward” or “outward” into the inheritance hierarchy. It calls a method in a derived class. If you do this inside a constructor, you call a method that might manipulate members that haven’t been initialized yet – a sure recipe for disaster.
Bruce Eckel, http://www.codeguru.com/java/tij/tij0082.shtml

In C++, one must remember a virtual won't work as expected, as only the method of the current constructed class will be called. The reason is to avoid accessing data members or even methods that do not exist yet.

During base class construction, virtual functions never go down into derived classes. Instead, the object behaves as if it were of the base type. Informally speaking, during base class construction, virtual functions aren't.
Scott Meyers, http://www.artima.com/cppsource/nevercall.html

回复收藏 0 原文