What is the difference between Abstraction and Polymorphism

Question

I seem to not understand two OOP concepts very well. Could you explain what abstraction and polymorphism are, preferably with real examples and code?

Thank you.

Answer 1

Abstraction

Imagine a fraction class:

class fraction:     int denominator     int numerator 

Now two objects of that:

fraction(obj1): denominator=-1 numerator=-1 fraction(obj2): denominator=1  numerator=1 

Both objects have the value 1: (1/1) == (-1)/(-1). You wouldn't expect they behave any different to the outside. That's abstraction. You abstract the data your object holds into a logical view, even tho behind the scenes, there are other things. Theoretically, you have got a equivalence relation, with different equivalence groups:

[1]=(1, 1), (-1, -1), (5, 5), ... [2]=(2, 4), (-2, -4), ... ... 

And there is a abstraction function that abstracts the internal details to the outside:

f((1, 1)) = [1] f((-1, -1)) = [1] 

It maps from concrete values to the abstract values of an object. You do that by writing for example a constructor mapping (-1, -1) to (1, 1) and by writing a equals function for your class.

Polymorphism

Imagine a pen and two derived classes:

class pen:     void draw(int x, int y)  class pen_thin extends pen:     void draw(int x, int y) { color(x, y) = green; }  class pen_thick extends pen:     void draw(int x, int y) { color(x, y) = green;                                color(x, y+1) = green; } and two objects:     pen_thin(p1)     pen_thick(p2) 

Both pens can draw. your general "pen" cannot draw itself. It's just an interface to pen_thin, pen_thick and lots of other pens. You say: obj1.draw(1, 0); and whether obj1 is a thick or a thin pen doesn't matter to you as a user, neither to the compiler at compile time. The call behaves polymorphic. It's dynamic polymorphism (happens at runtime) and that's what people usually mean. Static Polymorphism happens at compile time:

class colorizer:     void colorize(shirt s)     void colorize(pants p) 

That's called overloading. You call obj.colorize(something). If you call it with a shirt reference, it will call the version taking a shirt. And if you call it with a pant reference, it will call the pants version. The choice done here is at compile-time.

Answer 2

Abstraction and polymorphism are critical concepts by no means limited to OO. Adding to the confusion, the word 'abstraction' is used multiple ways. Here is a quick cheat sheet with one example:

• Data abstraction means information hiding. Usually what is hidden is the representation of a data structure. Example: I implement sets, but I don't tell you whether a set is represented as a list, a balanced binary tree, or an unbalanced binary tree. Done right, I can change representation without breaking your code.

• Polymorphism means reuse with different types. So with my set example you could create sets of Social Security numbers, sets of full names, or sets of fruitbats, all using the same code.

Obviously you can define a class which is both abstract and polymorphic.

Polymorphism is further confusing because there are two ways to implement polymorphism. In parametric polymorphism, you can reuse the set with values of any type, or maybe any type satisfying some constraint. The most obvious examples are C++ templates; if you write

class Set <T> { ... } 

Then T is the type of objects contained in the set (the notation <T> indicates a so-called "type parameter", which is what makes it parametric polymorphism).

In subtype polymorphism, you can reuse sets only with objects whose types are subtypes of a particular type. For example, you might be able to make sets only of objects that offer a less-than-or-equal-to method. In a true object-oriented language like Smalltalk or Ruby, which offer so-called duck typing (us pointy-headed theorists sometimes call it behavioral subtyping), the presence of the method is good enough. In a language like Java or C++, which conflate subtyping with inheritance, your use of polymorphism may be restricted to subclasses of a particular class. (Java further confuses the issue by using one form of subtyping on classes and another on interfaces.)

Finally, old farts like me talk about procedural abstraction, which just means being able to take a bunch of statements that are frequently used together and plop them into a procedure or method which you can then reuse. It's probably not germane to your question.

So, do you feel better about being confused?