Dart Inheritance and polymorphism

Understanding Inheritance and Polymorphism in Object-Oriented Programming with Dart

Introduction:
Inheritance and polymorphism are essential concepts in object-oriented programming, enabling code reuse, flexibility, and the creation of robust, scalable applications.

Dart is an object-oriented programming language that supports inheritance and polymorphism, which are fundamental concepts in object-oriented programming.
In this essay, we will explore the concepts of Dart inheritance and polymorphism, their significance, and how they are implemented in Dart programming.

Inheritance in Dart allows a class to inherit properties and behavior from another class.

The class that inherits from another class is called a subclass or derived class, and the class from which it inherits is called a superclass or base class.

In Dart How inheritance is declared ?

• In Dart, inheritance is declared using the “extends” keyword.
• When a subclass inherits from a superclass, it automatically acquires all the fields and methods of the superclass. 
• This makes code reusability, as the subclass can build upon the existing functionality of the superclass without duplicating code.

Dart Polymorphism

• Polymorphism, in Dart is the ability of different classes to be treated as instances of the same class through a common interface.
• In Dart, polymorphism is made through method overriding.

Method overriding allows a subclass to provide a specific implementation of a method that is already defined in its superclass. This means that a method in a superclass can be overridden in a subclass to customize its behavior.

Polymorphism allows for more flexible and dynamic code, as objects of different classes can be treated uniformly through their common interface.

By using inheritance, we can create a class hierarchy that enables code reuse and abstraction.

Subclasses can inherit common behavior and then extend or modify it to suit their specific needs. Additionally, polymorphism adds flexibility to the code by allowing objects of different classes to be treated uniformly, leading to more modular and scalable code.

How inheritance and polymorphism occured in Dart ?

To illustrate inheritance and polymorphism in Dart, consider the following example:

class Animal {
void makeSound() {
print('Some generic sound');
}
}

class Dog extends Animal {
@override
void makeSound() {
print('Bark');
}
}

class Cat extends Animal {
@override
void makeSound() {
print('Meow');
}
}

void main() {
Animal dog = Dog();
Animal cat = Cat();

dog.makeSound(); // Output: Bark
cat.makeSound(); // Output: Meow
}

Explanation:

In this example, the Animal class is the superclass, and the Dog and Cat classes are subclasses that inherit from the Animal class. Each subclass provides its own implementation of the makeSound method, showcasing polymorphic behavior.

Dart inheritance and polymorphism are essential concepts in object-oriented programming that enable us to create modular, reusable, and maintainable code.

By using inheritance and polymorphism, developers can build hierarchies of classes that enable us code reuse and flexibility.

Another example of inheritance and polymorphism in Dart

• Suppose we have a base class called Shape, which represents a geometric shape.
• The Shape class has a method called calculateArea to calculate the area of the shape.
• We also have subclasses such as Rectangle and Circle which inherit from the Shape class, each providing their own implementation of the calculateArea method.

class Shape {
double calculateArea() {
return 0;
}
}

class Rectangle extends Shape {
double length;
double width;

Rectangle(this.length, this.width);

@override
double calculateArea() {
return length * width;
}
}

class Circle extends Shape {
double radius;

Circle(this.radius);

@override
double calculateArea() {
return 3.14 * radius * radius;
}
}

void main() {
Shape rectangle = Rectangle(5, 3);
Shape circle = Circle(4);

print('Area of rectangle: ${rectangle.calculateArea()}'); // Output: Area of rectangle: 15
print('Area of circle: ${circle.calculateArea()}'); // Output: Area of circle: 50.24
}

Explanation:

• In this example, the Rectangle and Circle classes inherit from the Shape class and provide their specific implementations of the calculateArea method.
• When we create instances of the Rectangle and Circle classes and call the calculateArea method, Dart’s polymorphism allows us to execute the correct method based on the type of object, despite being referenced through the Shape type.
• The Rectangle class calculates the area of a rectangle using its specific formula,
  The Circle class calculates the area of a circle using its specific formula.

This shows the flexibility and extensibility of polymorphism in Dart, as you can treat objects of different classes uniformly through the common Shape interface.

Inheritance allows the subclasses to inherit the common behavior from the superclass. while polymorphism allows for more flexible and dynamic code, enabling objects of different classes to be treated uniformly through their common interface.

step by step how to use Inheritance and polymorphism in dart?

