# Object Oriented Programming in DART ### **OOP In Dart** visit [https://dart-tutorial.com/object-oriented-programming/](https://dart-tutorial.com/object-oriented-programming/) Object-oriented programming (OOP) is a programming method that uses objects and their interactions to design and program applications. It is one of the most popular programming paradigms and is used in many programming languages, such as Dart, Java, C++, Python, etc. In OOP, an object can be anything, such as a person, a bank account, a car, or a house. Each object has its attributes (or properties) and behavior (or methods). For example, a person object may have the attributes name, age and height, and the behavior walk and talk. ### **Advantages** * It is easy to understand and use. * It increases reusability and decreases complexity. * The productivity of programmers increases. * It makes the code easier to maintain, modify and debug. * It promotes teamwork and collaboration. * It reduces the repetition of code. ### **Features Of OOP** 1. Class 2. Object 3. Encapsulation 4. Inheritance 5. Polymorphism 6. Abstraction ### **Key Points** * Object Oriented Programming (OOP) is a programming paradigm that uses objects and their interactions to design and program applications. * OOP is based on objects, which are data structures containing data and methods. * OOP is a way of thinking about programming that differs from traditional procedural programming. * OOP can make code more modular, flexible, and extensible. * OOP can help you to understand better and solve problems. # **Classes** In object-oriented programming, a class is a blueprint for creating objects. A class defines the properties and methods that an object will have. For example, a class called Dog might have properties like breed, color and methods like bark, run. ### **Declaring A class in Dart** In Dart programming, you can declare a class using the class keyword followed by the class name. Here's a simple example: ```cpp // Declaring a class in Dart class Person { // Properties of the class String name; int age; // Constructor Person(this.name, this.age); // Method to display person details void displayInfo() { print('Name: $name, Age: $age'); } } ``` **Class Declaration:** * The class keyword is used to declare a class, followed by the class name Person. # **Objects** An **object** is an instance of a class. It represents a real-world entity with attributes (properties) and behaviors (methods). Objects allow you to create multiple instances of a class, each with its own unique data. ```cpp // Declaring a simple class in Dart class Car { String brand; String model; Car(this.brand, this.model); void showDetails() { print('Brand: $brand, Model: $model'); } } void main() { // Creating an object of the Car class Car myCar = Car('Toyota', 'Corolla'); // Calling the method using the object myCar.showDetails(); // Output: Brand: Toyota, Model: Corolla } ``` **Class Declaration:** * The Car class has two properties: brand and model. * The constructor Car(this.brand, this.model); initializes these properties. **Object Creation:** * Car myCar = Car('Toyota', 'Corolla'); creates an object myCar of the Car class with specific values for brand and model. # **Object Oriented Programming in DART** Object-oriented programming (OOP) is **a computer programming model that organizes software design around data, or objects, rather than functions and logic**. An object can be defined as a data field that has unique attributes and behavior. ## Components of OOP, ## Constructor * A constructor in programming is a special method or function that is automatically called when an object is created. * Initializes the object's properties or performs any desired configuration. * Constructors are essential for creating class instances in object-oriented programming. * In Dart, constructors are defined with the same name as the class. * There are two main types of constructors in dart: **Default constructor:** A default constructor is automatically created if no other constructor is specified. No parameter required. Initializes instance variables to their default values ​​(null for objects, 0 for integers, etc.). ```cpp class MyDetails { String name = 'Unknown'; int age = 0; } void main() { MyDetails myDetails = MyDetails(); print("Name: ${myDetails.name}, Age: ${myDetails.age}"); } ``` In this example: * The MyDetails class has a default constructor, which doesn't take any parameters. * Inside the constructor, you can add any initialization code if needed. * In the main() function, an instance of MyDetails named myDetails is created using the default constructor. **Parameterized Constructors:** Parameterized constructors allow you to pass a value during object creation, allowing you to initialize instance variables with specific values. ```cpp class MyDetails { String name; int age; // Parameterized constructor MyDetails(this.name, this.age); } void main() { // Creating an instance of MyDetails using the parameterized constructor MyDetails myDetails = MyDetails('Allan', 25); print("Name: ${myDetails.name}, Age: ${myDetails.age}"); } ``` ## **Object Oriented Programming Paradigm** ### Data Encapsulation Data encapsulation is the process of keeping a class' implementation details hidden from the user through an object's functions. ### How To Achieve Encapsulation In Dart Encapsulation can be achieved by: * Declaring the class properties as private by using underscore(\_). * Providing public getter and setter methods to access and update the value of private property. ### Getter and Setter Methods Getter and setter methods are used to access and update the value of private property. Getter methods are used to access the value of private property. Setter methods are used to update the value of private property. **Code sample** ```cpp class Circle { // Private variable _radius, which stores the radius of the circle double _radius; // Constructor to initialize the circle with a radius Circle(this._radius); // Getter method to return the value of the private variable _radius double get radius => _radius; // Setter method to update the radius with validation set radius(double value) { // Check if the new radius is positive if (value > 0) { // If valid, update the radius _radius = value; } else { // If invalid (radius is negative or zero), show an error message print('Radius must be positive'); } } // Method to calculate the area of the circle using the formula: πr² double calculateArea() { return 3.14 * _radius * _radius; } } void main() { // Create a new Circle object with a radius of 5.0 Circle circle = Circle(5.0); // Print the initial radius of the circle print("Radius: ${circle.radius}"); // Calculate and print the area of the circle print("Area: ${circle.calculateArea()}"); // Update the radius to 7.0 using the setter method circle.radius = 7.0; // Print the updated radius print("New Radius: ${circle.radius}"); // Calculate and print the new area with the updated radius print("New Area: ${circle.calculateArea()}"); // Try to set an invalid radius (-3.0), which will trigger the validation circle.radius = -3.0; // This will show the error message } ``` ### Explanation 1. **Private Variable (**`_radius`): * The `Circle` class has a private variable `_radius`. The underscore (`_`) before the name makes it private, meaning it cannot be accessed directly from outside the class. This ensures the data is protected and can only be accessed or modified through methods within the class. 2. **Constructor**: * The constructor (`Circle(this._radius)`) is used to initialize the `_radius` variable when an instance of the `Circle` class is created. It sets the value of `_radius` when you create a new `Circle` object. 3. **Getter (get radius)**: * The getter method `radius` allows external code to access the value of the private variable `_radius`. This means you can "get" the value of `_radius`, but only through this method, ensuring the value remains encapsulated. 4. **Setter (set radius)**: * The setter method `radius` provides a controlled way to update the value of `_radius`. It includes validation, ensuring the radius can only be set to a positive value. If an invalid value (e.g., a negative number) is provided, it shows an error message and does not update the value. This helps maintain the integrity of the data. 5. **Method (calculateArea)**: * The `calculateArea` method calculates the area of the circle using the formula πr2\\pi r^2πr2. It demonstrates how methods in a class can use the encapsulated data (i.e., `_radius`) to perform operations. This method can access `_radius` directly since it's part of the class, but external code cannot. ### **Inheritance** Generally speaking, inheritance is the process of gaining properties. OOP allows for the inheritance of properties from one object to another. ***Code sample*** ```cpp // Base class (Superclass) class Vehicle { String brand; int year; // Constructor for Vehicle Vehicle(this.brand, this.year); // Method to display vehicle info void displayInfo() { print("Brand: $brand"); print("Year: $year"); } } // Derived class (Subclass) inheriting from Vehicle class Car extends Vehicle { String model; // Constructor for Car which uses super to call the base class constructor Car(String brand, int year, this.model) : super(brand, year); // Method to display car-specific info void displayCarInfo() { displayInfo(); // Call the base class method print("Model: $model"); } } void main() { // Creating an instance of the Car class Car car = Car('Toyota', 2021, 'Corolla'); // Accessing methods from both base and derived classes car.displayCarInfo(); } ``` ***Explanation*** * The Vehicle class is the base class with instance variables brand and year, and a method displayInfo. * The Car class is the derived class that extends (inherits from) the Vehicle class. It adds an additional property model and a method displayCarInfo. * The Car constructor uses super to call the constructor of the base class (Vehicle). * The main function demonstrates creating an instance of the Car class and accessing methods from both the base and derived classes. ### Polymorphism Polymorphism is the practice of having many classes use the same method name while redefining it for the derived classes. ![](data:image/png;base64,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 align="left") ***Code sample*** ```cpp // Base class class Animal { // Method to be overridden by derived classes void makeSound() { print("Animal makes a sound"); } } // Derived class Dog that overrides makeSound method class Dog extends Animal { @override void makeSound() { print("Dog barks"); } } // Derived class Cat that overrides makeSound method class Cat extends Animal { @override void makeSound() { print("Cat meows"); } } void main() { // Creating instances of Animal, Dog, and Cat Animal animal = Animal(); Dog dog = Dog(); Cat cat = Cat(); // Calling makeSound method for each instance animal.makeSound(); // Calls Animal's version dog.makeSound(); // Calls Dog's version cat.makeSound(); // Calls Cat's version } ``` **Explanation** * The Animal class is the base class with a method makeSound. * The Dog and Cat classes are derived classes that override the makeSound method with their own implementations. * In the main function, instances of Animal, Dog, and Cat are created. * The makeSound method is called on each object, demonstrating polymorphism as the appropriate version of the method is invoked based on the actual type of the object. ### **Abstraction** Abstraction refers to the user’s interaction with just a subset of an object’s characteristics and operations. To access a complicated item, abstraction uses simpler, high-level techniques. * Simple items are used to show complexity. * Keep complicated information hidden from the user. Simple classes are used to indicate complexity in abstraction. Encapsulation is an extension of abstraction. *Advantages of Abstraction* * It simplifies the process of seeing things in their entirety. * Code duplication is avoided, and reusability is increased. * Because just the most necessary information is shown to the user, it helps to enhance the security of an application or software. **Code example** ```cpp // Abstract class Shape abstract class Shape { // Abstract method (no implementation) double calculateArea(); // Concrete method (with implementation) void printInfo() { print("This is a shape."); } } // Concrete class Circle extends Shape class Circle extends Shape { double radius; // Constructor for Circle Circle(this.radius); // Override the abstract method to provide specific implementation @override double calculateArea() { return 3.14 * radius * radius; } } // Concrete class Rectangle extends Shape class Rectangle extends Shape { double width; double height; // Constructor for Rectangle Rectangle(this.width, this.height); // Override the abstract method to provide specific implementation @override double calculateArea() { return width * height; } } void main() { // Create instances of Circle and Rectangle Circle circle = Circle(5.0); Rectangle rectangle = Rectangle(10.0, 20.0); // Using the common interface provided by the Shape abstract class circle.printInfo(); // Calls the concrete method in the abstract class print("Circle Area: ${circle.calculateArea()}"); rectangle.printInfo(); // Calls the concrete method in the abstract class print("Rectangle Area: ${rectangle.calculateArea()}"); } ``` **Explanation** * The Shape class is an abstract class with an abstract method calculateArea() and a concrete method printInfo(). * The Circle and Rectangle classes are concrete classes that extend the Shape class and provide implementations for the abstract method. * In the main function, instances of Circle and Rectangle are created and used through the common interface provided by the Shape abstract class.