What is OOP in Dart?

Object-Oriented Programming (OOP) is a programming paradigm that uses "objects" to model real-world entities and their behaviors. These objects are instances of classes, and OOP in Dart allows you to organize and structure your code in a more manageable, modular, and reusable way.

In Dart, OOP revolves around classes and objects, and it follows the four main principles of object-oriented design: Encapsulation, Inheritance, Polymorphism, and Abstraction.

Let’s break down how each of these concepts applies to Dart.

Key Concepts of OOP in Dart

1. Classes and Objects
   • Classes are blueprints for creating objects. They define properties (fields) and behaviors (methods) that the objects created from them will have.
   • Objects are instances of classes. They represent concrete entities with specific data and actions.

   Example:

   class Car {
     String brand;
     String model;
   
     // Constructor
     Car(this.brand, this.model);
   
     void displayInfo() {
       print('Brand: $brand, Model: $model');
     }
   }
   
   void main() {
     var myCar = Car('Toyota', 'Corolla');
     myCar.displayInfo();  // Output: Brand: Toyota, Model: Corolla
   }
   

   In the above example, Car is a class, and myCar is an object (instance) of that class.

2. Encapsulation
   • Encapsulation is the concept of restricting direct access to an object's data and allowing it to be accessed or modified only through specified methods (getters and setters). This helps protect an object’s internal state.

   Example:

   class BankAccount {
     double _balance = 0.0;  // Private field
   
     // Getter
     double get balance => _balance;
   
     // Setter
     set balance(double amount) {
       if (amount >= 0) {
         _balance = amount;
       } else {
         print('Invalid amount');
       }
     }
   }
   
   void main() {
     var account = BankAccount();
     account.balance = 1000.0;  // Using setter to set the balance
     print(account.balance);    // Using getter to access the balance
   }
   

   • The _balance field is private, and can only be accessed or modified using the getter and setter.

3. Inheritance

   • Inheritance allows one class (subclass) to inherit properties and methods from another class (superclass). This helps in reusing code and extending functionality.

   Example:

   class Animal {
     void sound() {
       print('Some sound');
     }
   }
   
   class Dog extends Animal {
     @override
     void sound() {
       print('Bark');
     }
   }
   
   void main() {
     var dog = Dog();
     dog.sound();  // Output: Bark
   }
   

   • Here, Dog is inheriting from the Animal class and overriding its sound method. This allows Dog to reuse the sound method structure but change its behavior.

4. Polymorphism
   • Polymorphism means "many forms." It allows a single method or function to behave differently depending on the object it is operating on.
   • In Dart, this is typically achieved through method overloading and overriding.

   Example:

   class Animal {
     void speak() {
       print("Animal speaks");
     }
   }
   
   class Cat extends Animal {
     @override
     void speak() {
       print("Meow");
     }
   }
   
   class Dog extends Animal {
     @override
     void speak() {
       print("Bark");
     }
   }
   
   void main() {
     Animal cat = Cat();
     Animal dog = Dog();
   
     cat.speak();  // Output: Meow
     dog.speak();  // Output: Bark
   }
   

   • Even though both cat and dog are of type Animal, the specific behavior of speak() depends on whether the object is a Cat or a Dog.

5. Abstraction
   • Abstraction is the concept of hiding complex implementation details and exposing only the necessary features of an object. This is typically done using abstract classes and interfaces.

   Example:

   abstract class Shape {
     double area();  // Abstract method
   }
   
   class Circle extends Shape {
     final double radius;
     
     Circle(this.radius);
   
     @override
     double area() {
       return 3.14 * radius * radius;
     }
   }
   
   void main() {
     var circle = Circle(5);
     print(circle.area());  // Output: 78.5
   }
   

   • The Shape class is abstract and does not provide an implementation for area(). The Circle class implements this method, providing the behavior specific to a circle.

Why Use OOP in Dart?

1. Code Reusability: Inheritance allows you to reuse code, reducing redundancy.
2. Modularity: Classes help you logically separate concerns, making the code easier to understand and maintain.
3. Maintainability: The ability to extend classes and override methods allows for easier updates and changes without affecting other parts of the program.
4. Abstraction: By hiding the details and showing only relevant features, you can work with complex systems more easily.

Summary

OOP in Dart allows you to write flexible and reusable code using the core principles of Encapsulation, Inheritance, Polymorphism, and Abstraction. It helps in building more structured, maintainable, and scalable applications. Understanding these principles is essential for becoming proficient in Dart, especially for working with frameworks like Flutter, where OOP concepts are widely used.