32. abstract.dart

/// Abstract Classes in Dart
///
/// What are Abstract Classes?
///
/// In Dart, an *abstract class* is a class that cannot be instantiated directly.
/// It serves as a blueprint for other classes (subclasses) to inherit from.
/// Abstract classes are used to define a common interface or set of behaviors that subclasses must implement.
/// They can contain both concrete (implemented) methods and abstract (unimplemented) methods.
///
/// Key Characteristics of Abstract Classes:
///
/// 1.Cannot be Instantiated: You cannot create an object directly from an abstract class using `new`.
/// 2.Blueprint for Subclasses: Abstract classes define a common structure and set of behaviors that subclasses must adhere to.
/// 3.Abstract Methods: Abstract classes can contain *abstract methods*, which are method declarations without an implementation. Subclasses *must* provide an implementation for these methods.
/// 4.Concrete Methods: Abstract classes can also contain *concrete methods*, which are methods with a full implementation. Subclasses can use these methods as-is or override them.
/// 5.Interface-Like: Abstract classes define an interface that subclasses must conform to, similar to how interfaces work in other languages.
/// 6.Partial Implementation: Abstract classes can provide a partial implementation of a class, leaving some methods to be implemented by subclasses.
/// 7.`abstract` Keyword: Abstract classes are defined using the `abstract` keyword before the `class` keyword.
/// 8.Inheritance: Abstract classes are designed to be extended using the `extends` keyword.
///
/// Benefits of Using Abstract Classes:
///
/// 1.Defining Interfaces: Abstract classes are a way to define interfaces in Dart, ensuring that subclasses implement a specific set of methods.
/// 2.Code Reusability: Concrete methods in abstract classes can be reused by subclasses, reducing code duplication.
/// 3.Enforcing Structure: Abstract classes enforce a common structure and set of behaviors across related classes.
/// 4.Abstraction: They allow you to work at a higher level of abstraction, focusing on what objects can do rather than how they do it.
/// 5.Polymorphism: Abstract classes enable polymorphism, allowing you to treat objects of different subclasses as objects of the abstract class type.
/// 6.Flexibility: Abstract classes provide a flexible way to define a common interface while allowing subclasses to implement the details in their own way.
///
/// How Abstract Classes are Defined:
///
/// Abstract classes are defined using the `abstract` keyword before the `class` keyword.
/// Abstract methods are defined without a method body (no `{}`), and they end with a semicolon (`;`).
///
/// Syntax:
///
/// ```dart
/// abstract class AbstractClassName {
///   // Abstract method (no implementation)
///   returnType abstractMethodName(parameters);
///
///   // Concrete method (with implementation)
///   returnType concreteMethodName(parameters) {
///     // Method body
///   }
/// }
/// ```
///
/// Example 1: Basic Abstract Class
///
/// This example demonstrates a simple abstract class `Shape` with an abstract method `getArea()`.

abstract class Shape {
  // Abstract method (no implementation)
  double getArea();

  // Concrete method (with implementation)
  void describe() {
    print('This is a shape.');
  }
}

class Circle extends Shape {
  double radius;

  Circle(this.radius);

  @override
  double getArea() {
    return 3.14159 * radius * radius;
  }
}

class Square extends Shape {
  double side;

  Square(this.side);

  @override
  double getArea() {
    return side * side;
  }
}

/// Example 2: Abstract Class with Multiple Abstract Methods
///
/// This example demonstrates an abstract class with multiple abstract methods.

abstract class Animal {
  String name;

  Animal(this.name);

  void eat(); // Abstract method
  void sleep(); // Abstract method
  void makeSound(); // Abstract method
}

class Dog extends Animal {
  String breed;

  Dog(String name, this.breed) : super(name);

  @override
  void eat() {
    print('$name is eating.');
  }

  @override
  void sleep() {
    print('$name is sleeping.');
  }

  @override
  void makeSound() {
    print('$name says Woof!');
  }
}

class Cat extends Animal {
  String color;

  Cat(String name, this.color) : super(name);

  @override
  void eat() {
    print('$name is eating.');
  }

  @override
  void sleep() {
    print('$name is sleeping.');
  }

  @override
  void makeSound() {
    print('$name says Meow!');
  }
}

/// Example 3: Abstract Class in `Vehicle` Class
///
/// This example demonstrates how to use an abstract class in a class.

abstract class Vehicle {
  String brand;
  String model;

  Vehicle(this.brand, this.model);

  void start(); // Abstract method
  void stop() {
    print('$brand $model is stopping.');
  }
}

class Car extends Vehicle {
  int numberOfDoors;

  Car(String brand, String model, this.numberOfDoors) : super(brand, model);

  @override
  void start() {
    print('Car $brand $model engine is revving.');
  }

  void drive() {
    print('Driving the $brand $model with $numberOfDoors doors.');
  }
}

class Motorcycle extends Vehicle {
  bool hasSidecar;

  Motorcycle(String brand, String model, this.hasSidecar) : super(brand, model);

  @override
  void start() {
    print('Motorcycle $brand $model engine is roaring.');
  }

  void wheelie() {
    print('Doing a wheelie with the $brand $model!');
  }
}

void main() {
  // Example 1: Basic Abstract Class
  print('--- Example 1 ---');
  Circle circle1 = Circle(5.0);
  print('Circle area: ${circle1.getArea()}'); // Output: Circle area: 78.53975
  circle1.describe(); // Output: This is a shape.

  Square square1 = Square(4.0);
  print('Square area: ${square1.getArea()}'); // Output: Square area: 16.0
  square1.describe(); // Output: This is a shape.

  // Example 2: Abstract Class with Multiple Abstract Methods
  print('\n--- Example 2 ---');
  Dog dog1 = Dog('Buddy', 'Golden Retriever');
  dog1.eat(); // Output: Buddy is eating.
  dog1.sleep(); // Output: Buddy is sleeping.
  dog1.makeSound(); // Output: Buddy says Woof!

  Cat cat1 = Cat('Whiskers', 'Gray');
  cat1.eat(); // Output: Whiskers is eating.
  cat1.sleep(); // Output: Whiskers is sleeping.
  cat1.makeSound(); // Output: Whiskers says Meow!

  // Example 3: Abstract Class in `Vehicle` Class
  print('\n--- Example 3 ---');
  Car car1 = Car('Toyota', 'Camry', 4);
  car1.start(); // Output: Car Toyota Camry engine is revving.
  car1.drive(); // Output: Driving the Toyota Camry with 4 doors.
  car1.stop(); // Output: Toyota Camry is stopping.

  Motorcycle motorcycle1 = Motorcycle('Harley-Davidson', 'Sportster', false);
  motorcycle1.start(); // Output: Motorcycle Harley-Davidson Sportster engine is roaring.
  motorcycle1.wheelie(); // Output: Doing a wheelie with the Harley-Davidson Sportster!
  motorcycle1.stop(); // Output: Harley-Davidson Sportster is stopping.

  // Polymorphism Example
  print('\n--- Polymorphism Example ---');
  List<Vehicle> vehicles = [car1, motorcycle1];
  for (var vehicle in vehicles) {
    vehicle.start();
  }
  // Output:
  // Car Toyota Camry engine is revving.
  // Motorcycle Harley-Davidson Sportster engine is roaring.
}