Here’s a step-by-step guide on how to use inheritance and polymorphism in Dart:

step 1:
Creating a Base Class (Superclass):

To begin, create a base class that will serve as the superclass for the inheritance hierarchy. This class should contain common properties and methods that can be shared by its subclasses.

Example:

// Shape.dart
class Shape {
double calculateArea() {
return 0;
}
}

step 2:
How to create Subclasses (Derived Classes) with Inheritance?

we create one or more subclasses that inherit from the base class.
we Use the extends keyword to indicate that a class inherits from another class.

Example:

// Rectangle.dart
import 'Shape.dart';

class Rectangle extends Shape {
double length;
double width;

Rectangle(this.length, this.width);

@override
double calculateArea() {
return length * width;
}
}
dart

// Circle.dart
import 'Shape.dart';

class Circle extends Shape {
double radius;

Circle(this.radius);

@override
double calculateArea() {
return 3.14 * radius * radius;
}
}

step 3:
Implementing Polymorphism through Method Overriding:

In each subclass, override the methods inherited from the superclass to provide specific implementations. Use the @override annotation to explicitly indicate that a method is being overridden.

step 4:

Utilizing Polymorphism with Superclass References:

Then we create instances of the subclasses and reference them through the superclass type. This approach demonstrates polymorphic behavior, where different objects are treated uniformly through a common interface.

Example:

import 'Rectangle.dart';
import 'Circle.dart';

void main() {
Shape rectangle = Rectangle(5, 3);
Shape circle = Circle(4);

print('Area of rectangle: ${rectangle.calculateArea()}'); // Output: Area of rectangle: 15
print('Area of circle: ${circle.calculateArea()}'); // Output: Area of circle: 50.24
}

An application about Inheritance and polymorphism in Dart

This is an example of a simple Dart application that shows inheritance and polymorphism in action. The application models a basic banking system with a base class representing a generic bank account and two subclasses representing specific types of bank accounts, along with polymorphic behavior.

// BankAccount.dart
class BankAccount {
String accountNumber;
double balance;

BankAccount(this.accountNumber, this.balance);

void deposit(double amount) {
balance += amount;
}

void withdraw(double amount) {
if (balance >= amount) {
balance -= amount;
} else {
print('Insufficient funds');
}
}

void displayAccountInfo() {
print('Account Number: $accountNumber');
print('Balance: \$$balance');
}
}

// SavingsAccount.dart
import 'BankAccount.dart';

class SavingsAccount extends BankAccount {
double interestRate;

SavingsAccount(String accountNumber, double balance, this.interestRate)
: super(accountNumber, balance);

void calculateInterest() {
double interest = balance * interestRate / 100;
deposit(interest);
print('Interest of \$$interest has been added to the account');
}
}

// CurrentAccount.dart
import 'BankAccount.dart';

class CurrentAccount extends BankAccount {
double overdraftLimit;

CurrentAccount(String accountNumber, double balance, this.overdraftLimit)
: super(accountNumber, balance);

@override
void withdraw(double amount) {
if (balance + overdraftLimit >= amount) {
balance -= amount;
} else {
print('Exceeded overdraft limit');
}
}
}

void main() {
// Creating instances of SavingsAccount and CurrentAccount
BankAccount mySavings = SavingsAccount('SA123456', 5000, 5);
BankAccount myCurrent = CurrentAccount('CA789012', 3000, 1000);

// Polymorphic behavior
mySavings.deposit(1000);
mySavings.calculateInterest();
mySavings.displayAccountInfo();

myCurrent.withdraw(4000);
myCurrent.displayAccountInfo();
}

Explanation:

• The BankAccount class serves as the base class, representing a generic bank account with common properties and methods such as accountNumber, balance, deposit, withdraw, and displayAccountInfo.
• The SavingsAccount class is a subclass of BankAccount, representing a savings account with an additional property interestRate and a method calculateInterest to calculate and add interest to the account balance.
• The CurrentAccount class is another subclass of BankAccount, representing a current account with an additional property overdraftLimit. It overrides the withdraw method from the superclass to incorporate the overdraft limit.
• In the main function, instances of the SavingsAccount and CurrentAccount are created and utilized. Polymorphism is demonstrated as the BankAccount type is used to reference objects of both subclass types. This allows for uniform handling of different types of accounts through the common interface provided by the superclass.

This application showcases how inheritance and polymorphism can be used to model and manage different types of bank accounts in Dart.

