• Classes
• Objects
• Inheritance
• Polymorphism
• Data Abstraction and Encapsulation

Other OOPs Features:

• Dynamic Binding
• Message Passing

Here are the five main features of OOPs

Classes:

public class Laptop
{
String modelName;
String manufacturerName;
String ram;
String memory;
String os;


void boot(){


}
}

Objects:

Laptop obj = new Laptop();
Laptop obj1 = new Laptop();
Laptop obj2 = new Laptop();

obj.modelName = " Pavilion 15";
obj.manufacturerName = "HP";
obj.ram = "4 GB";
obj.memory = "1 TB";
obj.os = "Windows";

Inheritance:

• It enables a class to acquire or get the properties from another class
• It makes code reusable
• It makes easier to add new features or methods to a class
• It provides an overriding feature which allows a child class to have a specific implementation of a method defined in the parent class

• Code Reusability
• Ease to add new feature
• Overriding

class Laptop extends Electronics
{


}

Polymorphism:

Data Abstraction and Encapsulation:

Other OOPs Features:

Dynamic Binding:

Message Passing:

Frequently Asked Questions

However, it can be classified into Static and Dynamic polymorphism ( Runtime Polymorphism ) . The main difference between them is, one is resolved at compile-time and other resolved at run time.

Difference Between Static And Dynamic Polymorphism ( Runtime Polymorphism )?

Basis	Static Polymorphism	Runtime Polymorphism
Definition	It can be defined as a process in which a function call with an object resolve at compile time by the compiler	It can be defined as a process in which a function call with an object resolve at runtime
Call Resolution	Call is settled by the compiler	Call isn't settled by the compiler
Other Name	Compile-time Polymorphism and Early binding	Dynamic binding and Late binding
Achieved By	Function overloading and Operator overloading	Pointers and virtual functions
Execution	It is analyzed early at compile time so it provides fast execution	It is slow because it is analyzed at the runtime
Flexibility	It is managed and executed at compile time which makes it less flexible	It is more flexible because of its execution at runtime

Static Polymorphism

Static polymorphism is additionally termed as compile-time polymorphism, which implies that one can write numerous methods in a program with the same name, performing distinctive tasks.

However, it gives the client or the software engineer efficient and better comprehensibility of code.

Runtime Polymorphism ( Dynamic Polymorphism )

This is otherwise called Dynamic Polymorphism. It is a procedure in which a call to an overridden method is settled at runtime, which is the reason it is termed as runtime polymorphism.

Key differences

• In Static Polymorphism, the call is settled by the compiler, whereas; In Run time Polymorphism, the call isn’t settled by the compiler.
• It is otherwise called as Compile-time Polymorphism and Early binding, whereas; it is otherwise called Dynamic binding, Late binding and overriding also.
• Overloading is compile-time polymorphism where more than one functions share a similar name with various parameters or signature and distinctive return type, whereas; Overriding is run time polymorphism having the same function with the same parameters or mark, however, related in a class and its subclass.
• Static polymorphism is accomplished by function overloading and operator overloading, whereas; Runtime polymorphism is accomplished by pointers and virtual functions.
• As in static polymorphism, it is analyzed early at compile time so it provides fast execution, whereas; Runtime polymorphism is slow because it is analyzed at the runtime.
• In Static polymorphism, all the stuff is managed and executed at compile time which makes it less flexible, whereas; Runtime polymorphism is more flexible because of its execution at runtime.

Note: If you think, anything is wrong with the article, please inform us at inform@programmerbay.com