🏗️ Lesson 5: Object-Oriented Programming Basics
Why Object-Oriented Programming?
🧠 The Core Idea
OOP organizes code into objects—self-contained units that bundle data (properties) and behavior (methods) together. Instead of scattered variables and functions, you create reusable blueprints called classes.
Class = Blueprint
A plan that describes how to build something. The class Car defines what every car has.
Object = Instance
An actual car built from the blueprint. var myCar = Car('Tesla', 2026) creates one.
Properties = Attributes
Data stored in the object. Color, model, year, speed.
Methods = Actions
Things the object can do. Accelerate, brake, honk.
Anatomy of a Class
🧠 Every class has three main parts:
1. Properties (also called fields or instance variables) — the data.
2. Constructor — a special method that creates and initializes objects.
3. Methods — functions that define what objects can do.
📖 Member Details
Click on any property, constructor, or method to see what it does.
Complete Class Example with Line-by-Line Explanation
// Defining a class called Animal
class Animal {
// Properties (instance variables)
String name;
int age;
String species;
// Constructor — creates new Animal objects
Animal(this.name, this.age, this.species);
// Method — an action the animal can do
void makeSound() {
print('\$name makes a sound');
}
// Method with a parameter
void eat(String food) {
print('\$name eats \$food');
}
// Getter — a computed property (no parentheses)
String get description {
return '\$name is a \${age}-year-old \$species';
}
}📝 Line-by-Line
class keyword defines a new typethis refers to the current instance\$name interpolates the property value()Using the Class
// Creating objects (instances) of the Animal class
void main() {
// Create two different Animal objects
var cat = Animal('Whiskers', 3, 'Feline');
var dog = Animal('Buddy', 5, 'Canine');
// Accessing properties
print(cat.name); // Whiskers
print(dog.age); // 5
// Calling methods
cat.makeSound(); // Whiskers makes a sound
dog.eat('kibble'); // Buddy eats kibble
// Using the getter (no parentheses!)
print(cat.description); // Whiskers is a 3-year-old Feline
}✏️ Try It: Create Your Own Animal
Constructors: Different Ways to Create Objects
🧠 Constructors are special methods named after the class
Dart provides several constructor types for different scenarios. The most common is the default constructor, but you can also create named constructors for alternative initialization paths.
1️⃣ Default Constructor
The most common type. Automatically provided if you don't define one. Use this.property for shorthand initialization.
class Point {
double x;
double y;
// Default constructor with shorthand syntax
Point(this.x, this.y);
}
var p = Point(3.0, 4.0); // x=3.0, y=4.02️⃣ Named Constructors
Give your class multiple ways to be created. Use the syntax ClassName.constructorName().
class Point {
double x, y;
Point(this.x, this.y);
// Named constructor: creates origin point
Point.origin()
: x = 0,
y = 0;
// Named constructor: creates point from map
Point.fromMap(Map<String, double> map)
: x = map['x'] ?? 0,
y = map['y'] ?? 0;
}
var origin = Point.origin(); // x=0, y=0
var fromMap = Point.fromMap({'x': 5, 'y': 10}); // x=5, y=103️⃣ Factory Constructors
Use factory when you don't always want to create a new instance. Common for caching, singletons, or returning subtypes.
class Logger {
static Logger? _instance;
// Private constructor (can't be called from outside)
Logger._();
// Factory returns the same instance every time
factory Logger() {
_instance ??= Logger._();
return _instance!;
}
}
var log1 = Logger();
var log2 = Logger();
print(log1 == log2); // true — same instance!4️⃣ Constant Constructors
Use const to create compile-time constants. All properties must be final. These are immutable and share memory.
class ImmutablePoint {
final double x;
final double y;
const ImmutablePoint(this.x, this.y);
}
const p1 = ImmutablePoint(0, 0);
const p2 = ImmutablePoint(0, 0);
print(p1 == p2); // true — identical constants share memoryInheritance: Reusing Code with Hierarchies
🧠 Inheritance lets a class reuse properties and methods from a parent class
Use the extends keyword. The child class automatically gets everything the parent has, and can add or override its own behavior. Use super to refer to the parent class.
❌ Without Inheritance (Duplication)
class Dog {
String name;
void eat() { print('Eating...'); }
void sleep() { print('Sleeping...'); }
void bark() { print('Woof!'); }
}
class Cat {
String name;
void eat() { print('Eating...'); }
void sleep() { print('Sleeping...'); }
void meow() { print('Meow!'); }
}😰 eat() and sleep() duplicated in every class!
✅ With Inheritance (Clean)
class Animal {
String name;
Animal(this.name);
void eat() { print('Eating...'); }
void sleep() { print('Sleeping...'); }
}
class Dog extends Animal {
Dog(super.name);
void bark() { print('Woof!'); }
}
class Cat extends Animal {
Cat(super.name);
void meow() { print('Meow!'); }
}😍 Shared code in parent, unique behavior in children!
🌳 Class Hierarchy
📋 Class Details
Click on any class to see its role in the hierarchy.
@override. This is how a Dog's makeSound() says "Woof!" while a Cat's says "Meow!".
Complete Inheritance Example with Override
class Animal {
String name;
Animal(this.name);
void makeSound() {
print('\$name makes a generic sound');
}
}
class Dog extends Animal {
Dog(super.name); // Forward name to parent constructor
@override
void makeSound() {
print('\$name says: Woof! Woof!'); // Override!
}
}
class Cat extends Animal {
Cat(super.name);
@override
void makeSound() {
print('\$name says: Meow! Meow!');
}
}
void main() {
var dog = Dog('Buddy');
var cat = Cat('Whiskers');
dog.makeSound(); // Buddy says: Woof! Woof!
cat.makeSound(); // Whiskers says: Meow! Meow!
}Polymorphism: One Interface, Many Behaviors
🧠 "Poly" = many, "morph" = form
Polymorphism lets you treat objects of different classes through a shared parent type. You can write code that works with Animal without knowing if it's a Dog, Cat, or Bird—each responds in its own way.
animal.makeSound() on a variable typed as Animal, Dart calls the actual object's version of the method, not the parent's. This is called dynamic dispatch.
// Polymorphism: Treat all animals the same way
void makeAllSpeak(List<Animal> animals) {
for (var animal in animals) {
animal.makeSound(); // Each animal speaks in its own way!
}
}
void main() {
var animals = [
Dog('Buddy'),
Cat('Whiskers'),
Dog('Rex'),
Cat('Luna'),
];
makeAllSpeak(animals);
// Buddy says: Woof! Woof!
// Whiskers says: Meow! Meow!
// Rex says: Woof! Woof!
// Luna says: Meow! Meow!
}🦁 Build Your Zoo
No animals in the zoo yet.
🎵 Make Them Speak!
Abstract Classes: Defining Contracts
🧠 An abstract class defines WHAT must be done, not HOW
Mark a class with abstract to prevent it from being instantiated directly. It can declare methods without implementations—forcing every subclass to provide their own. Think of it as a contract: "If you extend me, you MUST implement these methods."
📜 The Contract (Abstract)
abstract class Shape {
// Abstract getters — no body!
double get area;
double get perimeter;
// Concrete method — has a body
void display() {
print('Area: \$area');
print('Perimeter: \$perimeter');
}
}⚠️ Cannot do: var s = Shape(); — abstract!
🔵 Circle Implementation
class Circle extends Shape {
double radius;
Circle(this.radius);
@override
double get area => 3.14159 * radius * radius;
@override
double get perimeter => 2 * 3.14159 * radius;
}🟦 Rectangle Implementation
class Rectangle extends Shape {
double width, height;
Rectangle(this.width, this.height);
@override
double get area => width * height;
@override
double get perimeter => 2 * (width + height);
}✏️ Try It: Create a Shape and Display It
🎯 OOP Concept Quiz
Score: 0/5 | Hints: 3
Loading question...
Practice Projects
Apply what you've learned by building these hands-on projects.