Which OO concept is “Base b = new Derived()” an ex

问题:

I was passing a test and met a question in which we didn't find an agreement with my colleagues.

С++

  1 class Base {};
  2 class Derived : public Base {};
  3 class Foo
  4 {
  5 public:
  6     Foo()
  7     {
 -8-         Base* b = new Derived(); // Concept name is?
  9     }
 10 };

C#

  1 abstract class Base{}
  2 public class Derived : Base{}
  3
  4 public class Foo
  5 {
  6    public Foo
  7    {
 -8-        Base b = new Derived(); // Concept name is?
  9    }
 10 }

The question is: line number 8 above is an example of the following oo concept

1. Polymorphism
2. Aggregation
3. Encapsulation
4. Abstraction
5. Inheritance

Please put a link with the answer to the source of knowledge.

P.S. The test is 'OO Concept' on breinbench. It is free.

Update:

From one of the answer which defends polymorphism

"In simple terms, polymorphism is the ability of one type, A, to appear as and be used like another type, B. In strongly typed languages, this usually means that type A somehow derives from type B, or type A implements an interface that represents type B."

From wikipedia which defends inheritance

Inheritance is also sometimes called generalization, because the is-a relationships represent a hierarchy between classes of objects.

and

Inheritance therefore has another view, a dual, called polymorphism, which describes many pieces of code being controlled by shared control code.

so Base = new Derived() shows 'is a'(inheritance). And consequence of this is polymorphism.

So I doubt what is right?

回答1:

This question is easy... It is Polymorphism.

The Polymorphic behavior is accomplished because of inheritance. You can treat the instance of Derived as Base because Derived inherits from Base. This is the definition of Polymorphism when applied to types in an OO language...

http://en.wikipedia.org/wiki/Polymorphism_(computer_science)

[Update, Update]

I hope this is definitive enough... these are all different ways of saying the same thing.

Polymorphism (C# Programming Guide)

"Through inheritance, a class can be used as more than one type; it can be used as its own type, any base types, or any interface type if it implements interfaces. This is called polymorphism."

[Update]

Given the comments I will try to be more specific... I am not saying that because Derived inherits from Base that the line is an example of Polymorphic behavior, I am saying that the assignment of an instance to a variable of a type that it derives from is an example of Polymorphic behavior. To quote the first sentence of the link I attached...

"In computer science, polymorphism is a programming language feature that allows values of different data types to be handled using a uniform interface"

Meaning that I can treat an instance of Derived as an instance of Base is exhibiting a Polymorphic behavior. This doesn't depend on the existence of virtual methods on the class to be true.

and another quote from a different source...

"In simple terms, polymorphism is the ability of one type, A, to appear as and be used like another type, B. In strongly typed languages, this usually means that type A somehow derives from type B, or type A implements an interface that represents type B."

回答2:

The real answer is: a poorly formed and therefore meaningless question.

This is suppose to be a standardized multiple choice question yet you have people with many years of experience not coming to a consensus. The only conclusion that should be reached is that as a measurement of knowledge it is useless.

回答3:

This snippet is about Inheritance

A rough summary of concepts

Abstraction is about the whole idea of modeling a real-world concept in terms of objects rather than thinking about function calls or other stuff. It's basically thinking about objects as separate entities.

Encapsulation is the act of hiding implementation of an object from the outside world behind well-defined interfaces.

Inheritance is the relationship between derived classes and base classes and categorization of concepts. It defines "is-a" relationship between too entities, adding the ability of using derived classes where a base is expected.

Polymorphism means two objects are similar in interface but behave in different ways (think about virtual methods).

Aggregation defines a "has-a" relationship between two concepts. Means an object is composed out of another entity.

回答4:

I think the diversity of the answers demonstrates that this is a poorly constructed question.

If you put a gun to my head, I would probably choose inheritance, since this models that since Derived inherits Base, then Derived can be used where a Base is required (such as being pointed to by a Base*) but I could imagine a defense of any of the answers.

If I were making a hiring decision, I'd be more interested in hearing how a candidate defended her chosen answer than in which one she chose. But a company using a test like this probably isn't, or doesn't have anyone on staff capable of assessing skills at that level.

回答5:

I'd have said Polymorphism, because the types are assignable to each other and can be treated as if they are the same. You are using the parent interface to handle the instance of the subtype.

Inheritance is more to do with inheriting members and/or member implementations from parent to child (aka base to derived, super to sub, abstract to concrete) class.

I see resolution of virtual functions to a concrete implementation as a feature of polymorphism so would not be put off by the absence of virtual function resolution in the example.

回答6:

The answer is polymorphism.

See http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming.

Many of the answers here discard this answer because there is no virtual function call. But that is just one example of polymorphism (and the most common). But that's not the only one.

The definition of polymorphism in simplest terms is summed up by the wikipedia article nicely:

In simple terms, polymorphism is the ability of one type, A, to appear as and be used like another type, B. In strongly typed languages, this usually means that type A somehow derives from type B, or type A implements an interface that represents type B.

Certainly line 8 is an example of an object appearing to be of type Base but really is of type Derived

回答7:

1. Polymorphism

   • no, because we don't make any calls of virtual methods - and don't use polymorphic behaviour on any other manner

2. Aggregation

   • no, because because Base* b is not member

3. Encapsulation

   • don't see what we have encapsulated.. except implementation of constructor

4. Abstraction

   • I think - yes - we will use more abstract class then created

5. Inheritance

   • relationship between base and derived is inheritance - but you asked about assignment line

EDIT

Abstraction is simplifying complex reality by modelling classes appropriate to the problem, and working at the most appropriate level of inheritance for a given aspect of the problem.

definition from wikipedia - http://en.wikipedia.org/wiki/Object_oriented

回答8:

6. None of the above.  

It's an example of covariance.
http://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)
See also, Liskov subtitutability principle:
http://en.wikipedia.org/wiki/Liskov_substitution_principle

回答9:

I think the simple code here is best described as an example of subtyping (http://en.wikipedia.org/wiki/Subtype). In object-oriented programming terminology, polymorphism refers to the ability of subclasses to change or specialize the behaviour defined in the base class (http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming). This example doesn't really show that.

Of the choices listed on brainbench, I guess inheritance makes the most sense simply because its the most vague.

回答10:

It isn't directly any of the choices given.

It isn't directly about polymorphism because the code isn't calling a virtual method through a base pointer or deleting a pointer to the base class.

It isn't directly about inheritance because the highlighted code doesn't do any inheritance.Line 2 is about inheritance.

It certainly isn't about abstraction, encapsulation or aggregation because, well, it's not anywhere near those things.

The concept is most directly illustrates is an automatic cast.