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

Answer 1

These two are among the most important characteristics of Object Oriented paradigm.

Abstraction.

Object orientation models the software as real world objects. However it would be too hard ( and useless ) to model ALL the properties a Customer may have, or all the properties an Employee have.

By listing only the interesting attributes of an object OO may use effectively that object for an specific domain. That's abstraction.

For instance an Employee in a HR system may have very different attributes than a Online BookStore. We abstract the details to make is useful.

Polymorphism.

Objects may behave differently depending on the "type" while keeping the same interface.

What does this means?

For instance an online store system may have two sub-classes of Employee

A) Internal employees.

B) Contractors

And a method to calculate the discount for internal purchases

The discount of an internal employee is calculated as: 10% + 2% for each worked year in the company + 2% for each.. mmhh child

The discount of a contractor is 10%

The following code to calculate the amount to pay:

 public Amount getAmountToPay( Product product, Employee internalCustomer ) { 
      Amount amount = product.getPrice();
      amount.applyDiscount( internalCustomer.getDiscount() );
      return amount;
 }

Would produce different results for the two different kinds of Employee 's

class Employee { 
    public int getDiscount();
}


class InternalEmployee extends Employee { 
     public int getDiscount() { 
        return 10 + 2 * getWorkedYears() + 2 * getNumberOfChilds();
     }
 }

 class Contractor extends Employee { 
      public int getDiscount() { 
          return 10;
     }
 }

This is the polymorphism in action. Instead of having something like

 Amount amount = product.getPrice();

 if( employee.isContractor() ) { 
      amount.applyDiscount( 10 );
 } else if( employee.isSomthingElse() ) {
      amount.applyDiscount( 10 * 2 * getYrs() + 2 * getChilds() );
 } else if ( employee.contidions, condigions, conditions ) {
      amount.applyDiscount( getSomeStrageRuleHere() );
 }

We let the runtime to choose which one to calculate. Is like the program behaves differently depending on the type:

      Amount amount = product.getPrice();
      amount.applyDiscount( internalCustomer.getDiscount() );
      return amount;

By the way, in this example the "Amount" is an abstraction of a real life concept, that could also be represented as a double or an Integer, but maybe we have interestion methods inside that would be better if set in its own class.

I hope this helps.

Answer 2

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 3

Abstraction refers to the act of representing essential features without including the background details or explanations. Classes use the concept of abstraction and are defined as a list of abstract attributes.

One example of a software abstraction is Java's Object.equals(Object o) method. You know that it will compare this object to the one passed in as a parameter, but you don't know, nor do you need to know, exactly how it will be implemented (unless you are the implementer of the class).

Polymorphism means the ability to take more than one form. A method might have different behaviors in different instances. The behavior depends on the data types used in the operation.

One of the classic examples of polymorphism uses an inheritance tree rooted in the Animal class. All Animal's have a makeNoise() method, but the Dog class and the Cat class implement it differently. This allows you to refer to any Dog's and Cat's using an Animal reference type.

Animal a = new Dog();
Animal b = new Cat();

Now you can call makeNoise() on either Animal instance and know that it will make the appropriate noise. This is particularly useful if you have a Collection of Animals, and you don't know at run time exactly what type each of them really is.

Answer 4

very easy.

1. Abstraction is abstraction. Class 'Student' is an abstraction of a real student.

2. Polymorphism is when one class represents another so that user won't notice. This could happen when classes implement the same interface or one class derives from another. Class 'HighSchoolStudent' is derived from class 'Student'. When class 'Teacher' calls #attendance method on the object it might not know whether this object is of 'Student' class or 'HighSchoolStudent' class.

Answer 5

Abstraction and Polymorphism are similar in nature with a different purpose.

For ex.

A driving license: you are given a license mentioning the class of vehicles you are allowed to drive. The license mentions the class of vehicle allowed by the authority but it doesn't define or mention which specific car or brand you should drive. This is Abstraction.

here License is an Abstract class and its method, the allowed vehicles is its Abstract method.

Now, here, Polymorphism is different ways individual License is alloted by the authority to different people, some are issued for light vehicles while some for heavy and some are given for commercial vehicles, according to different requirement. Here, License is a base class, and other kinds of licenses are its child classes, also obeying the is-a relationship. Commercial License is a License.

So, Abstraction is a general guideline giving independence of implementation to the follower classes while Polymorphism is differential approach which override the methods/rules set by parent class.