A quiz about Inheritance and polymorphism

multiple-choice quiz about inheritance and polymorphism, each followed by an explanation, would be quite extensive.

1-What is inheritance in the context of object-oriented programming?

a) The process of creating a new class from an existing class
b) The process of creating objects from classes
c) The process of dividing a class into smaller sub-classes
d) The process of defining methods within a class

Explanation: Inheritance is the process of creating a new class (subclass) from an existing class (superclass), where the subclass inherits the properties and behaviors of the superclass.

2-Which keyword is used in Dart to implement inheritance between classes?

a) use
b) inherit
c) implements
d) extends

Explanation: In Dart, the extends keyword is used to implement inheritance, indicating that a class is inheriting from another class.

3-What is polymorphism in Dart?

a) The ability of a class to have multiple constructors
b) The ability of creating multiple objects of a class
c) The ability to treat objects of different classes through a common interface
d) The process of creating classes with multiple methods

Explanation: Polymorphism in Dart refers to the ability to treat objects of different classes uniformly through a common interface, often achieved through method overriding.

4-Which keyword is used to override a method in Dart?

a) override
b) implements
c) redefine
d) extend

Explanation: In Dart, the @override annotation is used to override a method from the superclass in a subclass, indicating that a method is being overridden.

5-How does inheritance promote code reusability in Dart?

a) By allowing classes to override each other’s methods
b) By allowing subclasses to acquire properties and behaviors from the superclass
c) By allowing multiple classes to share the same set of properties
d) By allowing classes to implement multiple interfaces

Explanation: Inheritance promotes code reusability in Dart by allowing subclasses to acquire properties and behaviors from the superclass, reducing the need for duplicate code.

6-What is inheritance in object-oriented programming?

a) The process of creating a new class from an existing class
b) The process of creating objects from classes
c) The process of dividing a class into smaller sub-classes
d) The process of defining methods within a class

Explanation: a) The correct answer. Inheritance involves creating a new class (subclass) from an existing class (superclass) to inherit properties and behaviors.

7-Which keyword is used in Dart to implement inheritance between classes?

a) use
b) inherit
c) implements
d) extends

Explanation: d) The correct answer. In Dart, the extends keyword is used to implement inheritance, indicating that a class is inheriting from another class.

8-What is polymorphism in Dart?

a) The ability of a class to have multiple constructors
b) The ability of creating multiple objects of a class
c) The ability to treat objects of different classes through a common interface
d) The process of creating classes with multiple methods

Explanation: c) The correct answer. Polymorphism in Dart refers to the ability to treat objects of different classes uniformly through a common interface.

9-Which keyword is used to override a method in Dart?

a) override
b) implements
c) redefine
d) extend

Explanation: a) The correct answer. In Dart, the @override annotation is used to override a method from the superclass in a subclass.

10-How does inheritance promote code reusability in Dart?

a) By allowing classes to override each other’s methods
b) By allowing subclasses to acquire properties and behaviors from the superclass
c) By allowing multiple classes to share the same set of properties
d) By allowing classes to implement multiple interfaces

Explanation: b) The correct answer. Inheritance promotes code reusability in Dart by allowing subclasses to acquire properties and behaviors from the superclass, reducing the need for duplicate code.

11-Can you explain polymorphism too?

Polymorphism is a fundamental concept in object-oriented programming that allows objects of different classes to be treated uniformly through a common interface. There are two main types of polymorphism: compile-time (or static) polymorphism and runtime (or dynamic) polymorphism.

Compile-time Polymorphism: Compile-time polymorphism, also known as static polymorphism, is achieved through method overloading and operator overloading.

Method overloading: Method overloading allows a class to have multiple methods with the same name but different parameters. The compiler decides which method to call based on the number and types of arguments in the method call.

Operator overloading: In some object-oriented languages, such as Dart, operators like +, -, *, etc., can be overloaded to perform specific operations based on the operands’ types.

Runtime Polymorphism: Runtime polymorphism, also known as dynamic polymorphism, is achieved through method overriding and interface implementation. It allows an object to decide which method to execute at runtime.

Method overriding: Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. When a method is called on an object of the superclass, the overridden method in the subclass is executed.

Interface implementation: Interfaces in Dart allow for defining a set of methods that a class must implement. This feature enables objects of different classes that implement the same interface to be treated uniformly through the interface type.