Forem: Putra Prima A

Golang For PHP Developer : Testing & Deployment

Putra Prima A — Sat, 11 Oct 2025 23:02:09 +0000

Day 7: Testing & Deployment

Goal: Write tests and deploy your API to production

Time: ~4-5 hours

What you'll build: Tested, production-ready API with deployment

1. Testing Basics in Go (1 hour)

Go's Built-in Testing

Go has testing built into the language - no PHPUnit needed!

Test file naming: *_test.go

Your First Test

Create utils/password_test.go:

package utils

import "testing"

func TestHashPassword(t *testing.T) {
    password := "mySecretPassword123"

    hash, err := HashPassword(password)
    if err != nil {
        t.Fatalf("HashPassword failed: %v", err)
    }

    if hash == "" {
        t.Error("Hash should not be empty")
    }

    if hash == password {
        t.Error("Hash should not equal plain password")
    }
}

func TestCheckPassword(t *testing.T) {
    password := "mySecretPassword123"
    hash, _ := HashPassword(password)

    // Test correct password
    if !CheckPassword(password, hash) {
        t.Error("CheckPassword should return true for correct password")
    }

    // Test wrong password
    if CheckPassword("wrongPassword", hash) {
        t.Error("CheckPassword should return false for wrong password")
    }
}

func TestHashPasswordTooShort(t *testing.T) {
    password := "short"

    _, err := HashPassword(password)
    if err == nil {
        t.Error("Expected error for short password")
    }
}

Running Tests

# Run all tests
go test ./...

# Run tests in specific package
go test ./utils

# Verbose output
go test -v ./utils

# Run specific test
go test -v -run TestHashPassword ./utils

# With coverage
go test -cover ./...

# Coverage report
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out

Table-Driven Tests (Best Practice)

func TestValidateEmail(t *testing.T) {
    tests := []struct {
        name  string
        email string
        want  bool
    }{
        {"valid email", "john@example.com", true},
        {"valid with subdomain", "john@mail.example.com", true},
        {"missing @", "johnexample.com", false},
        {"missing domain", "john@", false},
        {"empty string", "", false},
        {"spaces", "john @example.com", false},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := ValidateEmail(tt.email)
            if got != tt.want {
                t.Errorf("ValidateEmail(%q) = %v, want %v", 
                    tt.email, got, tt.want)
            }
        })
    }
}

Test Assertions Helper

Create testutils/assertions.go:

package testutils

import "testing"

func AssertEqual(t *testing.T, got, want interface{}) {
    t.Helper()
    if got != want {
        t.Errorf("got %v, want %v", got, want)
    }
}

func AssertNotEqual(t *testing.T, got, want interface{}) {
    t.Helper()
    if got == want {
        t.Errorf("got %v, should not equal %v", got, want)
    }
}

func AssertNil(t *testing.T, got interface{}) {
    t.Helper()
    if got != nil {
        t.Errorf("expected nil, got %v", got)
    }
}

func AssertNotNil(t *testing.T, got interface{}) {
    t.Helper()
    if got == nil {
        t.Error("expected not nil, got nil")
    }
}

2. Testing HTTP Handlers (1 hour)

HTTP Test Basics

package handlers

import (
    "bytes"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestHealthCheck(t *testing.T) {
    // Create request
    req := httptest.NewRequest(http.MethodGet, "/health", nil)

    // Create response recorder
    w := httptest.NewRecorder()

    // Call handler
    healthCheckHandler(w, req)

    // Check status code
    if w.Code != http.StatusOK {
        t.Errorf("Expected status 200, got %d", w.Code)
    }

    // Check response body
    var response map[string]string
    json.NewDecoder(w.Body).Decode(&response)

    if response["status"] != "healthy" {
        t.Errorf("Expected healthy status, got %s", response["status"])
    }
}

Testing JSON APIs

func TestRegisterUser(t *testing.T) {
    // Setup test database
    db := setupTestDB(t)
    defer teardownTestDB(db)

    handler := NewAuthHandler(repository.NewUserRepository(db))

    // Prepare request body
    reqBody := map[string]string{
        "name":     "John Doe",
        "email":    "john@example.com",
        "password": "password123",
    }
    bodyBytes, _ := json.Marshal(reqBody)

    // Create request
    req := httptest.NewRequest(
        http.MethodPost,
        "/api/v1/register",
        bytes.NewBuffer(bodyBytes),
    )
    req.Header.Set("Content-Type", "application/json")

    // Create response recorder
    w := httptest.NewRecorder()

    // Call handler
    handler.Register(w, req)

    // Check status
    if w.Code != http.StatusCreated {
        t.Fatalf("Expected status 201, got %d", w.Code)
    }

    // Parse response
    var response struct {
        Token string      `json:"token"`
        User  models.User `json:"user"`
    }
    json.NewDecoder(w.Body).Decode(&response)

    // Assertions
    if response.Token == "" {
        t.Error("Expected token in response")
    }
    if response.User.Email != "john@example.com" {
        t.Errorf("Expected email john@example.com, got %s", response.User.Email)
    }
}

Test Database Setup

package handlers

import (
    "testing"

    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
    "your-project/models"
)

func setupTestDB(t *testing.T) *gorm.DB {
    // Use in-memory SQLite for tests
    db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
    if err != nil {
        t.Fatal("Failed to connect to test database:", err)
    }

    // Auto migrate
    err = db.AutoMigrate(&models.User{}, &models.Post{})
    if err != nil {
        t.Fatal("Failed to migrate test database:", err)
    }

    return db
}

func teardownTestDB(db *gorm.DB) {
    sqlDB, _ := db.DB()
    sqlDB.Close()
}

// Helper to create test user
func createTestUser(t *testing.T, db *gorm.DB) *models.User {
    user := &models.User{
        Name:     "Test User",
        Email:    "test@example.com",
        Password: "hashed_password",
    }

    if err := db.Create(user).Error; err != nil {
        t.Fatal("Failed to create test user:", err)
    }

    return user
}

Testing Protected Endpoints

func TestGetProfile_Authenticated(t *testing.T) {
    db := setupTestDB(t)
    defer teardownTestDB(db)

    // Create test user
    user := createTestUser(t, db)

    // Generate token
    token, _ := utils.GenerateToken(user.ID, user.Email)

    handler := NewAuthHandler(repository.NewUserRepository(db))

    // Create request with auth header
    req := httptest.NewRequest(http.MethodGet, "/api/v1/profile", nil)
    req.Header.Set("Authorization", "Bearer "+token)

    // Add user to context (normally done by middleware)
    claims := &utils.Claims{UserID: user.ID, Email: user.Email}
    ctx := context.WithValue(req.Context(), middleware.UserContextKey, claims)
    req = req.WithContext(ctx)

    w := httptest.NewRecorder()
    handler.GetProfile(w, req)

    if w.Code != http.StatusOK {
        t.Errorf("Expected status 200, got %d", w.Code)
    }
}

func TestGetProfile_Unauthenticated(t *testing.T) {
    db := setupTestDB(t)
    defer teardownTestDB(db)

    handler := NewAuthHandler(repository.NewUserRepository(db))

    // Request without auth
    req := httptest.NewRequest(http.MethodGet, "/api/v1/profile", nil)
    w := httptest.NewRecorder()

    handler.GetProfile(w, req)

    if w.Code != http.StatusUnauthorized {
        t.Errorf("Expected status 401, got %d", w.Code)
    }
}

Testing Middleware

func TestAuthMiddleware(t *testing.T) {
    // Create a test handler
    nextHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
    })

    // Wrap with auth middleware
    handler := middleware.AuthMiddleware(nextHandler)

    t.Run("Valid Token", func(t *testing.T) {
        token, _ := utils.GenerateToken(1, "test@example.com")

        req := httptest.NewRequest(http.MethodGet, "/test", nil)
        req.Header.Set("Authorization", "Bearer "+token)

        w := httptest.NewRecorder()
        handler.ServeHTTP(w, req)

        if w.Code != http.StatusOK {
            t.Errorf("Expected status 200, got %d", w.Code)
        }
    })

    t.Run("Missing Token", func(t *testing.T) {
        req := httptest.NewRequest(http.MethodGet, "/test", nil)
        w := httptest.NewRecorder()

        handler.ServeHTTP(w, req)

        if w.Code != http.StatusUnauthorized {
            t.Errorf("Expected status 401, got %d", w.Code)
        }
    })

    t.Run("Invalid Token", func(t *testing.T) {
        req := httptest.NewRequest(http.MethodGet, "/test", nil)
        req.Header.Set("Authorization", "Bearer invalid-token")

        w := httptest.NewRecorder()
        handler.ServeHTTP(w, req)

        if w.Code != http.StatusUnauthorized {
            t.Errorf("Expected status 401, got %d", w.Code)
        }
    })
}

Benchmark Tests

func BenchmarkHashPassword(b *testing.B) {
    password := "mySecretPassword123"

    for i := 0; i < b.N; i++ {
        HashPassword(password)
    }
}

func BenchmarkCheckPassword(b *testing.B) {
    password := "mySecretPassword123"
    hash, _ := HashPassword(password)

    for i := 0; i < b.N; i++ {
        CheckPassword(password, hash)
    }
}

// Run benchmarks
// go test -bench=. -benchmem ./utils

3. Building for Production (1 hour)

Building Your Application

# Build for current platform
go build -o blog-api

# Build for Linux
GOOS=linux GOARCH=amd64 go build -o blog-api-linux

# Build for Windows
GOOS=windows GOARCH=amd64 go build -o blog-api.exe

# Build with optimization (smaller binary)
go build -ldflags="-s -w" -o blog-api

# Run the binary
./blog-api

Dockerfile

Create Dockerfile:

# Build stage
FROM golang:1.21-alpine AS builder

WORKDIR /app

# Copy go mod files
COPY go.mod go.sum ./
RUN go mod download

# Copy source code
COPY . .

# Build application
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o blog-api .

# Run stage
FROM alpine:latest

RUN apk --no-cache add ca-certificates

WORKDIR /root/

# Copy binary from builder
COPY --from=builder /app/blog-api .

# Expose port
EXPOSE 8080

# Run
CMD ["./blog-api"]

Docker Compose

Create docker-compose.yml:

version: '3.8'

services:
  api:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgres://postgres:postgres@db:5432/blog_db?sslmode=disable
      - JWT_SECRET=your-super-secret-key
      - PORT=8080
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:15-alpine
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=blog_db
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  postgres_data:

Run with Docker

# Build and run
docker-compose up -d

# View logs
docker-compose logs -f api

# Stop
docker-compose down

# Rebuild
docker-compose up -d --build

.dockerignore

Create .dockerignore:

.env
.git
.gitignore
*.md
*.test
coverage.out
blog-api
blog-api-linux
blog-api.exe

4. Environment Configuration (30 min)

Production-Ready Config

Update config/config.go:

package config

import (
    "fmt"
    "os"
    "strconv"
)

type Config struct {
    // Server
    Port        string
    Environment string // development, staging, production

    // Database
    DatabaseURL string

    // JWT
    JWTSecret     string
    JWTExpiration int // hours

    // CORS
    AllowedOrigins []string

    // Rate Limiting
    RateLimitEnabled bool
    RateLimit        int
}

func Load() *Config {
    return &Config{
        Port:             getEnv("PORT", "8080"),
        Environment:      getEnv("ENVIRONMENT", "development"),
        DatabaseURL:      getEnv("DATABASE_URL", ""),
        JWTSecret:        getEnv("JWT_SECRET", ""),
        JWTExpiration:    getEnvAsInt("JWT_EXPIRATION", 24),
        AllowedOrigins:   getEnvAsSlice("ALLOWED_ORIGINS", []string{"*"}),
        RateLimitEnabled: getEnvAsBool("RATE_LIMIT_ENABLED", true),
        RateLimit:        getEnvAsInt("RATE_LIMIT", 100),
    }
}

func (c *Config) Validate() error {
    if c.DatabaseURL == "" {
        return fmt.Errorf("DATABASE_URL is required")
    }
    if c.JWTSecret == "" {
        return fmt.Errorf("JWT_SECRET is required")
    }
    if c.Environment == "production" && c.JWTSecret == "default-secret" {
        return fmt.Errorf("JWT_SECRET must be changed in production")
    }
    return nil
}

func (c *Config) IsProduction() bool {
    return c.Environment == "production"
}

func getEnv(key, defaultValue string) string {
    if value := os.Getenv(key); value != "" {
        return value
    }
    return defaultValue
}

func getEnvAsInt(key string, defaultValue int) int {
    if value := os.Getenv(key); value != "" {
        if intVal, err := strconv.Atoi(value); err == nil {
            return intVal
        }
    }
    return defaultValue
}

func getEnvAsBool(key string, defaultValue bool) bool {
    if value := os.Getenv(key); value != "" {
        if boolVal, err := strconv.ParseBool(value); err == nil {
            return boolVal
        }
    }
    return defaultValue
}

func getEnvAsSlice(key string, defaultValue []string) []string {
    if value := os.Getenv(key); value != "" {
        return strings.Split(value, ",")
    }
    return defaultValue
}

Multiple Environment Files

Create .env.development:

ENVIRONMENT=development
PORT=8080
DATABASE_URL=postgres://postgres:postgres@localhost:5432/blog_db_dev?sslmode=disable
JWT_SECRET=dev-secret-key
ALLOWED_ORIGINS=http://localhost:3000,http://localhost:5173

Create .env.production:

ENVIRONMENT=production
PORT=8080
DATABASE_URL=postgres://user:password@prod-db:5432/blog_db?sslmode=require
JWT_SECRET=super-secret-production-key-change-this
ALLOWED_ORIGINS=https://yourapp.com,https://www.yourapp.com
RATE_LIMIT_ENABLED=true
RATE_LIMIT=100

5. Deployment Options (1 hour)

Option 1: Deploy to Railway (Easiest)

Create account at https://railway.app
Install Railway CLI:

   npm install -g @railway/cli
   # or
   brew install railway

Login and deploy:

   railway login
   railway init
   railway up

Add PostgreSQL:

   railway add
   # Select PostgreSQL

Set environment variables in Railway dashboard
Railway automatically:
- Detects Go project
- Builds your app
- Provides HTTPS URL
- Auto-deploys on git push

Option 2: Deploy to Fly.io

Install flyctl:

   # Mac
   brew install flyctl

   # Linux
   curl -L https://fly.io/install.sh | sh

Login:

   fly auth login

Initialize:

   fly launch

Create fly.toml:

   app = "your-blog-api"
   primary_region = "sin"

   [build]

   [http_service]
     internal_port = 8080
     force_https = true
     auto_stop_machines = true
     auto_start_machines = true
     min_machines_running = 0

   [[vm]]
     cpu_kind = "shared"
     cpus = 1
     memory_mb = 256

Add PostgreSQL:

   fly postgres create
   fly postgres attach --app your-blog-api

Set secrets:

   fly secrets set JWT_SECRET=your-secret-key

Deploy:

   fly deploy

Option 3: Deploy to VPS (DigitalOcean/Linode)

Create droplet/VPS
Install Go on server:

   ssh root@your-server-ip

   wget https://go.dev/dl/go1.21.0.linux-amd64.tar.gz
   tar -C /usr/local -xzf go1.21.0.linux-amd64.tar.gz
   echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
   source ~/.bashrc

Install PostgreSQL:

   sudo apt update
   sudo apt install postgresql postgresql-contrib
   sudo -u postgres psql
   CREATE DATABASE blog_db;
   CREATE USER blog_user WITH PASSWORD 'secure_password';
   GRANT ALL PRIVILEGES ON DATABASE blog_db TO blog_user;
   \q

Clone and build:

   git clone your-repo
   cd your-blog-api
   go build -o blog-api

Create systemd service /etc/systemd/system/blog-api.service:

   [Unit]
   Description=Blog API
   After=network.target

   [Service]
   Type=simple
   User=root
   WorkingDirectory=/root/blog-api
   ExecStart=/root/blog-api/blog-api
   Restart=on-failure
   Environment="DATABASE_URL=postgres://blog_user:secure_password@localhost:5432/blog_db"
   Environment="JWT_SECRET=your-secret-key"
   Environment="PORT=8080"

   [Install]
   WantedBy=multi-user.target

Start service:

   sudo systemctl daemon-reload
   sudo systemctl enable blog-api
   sudo systemctl start blog-api
   sudo systemctl status blog-api

Setup Nginx reverse proxy /etc/nginx/sites-available/blog-api:

   server {
       listen 80;
       server_name your-domain.com;

       location / {
           proxy_pass http://localhost:8080;
           proxy_http_version 1.1;
           proxy_set_header Upgrade $http_upgrade;
           proxy_set_header Connection 'upgrade';
           proxy_set_header Host $host;
           proxy_cache_bypass $http_upgrade;
       }
   }

Enable site:

   sudo ln -s /etc/nginx/sites-available/blog-api /etc/nginx/sites-enabled/
   sudo nginx -t
   sudo systemctl restart nginx

Setup SSL with Let's Encrypt:

   sudo apt install certbot python3-certbot-nginx
   sudo certbot --nginx -d your-domain.com

Option 4: Deploy with Docker

# Build image
docker build -t blog-api .

# Run container
docker run -d \
  -p 8080:8080 \
  -e DATABASE_URL="postgres://..." \
  -e JWT_SECRET="your-secret" \
  --name blog-api \
  blog-api

# Or use docker-compose
docker-compose -f docker-compose.prod.yml up -d

6. Production Checklist (30 min)

Security Checklist

// ✅ HTTPS only in production
if config.IsProduction() {
    // Redirect HTTP to HTTPS
    go http.ListenAndServe(":80", http.HandlerFunc(redirectToHTTPS))
}

func redirectToHTTPS(w http.ResponseWriter, r *http.Request) {
    http.Redirect(w, r, "https://"+r.Host+r.RequestURI, 
        http.StatusMovedPermanently)
}

// ✅ Secure headers middleware
func SecurityHeadersMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("X-Content-Type-Options", "nosniff")
        w.Header().Set("X-Frame-Options", "DENY")
        w.Header().Set("X-XSS-Protection", "1; mode=block")
        w.Header().Set("Strict-Transport-Security", 
            "max-age=31536000; includeSubDomains")
        next.ServeHTTP(w, r)
    })
}

// ✅ Rate limiting
r.Use(middleware.Throttle(100)) // Chi built-in

// ✅ Request size limit
r.Use(middleware.RequestSize(10 * 1024 * 1024)) // 10MB max

// ✅ Timeout
r.Use(middleware.Timeout(60 * time.Second))

Monitoring & Logging

// Structured logging
import "log/slog"

logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

logger.Info("Server starting",
    "port", config.Port,
    "environment", config.Environment,
)

logger.Error("Database connection failed",
    "error", err,
)

Health Check Endpoint

func (s *Server) healthCheck(w http.ResponseWriter, r *http.Request) {
    // Check database
    sqlDB, _ := s.db.DB()
    if err := sqlDB.Ping(); err != nil {
        s.sendJSON(w, http.StatusServiceUnavailable, map[string]string{
            "status": "unhealthy",
            "database": "down",
        })
        return
    }

    s.sendJSON(w, http.StatusOK, map[string]string{
        "status": "healthy",
        "database": "up",
        "version": "1.0.0",
    })
}

Graceful Shutdown

func main() {
    // ... setup code ...

    server := &http.Server{
        Addr:    ":8080",
        Handler: router,
    }

    // Start server in goroutine
    go func() {
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatal("Server failed:", err)
        }
    }()

    // Wait for interrupt signal
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    log.Println("Shutting down server...")

    // Graceful shutdown with timeout
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    if err := server.Shutdown(ctx); err != nil {
        log.Fatal("Server forced to shutdown:", err)
    }

    log.Println("Server exited")
}

Final Project Structure

blog-api/
├── .env
├── .env.production
├── .gitignore
├── .dockerignore
├── Dockerfile
├── docker-compose.yml
├── go.mod
├── go.sum
├── main.go
├── README.md
├── config/
│   └── config.go
├── models/
│   ├── user.go
│   ├── user_test.go
│   ├── post.go
│   └── post_test.go
├── handlers/
│   ├── auth.go
│   ├── auth_test.go
│   ├── user.go
│   ├── user_test.go
│   ├── post.go
│   └── post_test.go
├── middleware/
│   ├── auth.go
│   ├── auth_test.go
│   ├── logging.go
│   └── security.go
├── repository/
│   ├── user_repository.go
│   ├── user_repository_test.go
│   ├── post_repository.go
│   └── post_repository_test.go
├── utils/
│   ├── jwt.go
│   ├── jwt_test.go
│   ├── password.go
│   ├── password_test.go
│   ├── validation.go
│   └── validation_test.go
├── routes/
│   └── routes.go
└── testutils/
    ├── database.go
    └── assertions.go

Key Takeaways

Testing

Test files end with _test.go
Use table-driven tests
Test with in-memory SQLite
Use httptest for HTTP handlers
Aim for >70% coverage

Building

go build creates single binary
Cross-compile with GOOS/GOARCH
Docker for containerized deployment
No runtime dependencies needed!

Deployment

Railway/Fly.io: Easiest, free tier
VPS: Full control, requires setup
Docker: Portable, consistent
Always use environment variables
Enable HTTPS in production

Production

Graceful shutdown
Health checks
Rate limiting
Security headers
Structured logging
Request timeouts

🎉 Congratulations!

You've completed the 7-day Go learning journey!

What you've learned:

✅ Go basics and syntax
✅ Structs, interfaces, and OOP
✅ Error handling
✅ HTTP servers and REST APIs
✅ Chi router and middleware
✅ Database with GORM
✅ JWT authentication
✅ Testing and deployment

You can now:

Build production-ready REST APIs
Implement secure authentication
Work with databases
Test your code
Deploy to production

Next Steps

Add more features:
- Pagination with cursor
- File uploads
- Email notifications
- WebSockets
- GraphQL
Learn advanced topics:
- Goroutines and channels (concurrency)
- gRPC
- Microservices
- Event-driven architecture
Practice:
- Build a real project
- Contribute to open source
- Read others' Go code
Resources:

You're now a Go developer! 🚀

Dart Object Oriented For Beginner : Expense Manager Case Study Part 9

Putra Prima A — Wed, 08 Oct 2025 22:50:13 +0000

Lesson 9: Building the Complete Expense Manager App

Duration: 60 minutes

App Feature: 🎉 Putting It All Together

What You'll Build: A full-featured expense tracking system

Prerequisites: Complete Lessons 1-8

What We'll Learn Today

By the end of this lesson, you'll be able to:

✅ Combine all OOP concepts into one application
✅ Organize code into multiple files
✅ Create a command-line interface
✅ Handle user input and validation
✅ Implement CRUD operations (Create, Read, Update, Delete)
✅ Save and load data
✅ Structure a real-world Dart application
✅ Prepare code for Flutter integration

Part 1: Application Architecture

Before we start coding, let's plan our application structure:

expense_manager/
├── lib/
│   ├── models/
│   │   ├── expense.dart
│   │   ├── recurring_expense.dart
│   │   ├── one_time_expense.dart
│   │   └── payment_method.dart
│   │
│   ├── managers/
│   │   └── expense_manager.dart
│   │
│   ├── utils/
│   │   ├── input_helper.dart
│   │   └── display_helper.dart
│   │
│   └── app.dart
│
└── bin/
    └── main.dart

Why this structure?

models/ - Data classes (Expense, PaymentMethod, etc.)
managers/ - Business logic (ExpenseManager)
utils/ - Helper functions (input, display)
app.dart - Main application logic
main.dart - Entry point

Part 2: Complete Models

expense.dart

class Expense {
  static int _idCounter = 0;

  final int id;
  String description;
  double amount;
  String category;
  DateTime date;
  String? notes;
  bool isPaid;
  String? paymentMethodName;

  Expense({
    required this.description,
    required this.amount,
    required this.category,
    DateTime? date,
    this.notes,
    this.isPaid = false,
    this.paymentMethodName,
  }) : id = ++_idCounter,
       date = date ?? DateTime.now() {
    if (amount < 0) {
      throw Exception('Amount cannot be negative');
    }
    if (description.trim().isEmpty) {
      throw Exception('Description cannot be empty');
    }
  }

  // Getters
  bool isMajorExpense() => amount > 100;

  bool isThisMonth() {
    DateTime now = DateTime.now();
    return date.year == now.year && date.month == now.month;
  }

  bool isToday() {
    DateTime now = DateTime.now();
    return date.year == now.year && 
           date.month == now.month && 
           date.day == now.day;
  }

  int getDaysAgo() {
    return DateTime.now().difference(date).inDays;
  }

  String getFormattedAmount() => '\$${amount.toStringAsFixed(2)}';

  String getFormattedDate() {
    return '${date.month}/${date.day}/${date.year}';
  }

  String getCategoryEmoji() {
    switch (category) {
      case 'Food': return '🍔';
      case 'Transport': return '🚗';
      case 'Bills': return '💡';
      case 'Entertainment': return '🎬';
      case 'Health': return '💊';
      case 'Shopping': return '🛍️';
      default: return '📝';
    }
  }

  String getSummary() {
    String emoji = isMajorExpense() ? '🔴' : '🟢';
    String paid = isPaid ? '✅' : '❌';
    return '$emoji $paid #$id: $description - ${getFormattedAmount()} [$category]';
  }

  void printDetails() {
    print('─────────────────────────────────────');
    print('ID: #$id');
    print('${getCategoryEmoji()} $description');
    print('Amount: ${getFormattedAmount()}');
    print('Category: $category');
    print('Date: ${getFormattedDate()} (${getDaysAgo()} days ago)');
    print('Status: ${isPaid ? "✅ Paid" : "❌ Unpaid"}');
    if (paymentMethodName != null) {
      print('Payment: $paymentMethodName');
    }
    if (notes != null && notes!.isNotEmpty) {
      print('Notes: $notes');
    }
    print('─────────────────────────────────────');
  }

  // Convert to/from Map for saving
  Map<String, dynamic> toMap() {
    return {
      'id': id,
      'description': description,
      'amount': amount,
      'category': category,
      'date': date.toIso8601String(),
      'notes': notes,
      'isPaid': isPaid,
      'paymentMethodName': paymentMethodName,
    };
  }

  static Expense fromMap(Map<String, dynamic> map) {
    return Expense(
      description: map['description'],
      amount: map['amount'],
      category: map['category'],
      date: DateTime.parse(map['date']),
      notes: map['notes'],
      isPaid: map['isPaid'],
      paymentMethodName: map['paymentMethodName'],
    );
  }
}

recurring_expense.dart

import 'expense.dart';

class RecurringExpense extends Expense {
  String frequency;
  DateTime? nextDueDate;

  RecurringExpense({
    required String description,
    required double amount,
    required String category,
    required this.frequency,
    DateTime? date,
    this.nextDueDate,
    String? notes,
    bool isPaid = false,
  }) : super(
    description: description,
    amount: amount,
    category: category,
    date: date,
    notes: notes,
    isPaid: isPaid,
  ) {
    nextDueDate ??= _calculateNextDueDate();
  }

  DateTime _calculateNextDueDate() {
    switch (frequency) {
      case 'daily':
        return date.add(Duration(days: 1));
      case 'weekly':
        return date.add(Duration(days: 7));
      case 'monthly':
        return DateTime(date.year, date.month + 1, date.day);
      case 'yearly':
        return DateTime(date.year + 1, date.month, date.day);
      default:
        return date;
    }
  }

  double yearlyTotal() {
    switch (frequency) {
      case 'daily': return amount * 365;
      case 'weekly': return amount * 52;
      case 'monthly': return amount * 12;
      case 'yearly': return amount;
      default: return amount;
    }
  }

  bool isDueSoon(int daysThreshold) {
    if (nextDueDate == null) return false;
    int daysUntilDue = nextDueDate!.difference(DateTime.now()).inDays;
    return daysUntilDue <= daysThreshold && daysUntilDue >= 0;
  }

  @override
  void printDetails() {
    print('─────────────────────────────────────');
    print('🔄 RECURRING EXPENSE #$id');
    print('${getCategoryEmoji()} $description');
    print('Amount: ${getFormattedAmount()}/$frequency');
    print('Yearly Total: \$${yearlyTotal().toStringAsFixed(2)}');
    print('Category: $category');
    print('Last Payment: ${getFormattedDate()}');
    if (nextDueDate != null) {
      print('Next Due: ${nextDueDate!.month}/${nextDueDate!.day}/${nextDueDate!.year}');
      if (isDueSoon(3)) {
        print('⚠️  Due soon!');
      }
    }
    print('Status: ${isPaid ? "✅ Paid" : "❌ Unpaid"}');
    if (notes != null && notes!.isNotEmpty) {
      print('Notes: $notes');
    }
    print('─────────────────────────────────────');
  }

  @override
  Map<String, dynamic> toMap() {
    var map = super.toMap();
    map['type'] = 'recurring';
    map['frequency'] = frequency;
    map['nextDueDate'] = nextDueDate?.toIso8601String();
    return map;
  }
}

one_time_expense.dart

import 'expense.dart';

class OneTimeExpense extends Expense {
  String occasion;

  OneTimeExpense({
    required String description,
    required double amount,
    required String category,
    required this.occasion,
    DateTime? date,
    String? notes,
    bool isPaid = false,
  }) : super(
    description: description,
    amount: amount,
    category: category,
    date: date,
    notes: notes,
    isPaid: isPaid,
  );

  bool isSpecialOccasion() {
    return occasion == 'birthday' || 
           occasion == 'anniversary' || 
           occasion == 'holiday' ||
           occasion == 'wedding';
  }

  String getOccasionEmoji() {
    switch (occasion) {
      case 'birthday': return '🎂';
      case 'anniversary': return '💝';
      case 'holiday': return '🎄';
      case 'wedding': return '💒';
      case 'emergency': return '🚨';
      case 'vacation': return '✈️';
      default: return '🎯';
    }
  }

  @override
  void printDetails() {
    print('─────────────────────────────────────');
    print('🎯 ONE-TIME EXPENSE #$id');
    print('${getOccasionEmoji()} $occasion: $description');
    print('${getCategoryEmoji()} Category: $category');
    print('Amount: ${getFormattedAmount()}');
    print('Date: ${getFormattedDate()} (${getDaysAgo()} days ago)');
    print('Status: ${isPaid ? "✅ Paid" : "❌ Unpaid"}');
    if (isSpecialOccasion()) {
      print('✨ Special occasion');
    }
    if (notes != null && notes!.isNotEmpty) {
      print('Notes: $notes');
    }
    print('─────────────────────────────────────');
  }

  @override
  Map<String, dynamic> toMap() {
    var map = super.toMap();
    map['type'] = 'onetime';
    map['occasion'] = occasion;
    return map;
  }
}

Part 3: Expense Manager

import 'dart:io';
import 'dart:convert';
import 'expense.dart';
import 'recurring_expense.dart';
import 'one_time_expense.dart';

class ExpenseManager {
  List<Expense> _expenses = [];
  String _dataFile = 'expenses.json';

  // Add expense
  void addExpense(Expense expense) {
    _expenses.add(expense);
    print('✅ Added expense #${expense.id}');
  }

  // Get all expenses
  List<Expense> getAllExpenses() => List.from(_expenses);

  int getCount() => _expenses.length;

  bool isEmpty() => _expenses.isEmpty;

  // Get by ID
  Expense? getExpenseById(int id) {
    try {
      return _expenses.firstWhere((e) => e.id == id);
    } catch (e) {
      return null;
    }
  }

  // Filter methods
  List<Expense> getByCategory(String category) {
    return _expenses.where((e) => e.category == category).toList();
  }

  List<Expense> getThisMonth() {
    return _expenses.where((e) => e.isThisMonth()).toList();
  }

  List<Expense> getUnpaid() {
    return _expenses.where((e) => !e.isPaid).toList();
  }

  List<RecurringExpense> getRecurringExpenses() {
    return _expenses.whereType<RecurringExpense>().toList();
  }

  List<OneTimeExpense> getOneTimeExpenses() {
    return _expenses.whereType<OneTimeExpense>().toList();
  }

  // Statistics
  double getTotalSpending() {
    return _expenses.fold(0.0, (sum, e) => sum + e.amount);
  }

  double getTotalByCategory(String category) {
    return _expenses
        .where((e) => e.category == category)
        .fold(0.0, (sum, e) => sum + e.amount);
  }

  double getTotalUnpaid() {
    return _expenses
        .where((e) => !e.isPaid)
        .fold(0.0, (sum, e) => sum + e.amount);
  }

  double getAverageExpense() {
    if (_expenses.isEmpty) return 0;
    return getTotalSpending() / _expenses.length;
  }

  Expense? getLargestExpense() {
    if (_expenses.isEmpty) return null;
    return _expenses.reduce((a, b) => a.amount > b.amount ? a : b);
  }

  List<String> getAllCategories() {
    return _expenses.map((e) => e.category).toSet().toList();
  }

  Map<String, double> getCategoryBreakdown() {
    Map<String, double> breakdown = {};
    for (var expense in _expenses) {
      breakdown[expense.category] = 
          (breakdown[expense.category] ?? 0) + expense.amount;
    }
    return breakdown;
  }

  // Sort methods
  List<Expense> sortByAmountDesc() {
    List<Expense> sorted = List.from(_expenses);
    sorted.sort((a, b) => b.amount.compareTo(a.amount));
    return sorted;
  }

  List<Expense> sortByDateDesc() {
    List<Expense> sorted = List.from(_expenses);
    sorted.sort((a, b) => b.date.compareTo(a.date));
    return sorted;
  }

  // Update
  bool updateExpense(int id, {
    String? description,
    double? amount,
    String? category,
    String? notes,
    bool? isPaid,
  }) {
    var expense = getExpenseById(id);
    if (expense == null) return false;

    if (description != null) expense.description = description;
    if (amount != null) expense.amount = amount;
    if (category != null) expense.category = category;
    if (notes != null) expense.notes = notes;
    if (isPaid != null) expense.isPaid = isPaid;

    print('✏️  Updated expense #$id');
    return true;
  }

  // Delete
  bool deleteExpense(int id) {
    int initialLength = _expenses.length;
    _expenses.removeWhere((e) => e.id == id);
    bool removed = _expenses.length < initialLength;

    if (removed) {
      print('🗑️  Deleted expense #$id');
    }
    return removed;
  }

  // Mark as paid
  bool markAsPaid(int id, String paymentMethod) {
    var expense = getExpenseById(id);
    if (expense == null) return false;

    expense.isPaid = true;
    expense.paymentMethodName = paymentMethod;
    print('✅ Marked expense #$id as paid');
    return true;
  }

  // Search
  List<Expense> search(String query) {
    String lowerQuery = query.toLowerCase();
    return _expenses.where((e) => 
      e.description.toLowerCase().contains(lowerQuery) ||
      e.category.toLowerCase().contains(lowerQuery) ||
      (e.notes?.toLowerCase().contains(lowerQuery) ?? false)
    ).toList();
  }

  // Reports
  void printSummary() {
    print('\n${"═" * 50}');
    print('💰 EXPENSE SUMMARY'.padRight(50));
    print('${"═" * 50}');
    print('Total expenses: ${getCount()}');
    print('Total spent: \$${getTotalSpending().toStringAsFixed(2)}');
    print('Average: \$${getAverageExpense().toStringAsFixed(2)}');
    print('Unpaid: \$${getTotalUnpaid().toStringAsFixed(2)}');

    var largest = getLargestExpense();
    if (largest != null) {
      print('Largest: ${largest.description} (${largest.getFormattedAmount()})');
    }

    var recurring = getRecurringExpenses();
    if (recurring.isNotEmpty) {
      double yearlyRecurring = recurring.fold(0.0, (sum, e) => sum + e.yearlyTotal());
      print('Yearly recurring: \$${yearlyRecurring.toStringAsFixed(2)}');
    }

    print('${"═" * 50}\n');
  }

  void printCategoryReport() {
    print('\n📊 CATEGORY BREAKDOWN\n');
    var breakdown = getCategoryBreakdown();
    double total = getTotalSpending();

    if (breakdown.isEmpty) {
      print('No expenses to show');
      return;
    }

    breakdown.forEach((category, amount) {
      double percentage = total > 0 ? (amount / total) * 100 : 0;
      int count = _expenses.where((e) => e.category == category).length;

      print('$category:');
      print('  Amount: \$${amount.toStringAsFixed(2)} (${percentage.toStringAsFixed(1)}%)');
      print('  Count: $count expenses');
      print('');
    });
  }

  void printMonthlyReport() {
    print('\n📅 MONTHLY REPORT\n');
    var thisMonth = getThisMonth();

    if (thisMonth.isEmpty) {
      print('No expenses this month');
      return;
    }

    double total = thisMonth.fold(0.0, (sum, e) => sum + e.amount);
    double unpaid = thisMonth.where((e) => !e.isPaid).fold(0.0, (sum, e) => sum + e.amount);

    print('This month: ${thisMonth.length} expenses');
    print('Total spent: \$${total.toStringAsFixed(2)}');
    print('Unpaid: \$${unpaid.toStringAsFixed(2)}');
    print('\nExpenses:');

    for (var expense in thisMonth) {
      print('  ${expense.getSummary()}');
    }
    print('');
  }

  // Save/Load
  Future<void> saveToFile() async {
    try {
      List<Map<String, dynamic>> data = _expenses.map((e) => e.toMap()).toList();
      String json = JsonEncoder.withIndent('  ').convert(data);
      await File(_dataFile).writeAsString(json);
      print('💾 Saved ${_expenses.length} expenses');
    } catch (e) {
      print('❌ Error saving: $e');
    }
  }

  Future<void> loadFromFile() async {
    try {
      if (!await File(_dataFile).exists()) {
        print('No saved data found');
        return;
      }

      String json = await File(_dataFile).readAsString();
      List<dynamic> data = jsonDecode(json);

      _expenses.clear();
      for (var item in data) {
        String type = item['type'] ?? 'regular';

        if (type == 'recurring') {
          _expenses.add(RecurringExpense(
            description: item['description'],
            amount: item['amount'],
            category: item['category'],
            frequency: item['frequency'],
            date: DateTime.parse(item['date']),
            nextDueDate: item['nextDueDate'] != null 
                ? DateTime.parse(item['nextDueDate']) 
                : null,
            notes: item['notes'],
            isPaid: item['isPaid'],
          ));
        } else if (type == 'onetime') {
          _expenses.add(OneTimeExpense(
            description: item['description'],
            amount: item['amount'],
            category: item['category'],
            occasion: item['occasion'],
            date: DateTime.parse(item['date']),
            notes: item['notes'],
            isPaid: item['isPaid'],
          ));
        } else {
          _expenses.add(Expense.fromMap(item));
        }
      }

      print('📂 Loaded ${_expenses.length} expenses');
    } catch (e) {
      print('❌ Error loading: $e');
    }
  }
}

Part 4: Helper Utilities

input_helper.dart

import 'dart:io';

class InputHelper {
  static String readString(String prompt) {
    stdout.write('$prompt: ');
    return stdin.readLineSync() ?? '';
  }

  static int readInt(String prompt, {int? min, int? max}) {
    while (true) {
      stdout.write('$prompt: ');
      String? input = stdin.readLineSync();

      if (input == null || input.isEmpty) {
        print('❌ Please enter a number');
        continue;
      }

      int? number = int.tryParse(input);

      if (number == null) {
        print('❌ Invalid number');
        continue;
      }

      if (min != null && number < min) {
        print('❌ Number must be at least $min');
        continue;
      }

      if (max != null && number > max) {
        print('❌ Number must be at most $max');
        continue;
      }

      return number;
    }
  }

  static double readDouble(String prompt, {double? min}) {
    while (true) {
      stdout.write('$prompt: ');
      String? input = stdin.readLineSync();

      if (input == null || input.isEmpty) {
        print('❌ Please enter a number');
        continue;
      }

      double? number = double.tryParse(input);

      if (number == null) {
        print('❌ Invalid number');
        continue;
      }

      if (min != null && number < min) {
        print('❌ Number must be at least $min');
        continue;
      }

      return number;
    }
  }

  static bool readYesNo(String prompt) {
    while (true) {
      stdout.write('$prompt (y/n): ');
      String? input = stdin.readLineSync()?.toLowerCase();

      if (input == 'y' || input == 'yes') return true;
      if (input == 'n' || input == 'no') return false;

      print('❌ Please enter y or n');
    }
  }

  static String readChoice(String prompt, List<String> options) {
    print('$prompt:');
    for (int i = 0; i < options.length; i++) {
      print('  ${i + 1}. ${options[i]}');
    }

    int choice = readInt('Choose (1-${options.length})', 
                         min: 1, max: options.length);
    return options[choice - 1];
  }

  static void pause() {
    print('\nPress Enter to continue...');
    stdin.readLineSync();
  }
}

display_helper.dart

class DisplayHelper {
  static void clearScreen() {
    print('\n' * 50);  // Simple clear for cross-platform
  }

  static void printHeader(String title) {
    print('\n${"═" * 60}');
    print(title.toUpperCase().padRight(60));
    print('${"═" * 60}\n');
  }

  static void printSuccess(String message) {
    print('✅ $message');
  }

  static void printError(String message) {
    print('❌ $message');
  }

  static void printWarning(String message) {
    print('⚠️  $message');
  }

  static void printInfo(String message) {
    print('ℹ️  $message');
  }

  static void printDivider() {
    print('─' * 60);
  }
}

Part 5: Main Application

app.dart

import 'dart:io';
import 'expense_manager.dart';
import 'expense.dart';
import 'recurring_expense.dart';
import 'one_time_expense.dart';
import 'input_helper.dart';
import 'display_helper.dart';

class ExpenseApp {
  final ExpenseManager _manager = ExpenseManager();
  bool _running = true;

  Future<void> run() async {
    DisplayHelper.clearScreen();
    print('🚀 Loading...');
    await _manager.loadFromFile();

    while (_running) {
      _showMainMenu();
      int choice = InputHelper.readInt('\nChoose an option', min: 1, max: 11);

      DisplayHelper.clearScreen();

      switch (choice) {
        case 1:
          _addExpense();
          break;
        case 2:
          _viewAllExpenses();
          break;
        case 3:
          _viewByCategory();
          break;
        case 4:
          _searchExpenses();
          break;
        case 5:
          _viewExpenseDetails();
          break;
        case 6:
          _updateExpense();
          break;
        case 7:
          _deleteExpense();
          break;
        case 8:
          _markAsPaid();
          break;
        case 9:
          _viewReports();
          break;
        case 10:
          await _saveAndExit();
          break;
        case 11:
          _running = false;
          print('👋 Goodbye!');
          break;
      }

      if (_running && choice != 10 && choice != 11) {
        InputHelper.pause();
      }
    }
  }

  void _showMainMenu() {
    DisplayHelper.clearScreen();
    DisplayHelper.printHeader('💰 Expense Manager v1.0');

    if (!_manager.isEmpty()) {
      print('Total: ${_manager.getCount()} expenses | ');
      print('Spent: \$${_manager.getTotalSpending().toStringAsFixed(2)} | ');
      print('Unpaid: \$${_manager.getTotalUnpaid().toStringAsFixed(2)}\n');
    }

    print('1.  ➕ Add Expense');
    print('2.  📋 View All Expenses');
    print('3.  📁 View by Category');
    print('4.  🔍 Search Expenses');
    print('5.  🔎 View Expense Details');
    print('6.  ✏️  Update Expense');
    print('7.  🗑️  Delete Expense');
    print('8.  💳 Mark as Paid');
    print('9.  📊 View Reports');
    print('10. 💾 Save & Exit');
    print('11. 🚪 Exit Without Saving');
  }

  void _addExpense() {
    DisplayHelper.printHeader('➕ Add Expense');

    String type = InputHelper.readChoice('Expense type', [
      'Regular',
      'Recurring (subscriptions, bills)',
      'One-time (special occasion)',
    ]);

    print('');
    String description = InputHelper.readString('Description');
    double amount = InputHelper.readDouble('Amount (\$)', min: 0);

    String category = InputHelper.readChoice('Category', [
      'Food',
      'Transport',
      'Bills',
      'Entertainment',
      'Health',
      'Shopping',
      'Other',
    ]);

    String? notes;
    if (InputHelper.readYesNo('Add notes?')) {
      notes = InputHelper.readString('Notes');
    }

    try {
      if (type == 'Regular') {
        _manager.addExpense(Expense(
          description: description,
          amount: amount,
          category: category,
          notes: notes,
        ));
      } else if (type == 'Recurring (subscriptions, bills)') {
        String frequency = InputHelper.readChoice('Frequency', [
          'daily',
          'weekly',
          'monthly',
          'yearly',
        ]);

        _manager.addExpense(RecurringExpense(
          description: description,
          amount: amount,
          category: category,
          frequency: frequency,
          notes: notes,
        ));
      } else {
        String occasion = InputHelper.readChoice('Occasion', [
          'birthday',
          'anniversary',
          'holiday',
          'wedding',
          'emergency',
          'vacation',
          'other',
        ]);

        _manager.addExpense(OneTimeExpense(
          description: description,
          amount: amount,
          category: category,
          occasion: occasion,
          notes: notes,
        ));
      }

      DisplayHelper.printSuccess('Expense added successfully!');
    } catch (e) {
      DisplayHelper.printError('Failed to add expense: $e');
    }
  }

  void _viewAllExpenses() {
    DisplayHelper.printHeader('📋 All Expenses');

    if (_manager.isEmpty()) {
      DisplayHelper.printInfo('No expenses yet');
      return;
    }

    String sortBy = InputHelper.readChoice('Sort by', [
      'Date (newest first)',
      'Amount (highest first)',
      'ID',
    ]);

    List<Expense> expenses;
    if (sortBy == 'Date (newest first)') {
      expenses = _manager.sortByDateDesc();
    } else if (sortBy == 'Amount (highest first)') {
      expenses = _manager.sortByAmountDesc();
    } else {
      expenses = _manager.getAllExpenses();
    }

    print('');
    for (var expense in expenses) {
      print(expense.getSummary());
    }

    print('\nTotal: ${expenses.length} expenses');
  }

  void _viewByCategory() {
    DisplayHelper.printHeader('📁 View by Category');

    var categories = _manager.getAllCategories();
    if (categories.isEmpty) {
      DisplayHelper.printInfo('No expenses yet');
      return;
    }

    String category = InputHelper.readChoice('Category', categories);
    var expenses = _manager.getByCategory(category);

    print('');
    if (expenses.isEmpty) {
      DisplayHelper.printInfo('No expenses in this category');
      return;
    }

    for (var expense in expenses) {
      print(expense.getSummary());
    }

    double total = expenses.fold(0.0, (sum, e) => sum + e.amount);
    print('\n$category Total: \${total.toStringAsFixed(2)}');
  }

  void _searchExpenses() {
    DisplayHelper.printHeader('🔍 Search Expenses');

    String query = InputHelper.readString('Search for');
    var results = _manager.search(query);

    print('');
    if (results.isEmpty) {
      DisplayHelper.printInfo('No results found');
      return;
    }

    print('Found ${results.length} result(s):\n');
    for (var expense in results) {
      print(expense.getSummary());
    }
  }

  void _viewExpenseDetails() {
    DisplayHelper.printHeader('🔎 View Expense Details');

    if (_manager.isEmpty()) {
      DisplayHelper.printInfo('No expenses yet');
      return;
    }

    int id = InputHelper.readInt('Enter expense ID');
    var expense = _manager.getExpenseById(id);

    print('');
    if (expense == null) {
      DisplayHelper.printError('Expense not found');
      return;
    }

    expense.printDetails();
  }

  void _updateExpense() {
    DisplayHelper.printHeader('✏️  Update Expense');

    if (_manager.isEmpty()) {
      DisplayHelper.printInfo('No expenses yet');
      return;
    }

    int id = InputHelper.readInt('Enter expense ID');
    var expense = _manager.getExpenseById(id);

    if (expense == null) {
      DisplayHelper.printError('Expense not found');
      return;
    }

    print('\nCurrent details:');
    expense.printDetails();

    print('\nWhat would you like to update?');
    print('1. Description');
    print('2. Amount');
    print('3. Category');
    print('4. Notes');
    print('5. Cancel');

    int choice = InputHelper.readInt('Choose', min: 1, max: 5);

    if (choice == 5) {
      print('Cancelled');
      return;
    }

    switch (choice) {
      case 1:
        String newDesc = InputHelper.readString('New description');
        _manager.updateExpense(id, description: newDesc);
        break;
      case 2:
        double newAmount = InputHelper.readDouble('New amount', min: 0);
        _manager.updateExpense(id, amount: newAmount);
        break;
      case 3:
        String newCategory = InputHelper.readChoice('New category', [
          'Food', 'Transport', 'Bills', 'Entertainment', 
          'Health', 'Shopping', 'Other'
        ]);
        _manager.updateExpense(id, category: newCategory);
        break;
      case 4:
        String newNotes = InputHelper.readString('New notes');
        _manager.updateExpense(id, notes: newNotes);
        break;
    }
  }

  void _deleteExpense() {
    DisplayHelper.printHeader('🗑️  Delete Expense');

    if (_manager.isEmpty()) {
      DisplayHelper.printInfo('No expenses yet');
      return;
    }

    int id = InputHelper.readInt('Enter expense ID');
    var expense = _manager.getExpenseById(id);

    if (expense == null) {
      DisplayHelper.printError('Expense not found');
      return;
    }

    print('\nExpense to delete:');
    print(expense.getSummary());

    if (InputHelper.readYesNo('\nAre you sure?')) {
      _manager.deleteExpense(id);
    } else {
      print('Cancelled');
    }
  }

  void _markAsPaid() {
    DisplayHelper.printHeader('💳 Mark as Paid');

    var unpaid = _manager.getUnpaid();
    if (unpaid.isEmpty) {
      DisplayHelper.printInfo('No unpaid expenses');
      return;
    }

    print('Unpaid expenses:\n');
    for (var expense in unpaid) {
      print(expense.getSummary());
    }

    print('');
    int id = InputHelper.readInt('Enter expense ID');
    var expense = _manager.getExpenseById(id);

    if (expense == null) {
      DisplayHelper.printError('Expense not found');
      return;
    }

    if (expense.isPaid) {
      DisplayHelper.printWarning('This expense is already paid');
      return;
    }

    String paymentMethod = InputHelper.readChoice('Payment method', [
      'Cash',
      'Credit Card',
      'Debit Card',
      'Digital Wallet',
      'Bank Transfer',
      'Other',
    ]);

    _manager.markAsPaid(id, paymentMethod);
  }

  void _viewReports() {
    DisplayHelper.printHeader('📊 Reports');

    if (_manager.isEmpty()) {
      DisplayHelper.printInfo('No expenses yet');
      return;
    }

    print('1. Summary');
    print('2. Category Breakdown');
    print('3. Monthly Report');
    print('4. All Reports');

    int choice = InputHelper.readInt('Choose', min: 1, max: 4);

    print('');
    switch (choice) {
      case 1:
        _manager.printSummary();
        break;
      case 2:
        _manager.printCategoryReport();
        break;
      case 3:
        _manager.printMonthlyReport();
        break;
      case 4:
        _manager.printSummary();
        _manager.printCategoryReport();
        _manager.printMonthlyReport();
        break;
    }
  }

  Future<void> _saveAndExit() async {
    DisplayHelper.printHeader('💾 Saving');
    await _manager.saveToFile();
    _running = false;
    print('\n✅ Data saved. Goodbye! 👋');
  }
}

main.dart

import 'app.dart';

void main() async {
  var app = ExpenseApp();
  await app.run();
}

Part 6: Running the Application

How to Run:

Create the project structure:

mkdir expense_manager
cd expense_manager
mkdir lib bin

Create all the files in the appropriate folders
Run the application:

dart run bin/main.dart

Sample Interaction:

═══════════════════════════════════════════════════════════
💰 EXPENSE MANAGER V1.0
═══════════════════════════════════════════════════════════

1.  ➕ Add Expense
2.  📋 View All Expenses
3.  📁 View by Category
4.  🔍 Search Expenses
5.  🔎 View Expense Details
6.  ✏️  Update Expense
7.  🗑️  Delete Expense
8.  💳 Mark as Paid
9.  📊 View Reports
10. 💾 Save & Exit
11. 🚪 Exit Without Saving

Choose an option: 1

═══════════════════════════════════════════════════════════
➕ ADD EXPENSE
═══════════════════════════════════════════════════════════

Expense type:
  1. Regular
  2. Recurring (subscriptions, bills)
  3. One-time (special occasion)
Choose (1-3): 2

Description: Netflix Subscription
Amount ($): 15.99
Category:
  1. Food
  2. Transport
  3. Bills
  4. Entertainment
  5. Health
  6. Shopping
  7. Other
Choose (1-7): 4
Frequency:
  1. daily
  2. weekly
  3. monthly
  4. yearly
Choose (1-4): 3
Add notes? (y/n): y
Notes: Premium 4K plan

✅ Added expense #1

Part 7: Key Features Implemented

✅ CRUD Operations

Create: Add expenses (regular, recurring, one-time)
Read: View all, by category, search, view details
Update: Modify description, amount, category, notes
Delete: Remove expenses with confirmation

✅ Data Persistence

Save to JSON file
Load from JSON file
Auto-save on exit

✅ Different Expense Types

Regular expenses
Recurring expenses (with frequency and yearly total)
One-time expenses (with occasion)

✅ Filtering & Sorting

By category
By date
By amount
Search by keyword

✅ Statistics & Reports

Total spending
Category breakdown
Monthly report
Unpaid expenses

✅ Payment Tracking

Mark as paid
Track payment method
View unpaid expenses

Part 8: Extending the Application

Ideas for Enhancement:

1. Budget Management

class Budget {
  String category;
  double limit;
  int month;
  int year;

  bool isOverBudget(ExpenseManager manager) {
    double spent = manager.getTotalByCategory(category);
    return spent > limit;
  }
}

2. Export to CSV

void exportToCsv(String filename) {
  var file = File(filename);
  var csv = 'ID,Description,Amount,Category,Date,Paid\n';

  for (var expense in _expenses) {
    csv += '${expense.id},${expense.description},${expense.amount},';
    csv += '${expense.category},${expense.getFormattedDate()},${expense.isPaid}\n';
  }

  file.writeAsStringSync(csv);
  print('📄 Exported to $filename');
}

3. Charts & Visualizations

void printBarChart() {
  var breakdown = getCategoryBreakdown();
  double max = breakdown.values.reduce((a, b) => a > b ? a : b);

  breakdown.forEach((category, amount) {
    int bars = (amount / max * 20).round();
    print('$category: ${"█" * bars} \${amount.toStringAsFixed(2)}');
  });
}

4. Recurring Payment Reminders

void checkUpcomingPayments() {
  var recurring = getRecurringExpenses();

  for (var expense in recurring) {
    if (expense.isDueSoon(3)) {
      print('⚠️  ${expense.description} due in ${expense.nextDueDate!.difference(DateTime.now()).inDays} days');
    }
  }
}

5. Income Tracking

class Income {
  String source;
  double amount;
  DateTime date;

  Income(this.source, this.amount, this.date);
}

class FinanceManager {
  ExpenseManager expenseManager;
  List<Income> incomes = [];

  double getNetBalance() {
    double totalIncome = incomes.fold(0.0, (sum, i) => sum + i.amount);
    double totalExpense = expenseManager.getTotalSpending();
    return totalIncome - totalExpense;
  }
}

🎯 Practice Exercises

Exercise 1: Add Expense Categories Management (Easy)

Allow users to create custom categories instead of using predefined ones.

Hint:

class CategoryManager {
  List<String> _categories = ['Food', 'Transport', 'Bills'];

  void addCategory(String category) { ... }
  void removeCategory(String category) { ... }
  List<String> getAllCategories() { ... }
}

Exercise 2: Implement Budget System (Medium)

Create a budget management system with alerts when spending exceeds limits.

Requirements:

Set monthly budget per category
Track spending vs budget
Show warnings when approaching limit
Generate budget report

Exercise 3: Multi-User Support (Hard)

Add user accounts so multiple people can track their expenses separately.

Requirements:

User login system
Separate expense lists per user
User profiles with settings
Data saved per user

Part 9: Preparing for Flutter

This command-line app is a perfect foundation for a Flutter app!

Structure Similarities:

Command-line:

ExpenseApp (manages UI flow)
  └── ExpenseManager (manages data)
      └── Expense models

Flutter:

ExpenseApp (MaterialApp)
  └── Screens (HomeScreen, AddScreen, etc.)
      └── ExpenseProvider (state management)
          └── ExpenseManager (same!)
              └── Expense models (same!)

What Stays the Same:

✅ All model classes (Expense, RecurringExpense, etc.)

✅ ExpenseManager class

✅ Business logic

✅ Data persistence

What Changes:

❌ Command-line UI → Flutter widgets

❌ stdin/stdout → TextFields, Buttons

❌ print() → Text widgets

Next Steps for Flutter:

Keep all your model and manager classes
Replace InputHelper with Flutter Forms
Replace DisplayHelper with Flutter widgets
Add state management (Provider, Riverpod, or Bloc)
Create beautiful UI screens

Common Mistakes & How to Fix Them

Mistake 1: Not Handling Null Values

// ❌ Wrong - might crash
var expense = _manager.getExpenseById(id);
expense.printDetails();  // Crash if null!

// ✅ Correct - check for null
var expense = _manager.getExpenseById(id);
if (expense == null) {
  print('Expense not found');
  return;
}
expense.printDetails();

Mistake 2: Not Validating User Input

// ❌ Wrong - no validation
double amount = double.parse(input);

// ✅ Correct - validate and handle errors
double? amount = double.tryParse(input);
if (amount == null || amount < 0) {
  print('Invalid amount');
  return;
}

Mistake 3: Forgetting to Save Data

// ❌ Wrong - data lost on exit
void exit() {
  _running = false;
}

// ✅ Correct - save before exit
Future<void> exit() async {
  await _manager.saveToFile();
  _running = false;
}

Mistake 4: Not Using async/await Properly

// ❌ Wrong - doesn't wait for save
void saveData() {
  _manager.saveToFile();
  print('Saved!');  // Prints before save completes!
}

// ✅ Correct - await the operation
Future<void> saveData() async {
  await _manager.saveToFile();
  print('Saved!');  // Prints after save completes
}

Key Concepts Review

✅ Project organization - separate concerns into folders

✅ Model classes - represent data structures

✅ Manager classes - handle business logic

✅ Helper classes - reusable utility functions

✅ CRUD operations - Create, Read, Update, Delete

✅ Data persistence - save/load JSON

✅ User input validation - ensure data quality

✅ Error handling - graceful failure management

✅ Menu-driven UI - clear user flow

Self-Check Questions

1. Why separate models, managers, and helpers into different files?

Answer:

Organization: Easy to find and maintain code
Reusability: Can use same classes in different projects
Testing: Can test each component independently
Collaboration: Multiple developers can work on different parts
Scalability: Easy to add new features without breaking existing code

2. What's the difference between a model class and a manager class?

Answer:

Model: Represents a single entity (one expense) with properties and methods related to that entity
Manager: Handles collections and operations on multiple entities (all expenses, filtering, sorting, statistics)

3. Why use async/await for file operations?

Answer:
File operations are slow (I/O bound). Using async/await prevents the app from freezing while waiting for the file operation to complete, allowing other code to run in the meantime.

What's Next?

Congratulations! 🎉

You've completed all 9 lessons and built a complete, working expense manager application using OOP principles!

What You've Learned:

✅ Lesson 1: OOP basics

✅ Lesson 2: Classes and objects

✅ Lesson 3: Constructors

✅ Lesson 4: Encapsulation

✅ Lesson 5: Methods

✅ Lesson 6: Collections management

✅ Lesson 7: Inheritance

✅ Lesson 8: Polymorphism & abstraction

✅ Lesson 9: Complete application

Next Steps:

Enhance the CLI app with the practice exercises
Learn Flutter - convert this to a mobile app
Add database - SQLite for better data storage
Cloud sync - Firebase for multi-device support
Advanced features - charts, budgets, categories
Publish - share your app with others!

Final Project Ideas

Beginner Projects:

Todo list manager
Contact book
Note-taking app
Simple calculator with history

Intermediate Projects:

Habit tracker
Inventory management
Recipe organizer
Time tracker

Advanced Projects:

Budget planner with forecasting
Investment portfolio tracker
Multi-currency expense manager
Business expense reporting system

Resources for Continued Learning

Official Documentation:

Dart: https://dart.dev/guides
Flutter: https://flutter.dev/docs
Effective Dart: https://dart.dev/guides/language/effective-dart

Practice Platforms:

DartPad: https://dartpad.dev (online Dart playground)
LeetCode: Algorithm practice
HackerRank: Coding challenges

Community:

Flutter Discord: Join the community
r/FlutterDev: Reddit community
Stack Overflow: Ask questions

Closing Thoughts

You've accomplished a lot! 🌟

You started knowing nothing about OOP, and now you have:

A solid understanding of all core OOP principles
Practical experience building a real application
Clean, organized, maintainable code
A foundation ready for Flutter development

Keep practicing, keep building, and most importantly - have fun coding! 💪

The best way to solidify your knowledge is to build more projects. Take the concepts you've learned and create something new. Every project teaches you something valuable.

Good luck on your coding journey! 🚀

End of Course ✨

Dart Object Oriented For Beginner : Expense Manager Case Study Part 8

Putra Prima A — Wed, 08 Oct 2025 22:49:57 +0000

Lesson 8: Polymorphism & Abstraction

Duration: 50 minutes

App Feature: 💳 Supporting Multiple Payment Methods

What You'll Build: Abstract classes for payment methods and interfaces

Prerequisites: Complete Lessons 1-7

What We'll Learn Today

By the end of this lesson, you'll be able to:

✅ Understand polymorphism in depth
✅ Create abstract classes (templates)
✅ Use abstract methods (contracts)
✅ Implement interfaces with implements
✅ Know when to use abstract classes vs interfaces
✅ Build flexible, extensible code
✅ Work with multiple inheritance through interfaces

Part 1: Polymorphism Revisited

Polymorphism means "many forms" - one interface, multiple implementations.

Real-World Example:

Think about a remote control:

🎮 Remote Control (Same Button)
├── Press "Play" on TV → Plays TV show
├── Press "Play" on Music → Plays song
├── Press "Play" on Game → Starts game
└── Same action, different results!

In Code:

void main() {
  // One list, multiple types
  List<Expense> expenses = [
    Expense('Coffee', 4.50, 'Food', DateTime.now()),
    RecurringExpense('Netflix', 15.99, 'Entertainment', 'monthly'),
    OneTimeExpense('Gift', 50.0, 'Gifts', DateTime.now(), 'birthday'),
  ];

  // Same method call, different behavior!
  for (var expense in expenses) {
    expense.printDetails();  // Each type prints differently
    print('');
  }

  // This is polymorphism in action!
}

Key Benefits:

Write code once, works with all types
Easy to add new types without changing existing code
Flexible and maintainable

Part 2: The Problem - Need for Contracts

Let's say we want to add payment methods to our expenses:

class CreditCard {
  void pay(double amount) {
    print('💳 Paid \$${amount} with credit card');
  }
}

class Cash {
  void payNow(double amount) {  // Different method name!
    print('💵 Paid \$${amount} in cash');
  }
}

class DigitalWallet {
  void makePayment(double amount) {  // Another different name!
    print('📱 Paid \$${amount} with digital wallet');
  }
}

The Problem:

Every payment method has different method names
Can't treat them uniformly
Hard to add new payment methods
No guarantee they all have payment functionality

The Solution: Abstract classes and interfaces!

Part 3: Abstract Classes - Creating Templates

An abstract class is a template that defines what methods child classes MUST implement.

// Abstract class - cannot be instantiated directly
abstract class PaymentMethod {
  String get name;  // Abstract getter

  // Abstract method - no implementation
  void processPayment(double amount);

  // Concrete method - has implementation
  void showReceipt(double amount) {
    print('\n📄 RECEIPT');
    print('Payment method: $name');
    print('Amount: \$${amount.toStringAsFixed(2)}');
    print('✅ Payment successful\n');
  }
}

// Concrete class - implements all abstract members
class CreditCard extends PaymentMethod {
  String cardNumber;

  CreditCard(this.cardNumber);

  @override
  String get name => 'Credit Card';

  @override
  void processPayment(double amount) {
    print('💳 Processing credit card payment...');
    print('Card: ****${cardNumber.substring(cardNumber.length - 4)}');
    showReceipt(amount);
  }
}

class Cash extends PaymentMethod {
  @override
  String get name => 'Cash';

  @override
  void processPayment(double amount) {
    print('💵 Processing cash payment of \$${amount.toStringAsFixed(2)}');
    showReceipt(amount);
  }
}

void main() {
  // Can't do this - abstract class!
  // var payment = PaymentMethod();  // ❌ Error!

  // Must use concrete implementations
  var creditCard = CreditCard('4532123456789012');
  var cash = Cash();

  creditCard.processPayment(50.0);
  cash.processPayment(25.0);
}

Output:

💳 Processing credit card payment...
Card: ****9012

📄 RECEIPT
Payment method: Credit Card
Amount: $50.00
✅ Payment successful

💵 Processing cash payment of $25.00

📄 RECEIPT
Payment method: Cash
Amount: $25.00
✅ Payment successful

Key Points:

abstract class PaymentMethod {

abstract keyword means can't create instances directly
Used as a template/contract

void processPayment(double amount);

Abstract method - no body, just signature
Child classes MUST implement this

void showReceipt(double amount) {
  // Has implementation
}

Concrete method in abstract class
Available to all children

Part 4: Using Abstract Classes with Expenses

Let's integrate payment methods with our Expense class:

abstract class PaymentMethod {
  String get name;
  void processPayment(double amount);

  void showReceipt(double amount) {
    print('📄 Receipt: $name - \$${amount.toStringAsFixed(2)} ✅');
  }
}

class CreditCard extends PaymentMethod {
  String cardNumber;
  String cardHolder;

  CreditCard(this.cardNumber, this.cardHolder);

  @override
  String get name => 'Credit Card';

  @override
  void processPayment(double amount) {
    print('💳 Charging \$${amount.toStringAsFixed(2)} to $cardHolder\'s card');
    print('   Card: ****${cardNumber.substring(cardNumber.length - 4)}');
    showReceipt(amount);
  }
}

class Cash extends PaymentMethod {
  @override
  String get name => 'Cash';

  @override
  void processPayment(double amount) {
    print('💵 Received \$${amount.toStringAsFixed(2)} in cash');
    showReceipt(amount);
  }
}

class DigitalWallet extends PaymentMethod {
  String walletName;
  String email;

  DigitalWallet(this.walletName, this.email);

  @override
  String get name => 'Digital Wallet ($walletName)';

  @override
  void processPayment(double amount) {
    print('📱 Sending payment request to $email');
    print('   Via: $walletName');
    showReceipt(amount);
  }
}

// Updated Expense class
class Expense {
  String description;
  double amount;
  String category;
  DateTime date;
  PaymentMethod? paymentMethod;

  Expense(this.description, this.amount, this.category, this.date);

  void payWith(PaymentMethod method) {
    paymentMethod = method;
    print('\nProcessing payment for: $description (\$${amount.toStringAsFixed(2)})');
    method.processPayment(amount);
  }

  void printDetails() {
    String payment = paymentMethod != null 
        ? 'Paid with: ${paymentMethod!.name}' 
        : 'Not paid yet';
    print('$description: \$${amount.toStringAsFixed(2)} [$category]');
    print('$payment');
  }
}

void main() {
  var rent = Expense('Monthly rent', 1200.0, 'Bills', DateTime.now());
  var coffee = Expense('Coffee', 4.50, 'Food', DateTime.now());
  var laptop = Expense('New laptop', 899.99, 'Electronics', DateTime.now());

  // Pay with different methods
  rent.payWith(CreditCard('4532123456789012', 'John Doe'));
  coffee.payWith(Cash());
  laptop.payWith(DigitalWallet('PayPal', 'john@example.com'));

  print('\n' + '═' * 40);
  print('EXPENSE SUMMARY');
  print('═' * 40);
  rent.printDetails();
  print('');
  coffee.printDetails();
  print('');
  laptop.printDetails();
}

Part 5: Interfaces with implements

Dart doesn't have a separate interface keyword. Instead, any class can be used as an interface with implements.

Difference:

extends = IS-A relationship, inherit implementation
implements = HAS-A contract, must implement all methods yourself

// Can use any class as an interface
abstract class Printable {
  void printDocument();
  String getDocumentName();
}

abstract class Saveable {
  void save();
  void load();
}

// Implement multiple interfaces
class Report implements Printable, Saveable {
  String title;
  String content;

  Report(this.title, this.content);

  @override
  void printDocument() {
    print('🖨️ Printing: $title');
    print(content);
  }

  @override
  String getDocumentName() {
    return title;
  }

  @override
  void save() {
    print('💾 Saving report: $title');
  }

  @override
  void load() {
    print('📂 Loading report: $title');
  }
}

void main() {
  var report = Report('Monthly Report', 'Sales increased by 15%');

  report.printDocument();
  report.save();
}

Multiple Inheritance Through Interfaces:

abstract class Taxable {
  double calculateTax(double taxRate);
}

abstract class Discountable {
  double applyDiscount(double discountPercent);
}

// Can implement multiple interfaces
class PurchaseExpense extends Expense implements Taxable, Discountable {
  PurchaseExpense(String desc, double amt, String cat, DateTime date)
    : super(desc, amt, cat, date);

  @override
  double calculateTax(double taxRate) {
    return amount * taxRate;
  }

  @override
  double applyDiscount(double discountPercent) {
    return amount * (1 - discountPercent / 100);
  }

  double getTotalWithTax(double taxRate) {
    return amount + calculateTax(taxRate);
  }
}

void main() {
  var purchase = PurchaseExpense('Laptop', 1000.0, 'Electronics', DateTime.now());

  print('Original: \$${purchase.amount}');
  print('Tax (10%): \$${purchase.calculateTax(0.10).toStringAsFixed(2)}');
  print('Total with tax: \$${purchase.getTotalWithTax(0.10).toStringAsFixed(2)}');
  print('With 15% discount: \$${purchase.applyDiscount(15).toStringAsFixed(2)}');
}

Part 6: When to Use Abstract Classes vs Interfaces

Use Abstract Class When:

✅ You want to share code (concrete methods)

✅ Related classes with common functionality

✅ Define default behavior

✅ IS-A relationship makes sense

Example:

abstract class Expense {
  // Shared properties
  String description;
  double amount;

  // Concrete methods all expenses use
  bool isMajor() => amount > 100;

  // Abstract method children customize
  void printDetails();
}

Use Interface (implements) When:

✅ Unrelated classes need same contract

✅ Multiple inheritance needed

✅ Just defining capabilities, no shared code

✅ HAS-A capability relationship

Example:

abstract class Printable {
  void print();
}

// Completely different classes, same capability
class Document implements Printable { ... }
class Photo implements Printable { ... }
class Receipt implements Printable { ... }

Part 7: Complete Payment System Example

Let's build a complete payment system with abstract classes:

// Abstract payment method
abstract class PaymentMethod {
  String get name;
  String get icon;

  void processPayment(double amount);

  bool validate() {
    return true;  // Default implementation
  }

  void showReceipt(double amount) {
    print('\n${"─" * 35}');
    print('$icon RECEIPT');
    print('${"─" * 35}');
    print('Payment Method: $name');
    print('Amount: \$${amount.toStringAsFixed(2)}');
    print('Status: ✅ Success');
    print('Date: ${DateTime.now().toString().split('.')[0]}');
    print('${"─" * 35}\n');
  }
}

// Concrete implementations
class CreditCard extends PaymentMethod {
  String cardNumber;
  String cardHolder;
  String expiryDate;
  String cvv;

  CreditCard({
    required this.cardNumber,
    required this.cardHolder,
    required this.expiryDate,
    required this.cvv,
  });

  @override
  String get name => 'Credit Card';

  @override
  String get icon => '💳';

  @override
  bool validate() {
    // Simple validation
    if (cardNumber.length != 16) return false;
    if (cvv.length != 3) return false;
    // Check expiry date
    return true;
  }

  @override
  void processPayment(double amount) {
    if (!validate()) {
      print('❌ Invalid card details');
      return;
    }

    print('$icon Processing credit card payment...');
    print('Cardholder: $cardHolder');
    print('Card: ****${cardNumber.substring(12)}');
    print('Expiry: $expiryDate');
    showReceipt(amount);
  }
}

class DebitCard extends PaymentMethod {
  String cardNumber;
  String pin;
  double balance;

  DebitCard({
    required this.cardNumber,
    required this.pin,
    required this.balance,
  });

  @override
  String get name => 'Debit Card';

  @override
  String get icon => '💳';

  @override
  bool validate() {
    return pin.length == 4 && balance > 0;
  }

  @override
  void processPayment(double amount) {
    if (!validate()) {
      print('❌ Invalid PIN or insufficient balance');
      return;
    }

    if (balance < amount) {
      print('❌ Insufficient funds. Balance: \$${balance.toStringAsFixed(2)}');
      return;
    }

    balance -= amount;
    print('$icon Processing debit card payment...');
    print('Card: ****${cardNumber.substring(12)}');
    print('New balance: \$${balance.toStringAsFixed(2)}');
    showReceipt(amount);
  }
}

class Cash extends PaymentMethod {
  @override
  String get name => 'Cash';

  @override
  String get icon => '💵';

  @override
  void processPayment(double amount) {
    print('$icon Cash payment received');
    print('Amount: \$${amount.toStringAsFixed(2)}');
    showReceipt(amount);
  }
}

class DigitalWallet extends PaymentMethod {
  String walletName;
  String email;
  String password;

  DigitalWallet({
    required this.walletName,
    required this.email,
    required this.password,
  });

  @override
  String get name => walletName;

  @override
  String get icon => '📱';

  @override
  bool validate() {
    return email.contains('@') && password.length >= 6;
  }

  @override
  void processPayment(double amount) {
    if (!validate()) {
      print('❌ Invalid credentials');
      return;
    }

    print('$icon Connecting to $walletName...');
    print('Account: $email');
    print('Authorizing payment...');
    showReceipt(amount);
  }
}

class BankTransfer extends PaymentMethod {
  String accountNumber;
  String bankName;
  String routingNumber;

  BankTransfer({
    required this.accountNumber,
    required this.bankName,
    required this.routingNumber,
  });

  @override
  String get name => 'Bank Transfer';

  @override
  String get icon => '🏦';

  @override
  void processPayment(double amount) {
    print('$icon Initiating bank transfer...');
    print('Bank: $bankName');
    print('Account: ****${accountNumber.substring(accountNumber.length - 4)}');
    print('Routing: $routingNumber');
    print('⏳ Transfer pending (1-3 business days)');
    showReceipt(amount);
  }
}

// Enhanced Expense with payment
class Expense {
  String description;
  double amount;
  String category;
  DateTime date;
  PaymentMethod? paymentMethod;
  bool isPaid;

  Expense({
    required this.description,
    required this.amount,
    required this.category,
    DateTime? date,
  }) : date = date ?? DateTime.now(),
       isPaid = false;

  void payWith(PaymentMethod method) {
    print('\n${"═" * 40}');
    print('PROCESSING PAYMENT');
    print('${"═" * 40}');
    print('Expense: $description');
    print('Amount: \$${amount.toStringAsFixed(2)}');
    print('Category: $category');
    print('');

    method.processPayment(amount);
    paymentMethod = method;
    isPaid = true;
  }

  void printDetails() {
    String status = isPaid ? '✅ Paid' : '❌ Unpaid';
    String payment = paymentMethod != null 
        ? '${paymentMethod!.icon} ${paymentMethod!.name}' 
        : 'No payment method';

    print('$description: \$${amount.toStringAsFixed(2)} [$category]');
    print('Status: $status | Payment: $payment');
  }
}

void main() {
  print('💰 EXPENSE PAYMENT SYSTEM\n');

  // Create expenses
  var expenses = [
    Expense(description: 'Monthly rent', amount: 1200.0, category: 'Bills'),
    Expense(description: 'Groceries', amount: 127.50, category: 'Food'),
    Expense(description: 'Coffee', amount: 4.50, category: 'Food'),
    Expense(description: 'Laptop', amount: 899.99, category: 'Electronics'),
  ];

  // Create payment methods
  var creditCard = CreditCard(
    cardNumber: '4532123456789012',
    cardHolder: 'John Doe',
    expiryDate: '12/26',
    cvv: '123',
  );

  var debitCard = DebitCard(
    cardNumber: '5105105105105100',
    pin: '1234',
    balance: 5000.0,
  );

  var paypal = DigitalWallet(
    walletName: 'PayPal',
    email: 'john@example.com',
    password: 'secure123',
  );

  var cash = Cash();

  // Pay for expenses
  expenses[0].payWith(creditCard);
  expenses[1].payWith(debitCard);
  expenses[2].payWith(cash);
  expenses[3].payWith(paypal);

  // Summary
  print('\n${"═" * 40}');
  print('PAYMENT SUMMARY');
  print('${"═" * 40}\n');

  for (var expense in expenses) {
    expense.printDetails();
    print('');
  }
}

🎯 Practice Exercises

Exercise 1: Create Cryptocurrency Payment (Easy)

Create a Cryptocurrency payment method with:

Properties: walletAddress, coinType (e.g., "Bitcoin", "Ethereum")
Validate wallet address is not empty
Override all required methods

Solution:

class Cryptocurrency extends PaymentMethod {
  String walletAddress;
  String coinType;

  Cryptocurrency({
    required this.walletAddress,
    required this.coinType,
  });

  @override
  String get name => '$coinType Wallet';

  @override
  String get icon => '₿';

  @override
  bool validate() {
    return walletAddress.isNotEmpty && walletAddress.length > 20;
  }

  @override
  void processPayment(double amount) {
    if (!validate()) {
      print('❌ Invalid wallet address');
      return;
    }

    print('$icon Processing $coinType payment...');
    print('Wallet: ${walletAddress.substring(0, 6)}...${walletAddress.substring(walletAddress.length - 4)}');
    print('⏳ Waiting for blockchain confirmation...');
    showReceipt(amount);
  }
}

void main() {
  var btc = Cryptocurrency(
    walletAddress: '1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa',
    coinType: 'Bitcoin',
  );

  var expense = Expense(
    description: 'Online purchase',
    amount: 250.0,
    category: 'Shopping',
  );

  expense.payWith(btc);
}

Exercise 2: Refundable Interface (Medium)

Create a Refundable interface and implement it for payment methods that support refunds:

Solution:

abstract class Refundable {
  bool canRefund();
  void processRefund(double amount);
}

class CreditCard extends PaymentMethod implements Refundable {
  String cardNumber;
  String cardHolder;
  List<double> transactions = [];

  CreditCard(this.cardNumber, this.cardHolder);

  @override
  String get name => 'Credit Card';

  @override
  String get icon => '💳';

  @override
  void processPayment(double amount) {
    transactions.add(amount);
    print('$icon Charged \$${amount.toStringAsFixed(2)}');
    showReceipt(amount);
  }

  @override
  bool canRefund() {
    return transactions.isNotEmpty;
  }

  @override
  void processRefund(double amount) {
    if (!canRefund()) {
      print('❌ No transactions to refund');
      return;
    }

    print('🔄 Processing refund of \$${amount.toStringAsFixed(2)}');
    print('   Refund will appear in 3-5 business days');
    transactions.add(-amount);  // Negative for refund
  }
}

// Cash doesn't implement Refundable - can't refund cash!
class Cash extends PaymentMethod {
  @override
  String get name => 'Cash';

  @override
  String get icon => '💵';

  @override
  void processPayment(double amount) {
    print('$icon Cash payment: \$${amount.toStringAsFixed(2)}');
    showReceipt(amount);
  }
}

void main() {
  var card = CreditCard('4532123456789012', 'John Doe');
  var cash = Cash();

  card.processPayment(100.0);

  // Can refund credit card
  if (card is Refundable) {
    card.processRefund(50.0);
  }

  cash.processPayment(50.0);

  // Can't refund cash
  if (cash is Refundable) {
    cash.processRefund(25.0);
  } else {
    print('❌ Cash payments cannot be refunded');
  }
}

Exercise 3: Payment Gateway System (Hard)

Create an abstract PaymentGateway class and implement multiple gateways:

Solution:

abstract class PaymentGateway {
  String get gatewayName;
  double get transactionFee;

  bool authenticate(String apiKey);
  String processTransaction(double amount, PaymentMethod method);
  void logTransaction(String transactionId, double amount);
}

class StripeGateway extends PaymentGateway {
  String apiKey;
  List<Map<String, dynamic>> transactionLog = [];

  StripeGateway(this.apiKey);

  @override
  String get gatewayName => 'Stripe';

  @override
  double get transactionFee => 0.029;  // 2.9%

  @override
  bool authenticate(String key) {
    return key == apiKey && key.startsWith('sk_');
  }

  @override
  String processTransaction(double amount, PaymentMethod method) {
    if (!authenticate(apiKey)) {
      return 'AUTH_FAILED';
    }

    double fee = amount * transactionFee;
    double total = amount + fee;

    String transactionId = 'txn_${DateTime.now().millisecondsSinceEpoch}';

    print('\n🔵 Processing via $gatewayName');
    print('Amount: \$${amount.toStringAsFixed(2)}');
    print('Fee: \$${fee.toStringAsFixed(2)}');
    print('Total: \$${total.toStringAsFixed(2)}');
    print('Transaction ID: $transactionId');

    logTransaction(transactionId, total);
    return transactionId;
  }

  @override
  void logTransaction(String transactionId, double amount) {
    transactionLog.add({
      'id': transactionId,
      'amount': amount,
      'timestamp': DateTime.now(),
      'gateway': gatewayName,
    });
  }

  void printTransactionHistory() {
    print('\n📊 TRANSACTION HISTORY ($gatewayName)');
    for (var transaction in transactionLog) {
      print('${transaction['id']}: \$${transaction['amount'].toStringAsFixed(2)} at ${transaction['timestamp']}');
    }
  }
}

class PayPalGateway extends PaymentGateway {
  String email;
  String password;
  List<Map<String, dynamic>> transactionLog = [];

  PayPalGateway(this.email, this.password);

  @override
  String get gatewayName => 'PayPal';

  @override
  double get transactionFee => 0.034;  // 3.4%

  @override
  bool authenticate(String key) {
    return email.contains('@') && password.length >= 6;
  }

  @override
  String processTransaction(double amount, PaymentMethod method) {
    if (!authenticate(email)) {
      return 'AUTH_FAILED';
    }

    double fee = amount * transactionFee;
    double total = amount + fee;

    String transactionId = 'pp_${DateTime.now().millisecondsSinceEpoch}';

    print('\n🔷 Processing via $gatewayName');
    print('Account: $email');
    print('Amount: \$${amount.toStringAsFixed(2)}');
    print('Fee: \$${fee.toStringAsFixed(2)}');
    print('Total: \$${total.toStringAsFixed(2)}');
    print('Transaction ID: $transactionId');

    logTransaction(transactionId, total);
    return transactionId;
  }

  @override
  void logTransaction(String transactionId, double amount) {
    transactionLog.add({
      'id': transactionId,
      'amount': amount,
      'timestamp': DateTime.now(),
      'gateway': gatewayName,
    });
  }
}

void main() {
  var stripe = StripeGateway('sk_test_123456789');
  var paypal = PayPalGateway('merchant@example.com', 'password123');

  var card = CreditCard(
    cardNumber: '4532123456789012',
    cardHolder: 'John Doe',
    expiryDate: '12/26',
    cvv: '123',
  );

  // Process through different gateways
  stripe.processTransaction(100.0, card);
  stripe.processTransaction(250.0, card);

  paypal.processTransaction(75.0, card);

  // Show history
  if (stripe is StripeGateway) {
    stripe.printTransactionHistory();
  }
}

Common Mistakes & How to Fix Them

Mistake 1: Trying to Instantiate Abstract Class

// ❌ Wrong - can't create instance
var payment = PaymentMethod();

// ✅ Correct - use concrete class
var payment = CreditCard('1234567890123456', 'John');

Mistake 2: Not Implementing All Abstract Methods

// ❌ Wrong - missing processPayment implementation
class CreditCard extends PaymentMethod {
  String get name => 'Credit Card';
  // Forgot to implement processPayment!
}

// ✅ Correct - implement all abstract methods
class CreditCard extends PaymentMethod {
  String get name => 'Credit Card';

  @override
  void processPayment(double amount) {
    // Implementation
  }
}

Mistake 3: Using extends When You Mean implements

// ❌ Wrong - don't want to inherit implementation
class Report extends Printable {
  // Would need to inherit Printable's code
}

// ✅ Correct - just need the contract
class Report implements Printable {
  // Implement methods yourself
}

Mistake 4: Forgetting @override

// ❌ Wrong - typo goes unnoticed
class CreditCard extends PaymentMethod {
  void procesPayment(double amount) {  // Typo!
    // ...
  }
}

// ✅ Correct - compiler catches typo
class CreditCard extends PaymentMethod {
  @override
  void processPayment(double amount) {
    // ...
  }
}

Key Concepts Review

✅ Polymorphism - one interface, many implementations

✅ Abstract classes - templates that can't be instantiated

✅ Abstract methods - must be implemented by children

✅ Concrete methods - can exist in abstract classes

✅ implements - fulfill a contract without inheriting

✅ Multiple interfaces - class can implement many

✅ Type checking - use is keyword

✅ Abstract for shared code - use when classes are related

✅ Interfaces for contracts - use when classes are unrelated

Self-Check Questions

1. What's the difference between an abstract class and a regular class?

Answer:

Abstract class: Cannot be instantiated directly, can have abstract methods (no implementation), used as template
Regular class: Can be instantiated, all methods must have implementation

2. When should you use `extends` vs `implements`?

Answer:

extends: Use when you want to inherit both interface AND implementation (IS-A relationship)
implements: Use when you only need to fulfill a contract (HAS-A capability)
Can only extends one class, but can implements multiple interfaces

3. Why use abstract classes instead of regular inheritance?

Answer:
Abstract classes force child classes to implement certain methods, creating a contract. They ensure all children have required functionality while still allowing shared code through concrete methods.

Comparison Table

Feature	Abstract Class	Interface (implements)
Keyword	`abstract class`	Any class + `implements`
Can instantiate?	❌ No	❌ No
Concrete methods?	✅ Yes	❌ No (must implement all)
Abstract methods?	✅ Yes	✅ Yes (implicit)
Multiple inheritance?	❌ No (single)	✅ Yes (multiple)
Properties?	✅ Yes	Must implement
When to use?	Related classes	Unrelated capabilities

Real-World Architecture Example

Here's how everything fits together in a real expense app:

// 1. ABSTRACT CLASSES FOR RELATED TYPES
abstract class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  Expense(this.description, this.amount, this.category, this.date);

  void printDetails();  // Abstract
  bool isMajorExpense() => amount > 100;  // Concrete
}

class RecurringExpense extends Expense {
  String frequency;

  RecurringExpense(String desc, double amt, String cat, this.frequency)
    : super(desc, amt, cat, DateTime.now());

  @override
  void printDetails() {
    print('🔄 $description: \${amount.toStringAsFixed(2)} ($frequency)');
  }

  double yearlyTotal() {
    if (frequency == 'monthly') return amount * 12;
    if (frequency == 'weekly') return amount * 52;
    return amount;
  }
}

// 2. ABSTRACT CLASS FOR PAYMENT METHODS
abstract class PaymentMethod {
  String get name;
  void processPayment(double amount);
}

class CreditCard extends PaymentMethod {
  String cardNumber;

  CreditCard(this.cardNumber);

  @override
  String get name => 'Credit Card';

  @override
  void processPayment(double amount) {
    print('💳 Charged \${amount.toStringAsFixed(2)}');
  }
}

// 3. INTERFACES FOR CAPABILITIES
abstract class Refundable {
  bool canRefund();
  void processRefund(double amount);
}

abstract class Taxable {
  double calculateTax(double rate);
}

// 4. COMBINE EVERYTHING
class BusinessExpense extends Expense implements Taxable, Refundable {
  String client;
  PaymentMethod? paymentMethod;

  BusinessExpense(String desc, double amt, String cat, this.client)
    : super(desc, amt, cat, DateTime.now());

  @override
  void printDetails() {
    print('💼 $description for $client: \${amount.toStringAsFixed(2)}');
  }

  @override
  double calculateTax(double rate) {
    return amount * rate;
  }

  @override
  bool canRefund() {
    return paymentMethod != null;
  }

  @override
  void processRefund(double amount) {
    print('🔄 Refunding \${amount.toStringAsFixed(2)}');
  }

  void payWith(PaymentMethod method) {
    paymentMethod = method;
    method.processPayment(amount);
  }
}

void main() {
  var expense = BusinessExpense('Client lunch', 150.0, 'Meals', 'Acme Corp');

  expense.printDetails();

  var card = CreditCard('4532123456789012');
  expense.payWith(card);

  print('Tax (10%): \${expense.calculateTax(0.10).toStringAsFixed(2)}');

  if (expense.canRefund()) {
    expense.processRefund(50.0);
  }
}

Output:

💼 Client lunch for Acme Corp: $150.00
💳 Charged $150.00
Tax (10%): $15.00
🔄 Refunding $50.00

Design Patterns Using Abstract Classes

Factory Pattern

abstract class ExpenseFactory {
  Expense createExpense(String type, String desc, double amt, String cat);
}

class DefaultExpenseFactory extends ExpenseFactory {
  @override
  Expense createExpense(String type, String desc, double amt, String cat) {
    switch (type) {
      case 'recurring':
        return RecurringExpense(desc, amt, cat, 'monthly');
      case 'onetime':
        return OneTimeExpense(desc, amt, cat, DateTime.now(), 'other');
      default:
        return Expense(desc, amt, cat, DateTime.now());
    }
  }
}

void main() {
  var factory = DefaultExpenseFactory();

  var expense1 = factory.createExpense('recurring', 'Netflix', 15.99, 'Entertainment');
  var expense2 = factory.createExpense('onetime', 'Gift', 50.0, 'Personal');

  expense1.printDetails();
  expense2.printDetails();
}

Strategy Pattern

abstract class PaymentStrategy {
  void pay(double amount);
}

class CreditCardStrategy extends PaymentStrategy {
  @override
  void pay(double amount) {
    print('💳 Paying \${amount.toStringAsFixed(2)} with credit card');
  }
}

class CashStrategy extends PaymentStrategy {
  @override
  void pay(double amount) {
    print('💵 Paying \${amount.toStringAsFixed(2)} with cash');
  }
}

class Expense {
  String description;
  double amount;
  PaymentStrategy? paymentStrategy;

  Expense(this.description, this.amount);

  void setPaymentStrategy(PaymentStrategy strategy) {
    paymentStrategy = strategy;
  }

  void pay() {
    if (paymentStrategy != null) {
      print('Processing payment for: $description');
      paymentStrategy!.pay(amount);
    }
  }
}

void main() {
  var expense = Expense('Dinner', 75.0);

  expense.setPaymentStrategy(CreditCardStrategy());
  expense.pay();

  expense.setPaymentStrategy(CashStrategy());
  expense.pay();
}

What's Next?

In Lesson 9: Building the Complete Expense Manager App, we'll learn:

Putting all OOP concepts together
Building a complete command-line expense tracker
Organizing code into multiple files
Best practices for structuring Dart projects
Preparing for Flutter UI integration

Example preview:

📱 EXPENSE MANAGER v1.0

1. Add Expense
2. View All Expenses
3. View by Category
4. Monthly Report
5. Pay Expense
6. Exit

Choose an option: _

See you in Lesson 9! 🚀

Additional Resources

Practice Ideas:

Create a Subscription payment method that auto-pays monthly
Implement a RewardsCard that gives cashback
Build a PaymentProcessor that handles multiple gateways
Create Exportable interface for exporting data to CSV/JSON

Advanced Topics to Explore:

Mixins (combining behaviors without inheritance)
Extension methods
Generic types with abstract classes
Sealed classes (coming in future Dart versions)

Design Principles:

SOLID Principles - Especially Interface Segregation and Dependency Inversion
DRY (Don't Repeat Yourself) - Abstract classes help with this
Open/Closed - Open for extension, closed for modification

Final Project Challenge

Build a complete payment processing system with:

Requirements:

At least 5 different payment methods (abstract class)
Implement Refundable interface for 3 methods
Implement Recurring interface for subscription payments
Create PaymentGateway abstract class with 2 implementations
Handle payment failures gracefully
Log all transactions
Generate payment reports

Bonus Features:

Transaction history
Payment analytics (most used method, total fees, etc.)
Split payments (pay with multiple methods)
Scheduled payments for recurring expenses
Receipt generation

This will solidify all the abstract class and polymorphism concepts!

Summary

You've now learned:

✅ Polymorphism - treating different types uniformly

✅ Abstract classes - creating templates and contracts

✅ Interfaces - defining capabilities without inheritance

✅ Multiple interfaces - combining multiple capabilities

✅ Design patterns - factory, strategy using abstractions

✅ Real-world architecture - organizing code properly

Key Takeaway: Abstract classes and interfaces are tools for creating flexible, maintainable code. Use abstract classes when classes are related and share code. Use interfaces when defining capabilities across unrelated classes.

Congratulations! You've completed the core OOP lessons. You're now ready to build real applications with proper object-oriented design! 🎉

Next up: Putting it all together in a complete expense manager application!

Dart Object Oriented For Beginner : Expense Manager Case Study Part 7

Putra Prima A — Wed, 08 Oct 2025 22:49:43 +0000

Lesson 7: Inheritance - Different Types of Expenses

Duration: 45 minutes

App Feature: 🎨 Specialized Expense Types

What You'll Build: Create RecurringExpense and OneTimeExpense classes

Prerequisites: Complete Lessons 1-6

What We'll Learn Today

By the end of this lesson, you'll be able to:

✅ Understand what inheritance means
✅ Create child classes that extend parent classes
✅ Use the extends keyword
✅ Call parent constructors with super
✅ Override methods with @override
✅ Add specialized features to child classes
✅ Understand the "IS-A" relationship

Part 1: The Problem - All Expenses Are the Same

Currently, all our expenses are treated identically:

void main() {
  var coffee = Expense.quick('Coffee', 4.50, 'Food');
  var netflix = Expense.quick('Netflix subscription', 15.99, 'Entertainment');
  var birthday = Expense.quick('Birthday gift', 50.0, 'Gifts');

  // But these are fundamentally different!
  // Netflix repeats monthly
  // Birthday gift is one-time
  // Coffee is daily

  // We need a way to distinguish them!
}

The Problem:

Some expenses repeat (subscriptions, bills)
Some are one-time (gifts, emergency)
We want to calculate yearly costs for recurring expenses
We want to tag one-time expenses by occasion

The Solution: Create specialized expense types using inheritance!

Part 2: Understanding Inheritance

Inheritance lets you create new classes based on existing ones.

Real-World Analogy:

Think about vehicles:

🚗 Vehicle (Parent)
├── Has wheels
├── Has engine
├── Can drive()

   ├── 🚙 Car (Child)
   │   └── Everything from Vehicle PLUS:
   │       └── Has trunk
   │       └── Seats 4-5 people
   │
   ├── 🚚 Truck (Child)
   │   └── Everything from Vehicle PLUS:
   │       └── Has cargo bed
   │       └── Can tow()
   │
   └── 🏍️ Motorcycle (Child)
       └── Everything from Vehicle PLUS:
           └── Has 2 wheels (overrides parent)
           └── Can wheelie()

Key Points:

Car IS-A Vehicle (IS-A relationship)
Car inherits all properties and methods from Vehicle
Car can add its own properties and methods
Car can override inherited methods to change behavior

Part 3: Creating Your First Child Class

Let's create RecurringExpense that inherits from Expense:

// Parent class (what we already have)
class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  Expense(this.description, this.amount, this.category, this.date);

  void printDetails() {
    print('$description: \$${amount.toStringAsFixed(2)} [$category]');
  }

  bool isMajorExpense() => amount > 100;
}

// Child class - extends Expense
class RecurringExpense extends Expense {
  String frequency;  // New property!

  // Constructor
  RecurringExpense(
    String description,
    double amount,
    String category,
    this.frequency,
  ) : super(description, amount, category, DateTime.now());

  // New method specific to RecurringExpense
  double yearlyTotal() {
    if (frequency == 'monthly') return amount * 12;
    if (frequency == 'weekly') return amount * 52;
    if (frequency == 'daily') return amount * 365;
    return amount;  // yearly
  }
}

void main() {
  var netflix = RecurringExpense('Netflix', 15.99, 'Entertainment', 'monthly');

  // Can use methods from parent class
  netflix.printDetails();
  print('Is major? ${netflix.isMajorExpense()}');

  // Can use methods from child class
  print('Yearly cost: \$${netflix.yearlyTotal().toStringAsFixed(2)}');
}

Output:

Netflix: $15.99 [Entertainment]
Is major? false
Yearly cost: $191.88

Part 4: Understanding the Syntax

Let's break down the child class syntax:

class RecurringExpense extends Expense {

extends keyword means RecurringExpense inherits from Expense
RecurringExpense is the child (or subclass)
Expense is the parent (or superclass)

String frequency;  // New property

Child classes can add their own properties
This property doesn't exist in the parent

RecurringExpense(
  String description,
  double amount,
  String category,
  this.frequency,
) : super(description, amount, category, DateTime.now());

super(...) calls the parent constructor
Must pass required values to parent
Can also initialize child properties

double yearlyTotal() { ... }

New method that only exists in RecurringExpense
Parent class doesn't have this method

Part 5: Overriding Methods

Child classes can override parent methods to change their behavior:

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  Expense(this.description, this.amount, this.category, this.date);

  void printDetails() {
    print('$description: \$${amount.toStringAsFixed(2)} [$category]');
  }
}

class RecurringExpense extends Expense {
  String frequency;

  RecurringExpense(
    String description,
    double amount,
    String category,
    this.frequency,
  ) : super(description, amount, category, DateTime.now());

  // Override parent method
  @override
  void printDetails() {
    print('🔄 RECURRING ($frequency)');
    super.printDetails();  // Call parent version
    print('Yearly: \$${yearlyTotal().toStringAsFixed(2)}');
  }

  double yearlyTotal() {
    if (frequency == 'monthly') return amount * 12;
    if (frequency == 'weekly') return amount * 52;
    return amount;
  }
}

void main() {
  var regular = Expense('Coffee', 4.50, 'Food', DateTime.now());
  var netflix = RecurringExpense('Netflix', 15.99, 'Entertainment', 'monthly');

  print('Regular expense:');
  regular.printDetails();

  print('\nRecurring expense:');
  netflix.printDetails();
}

Output:

Regular expense:
Coffee: $4.50 [Food]

Recurring expense:
🔄 RECURRING (monthly)
Netflix: $15.99 [Entertainment]
Yearly: $191.88

Understanding @override:

@override
void printDetails() {

@override annotation tells Dart you're intentionally overriding
Not required, but highly recommended (helps catch typos)
super.printDetails() calls the parent version

Part 6: Creating Multiple Child Classes

Let's create another child class for one-time expenses:

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  Expense(this.description, this.amount, this.category, this.date);

  void printDetails() {
    print('$description: \$${amount.toStringAsFixed(2)} [$category]');
  }

  String getSummary() => '$description: \$${amount.toStringAsFixed(2)}';
}

class RecurringExpense extends Expense {
  String frequency;

  RecurringExpense(
    String description,
    double amount,
    String category,
    this.frequency,
  ) : super(description, amount, category, DateTime.now());

  @override
  void printDetails() {
    print('🔄 RECURRING ($frequency)');
    super.printDetails();
    print('   Yearly total: \$${yearlyTotal().toStringAsFixed(2)}');
  }

  double yearlyTotal() {
    if (frequency == 'monthly') return amount * 12;
    if (frequency == 'weekly') return amount * 52;
    if (frequency == 'daily') return amount * 365;
    return amount;
  }
}

class OneTimeExpense extends Expense {
  String occasion;  // 'birthday', 'emergency', 'vacation', etc.

  OneTimeExpense(
    String description,
    double amount,
    String category,
    DateTime date,
    this.occasion,
  ) : super(description, amount, category, date);

  @override
  void printDetails() {
    print('🎯 ONE-TIME ($occasion)');
    super.printDetails();
  }

  bool isSpecialOccasion() {
    return occasion == 'birthday' || 
           occasion == 'anniversary' || 
           occasion == 'holiday';
  }
}

void main() {
  var expenses = [
    Expense('Coffee', 4.50, 'Food', DateTime.now()),
    RecurringExpense('Netflix', 15.99, 'Entertainment', 'monthly'),
    OneTimeExpense('Birthday gift', 75.0, 'Gifts', DateTime.now(), 'birthday'),
    RecurringExpense('Gym', 45.0, 'Health', 'monthly'),
    OneTimeExpense('Car repair', 350.0, 'Transport', DateTime.now(), 'emergency'),
  ];

  print('ALL EXPENSES:\n');
  for (var expense in expenses) {
    expense.printDetails();
    print('');
  }
}

Output:

ALL EXPENSES:

Coffee: $4.50 [Food]

🔄 RECURRING (monthly)
Netflix: $15.99 [Entertainment]
   Yearly total: $191.88

🎯 ONE-TIME (birthday)
Birthday gift: $75.00 [Gifts]

🔄 RECURRING (monthly)
Gym: $45.00 [Health]
   Yearly total: $540.00

🎯 ONE-TIME (emergency)
Car repair: $350.00 [Transport]

Part 7: Polymorphism - Treating Different Types Uniformly

Polymorphism means "many forms" - you can treat different types the same way:

void main() {
  // All three types in one list!
  List<Expense> expenses = [
    Expense('Coffee', 4.50, 'Food', DateTime.now()),
    RecurringExpense('Spotify', 9.99, 'Entertainment', 'monthly'),
    OneTimeExpense('Concert', 85.0, 'Entertainment', DateTime.now(), 'fun'),
  ];

  // Same method call, different behavior!
  for (var expense in expenses) {
    expense.printDetails();  // Each type prints differently
    print('');
  }

  // Can check type and use specific features
  for (var expense in expenses) {
    if (expense is RecurringExpense) {
      print('${expense.description} costs \$${expense.yearlyTotal().toStringAsFixed(2)}/year');
    }

    if (expense is OneTimeExpense) {
      print('${expense.description} is for: ${expense.occasion}');
    }
  }
}

Key Points:

List<Expense> can hold any type of Expense (parent or children)
Each object responds to printDetails() based on its actual type
Use is keyword to check the type
Can cast to child type to access child-specific features

Part 8: Complete Example with ExpenseManager

Let's update our ExpenseManager to work with different expense types:

class ExpenseManager {
  List<Expense> _expenses = [];

  void addExpense(Expense expense) {
    _expenses.add(expense);
  }

  List<Expense> getAllExpenses() => List.from(_expenses);

  // Get only recurring expenses
  List<RecurringExpense> getRecurringExpenses() {
    List<RecurringExpense> recurring = [];
    for (var expense in _expenses) {
      if (expense is RecurringExpense) {
        recurring.add(expense);
      }
    }
    return recurring;
  }

  // Get only one-time expenses
  List<OneTimeExpense> getOneTimeExpenses() {
    List<OneTimeExpense> oneTime = [];
    for (var expense in _expenses) {
      if (expense is OneTimeExpense) {
        oneTime.add(expense);
      }
    }
    return oneTime;
  }

  // Calculate yearly cost of all recurring expenses
  double getYearlyRecurringCost() {
    double total = 0;
    for (var expense in getRecurringExpenses()) {
      total += expense.yearlyTotal();
    }
    return total;
  }

  // Get count of each type
  Map<String, int> getTypeCounts() {
    int regular = 0;
    int recurring = 0;
    int oneTime = 0;

    for (var expense in _expenses) {
      if (expense is RecurringExpense) {
        recurring++;
      } else if (expense is OneTimeExpense) {
        oneTime++;
      } else {
        regular++;
      }
    }

    return {
      'regular': regular,
      'recurring': recurring,
      'oneTime': oneTime,
    };
  }

  void printSummary() {
    print('\n═══════════════════════════════════');
    print('💰 EXPENSE SUMMARY');
    print('═══════════════════════════════════');

    var counts = getTypeCounts();
    print('Total expenses: ${_expenses.length}');
    print('  Regular: ${counts['regular']}');
    print('  Recurring: ${counts['recurring']}');
    print('  One-time: ${counts['oneTime']}');

    double total = 0;
    for (var expense in _expenses) {
      total += expense.amount;
    }
    print('\nTotal spent: \$${total.toStringAsFixed(2)}');

    double yearlyRecurring = getYearlyRecurringCost();
    print('Yearly recurring: \$${yearlyRecurring.toStringAsFixed(2)}');

    print('═══════════════════════════════════\n');
  }

  void printAllExpenses() {
    print('ALL EXPENSES:\n');
    for (var expense in _expenses) {
      expense.printDetails();
      print('');
    }
  }
}

void main() {
  var manager = ExpenseManager();

  // Add different types of expenses
  manager.addExpense(Expense('Coffee', 4.50, 'Food', DateTime.now()));
  manager.addExpense(RecurringExpense('Netflix', 15.99, 'Entertainment', 'monthly'));
  manager.addExpense(OneTimeExpense('Birthday gift', 75.0, 'Gifts', DateTime.now(), 'birthday'));
  manager.addExpense(RecurringExpense('Gym', 45.0, 'Health', 'monthly'));
  manager.addExpense(OneTimeExpense('Car repair', 350.0, 'Transport', DateTime.now(), 'emergency'));
  manager.addExpense(Expense('Lunch', 12.50, 'Food', DateTime.now()));

  manager.printSummary();
  manager.printAllExpenses();

  print('🔄 RECURRING EXPENSES BREAKDOWN:');
  for (var expense in manager.getRecurringExpenses()) {
    print('${expense.description}: \$${expense.amount}/${expense.frequency}');
    print('   → \$${expense.yearlyTotal().toStringAsFixed(2)}/year');
  }
}

🎯 Practice Exercises

Exercise 1: Create BusinessExpense Class (Easy)

Create a BusinessExpense class that extends Expense with:

Property: client (String)
Property: isReimbursable (bool)
Override printDetails() to show client and reimbursable status

Solution:

class BusinessExpense extends Expense {
  String client;
  bool isReimbursable;

  BusinessExpense({
    required String description,
    required double amount,
    required String category,
    required this.client,
    this.isReimbursable = true,
  }) : super(description, amount, category, DateTime.now());

  @override
  void printDetails() {
    print('💼 BUSINESS EXPENSE');
    super.printDetails();
    print('   Client: $client');
    print('   Reimbursable: ${isReimbursable ? "Yes ✅" : "No ❌"}');
  }
}

void main() {
  var expense = BusinessExpense(
    description: 'Client lunch',
    amount: 85.0,
    category: 'Meals',
    client: 'Acme Corp',
    isReimbursable: true,
  );

  expense.printDetails();
}

Exercise 2: Create TravelExpense Class (Medium)

Create a TravelExpense class with:

Properties: destination, tripDuration (days)
Method: getDailyCost() - returns amount per day
Method: isInternational() - returns true if destination is outside country
Override printDetails()

Solution:

class TravelExpense extends Expense {
  String destination;
  int tripDuration;

  TravelExpense({
    required String description,
    required double amount,
    required this.destination,
    required this.tripDuration,
    DateTime? date,
  }) : super(description, amount, 'Travel', date ?? DateTime.now());

  double getDailyCost() {
    if (tripDuration == 0) return amount;
    return amount / tripDuration;
  }

  bool isInternational() {
    // Simple check - could be improved with a country list
    return destination.contains('Japan') || 
           destination.contains('USA') || 
           destination.contains('Europe');
  }

  @override
  void printDetails() {
    print('✈️ TRAVEL EXPENSE');
    super.printDetails();
    print('   Destination: $destination');
    print('   Duration: $tripDuration days');
    print('   Daily cost: \$${getDailyCost().toStringAsFixed(2)}');
    print('   International: ${isInternational() ? "Yes 🌍" : "No 🏠"}');
  }
}

void main() {
  var trip = TravelExpense(
    description: 'Tokyo vacation',
    amount: 2500.0,
    destination: 'Tokyo, Japan',
    tripDuration: 7,
  );

  trip.printDetails();
}

Exercise 3: Subscription Management System (Hard)

Create a SubscriptionExpense class that extends RecurringExpense with:

Properties: provider, plan, startDate, endDate
Method: isActive() - checks if subscription is currently active
Method: getRemainingMonths() - months until expiration
Method: getTotalCost() - total cost from start to end date
Override printDetails()

Solution:

class SubscriptionExpense extends RecurringExpense {
  String provider;
  String plan;
  DateTime startDate;
  DateTime? endDate;

  SubscriptionExpense({
    required String description,
    required double amount,
    required this.provider,
    required this.plan,
    required this.startDate,
    this.endDate,
  }) : super(description, amount, 'Subscriptions', 'monthly');

  bool isActive() {
    DateTime now = DateTime.now();
    if (endDate == null) return true;  // No end date = active
    return now.isBefore(endDate!);
  }

  int getRemainingMonths() {
    if (endDate == null) return -1;  // Unlimited
    DateTime now = DateTime.now();
    if (now.isAfter(endDate!)) return 0;

    int months = (endDate!.year - now.year) * 12 + 
                 (endDate!.month - now.month);
    return months;
  }

  double getTotalCost() {
    if (endDate == null) {
      // If no end date, calculate for 1 year
      return yearlyTotal();
    }

    int months = (endDate!.year - startDate.year) * 12 + 
                 (endDate!.month - startDate.month);
    return amount * months;
  }

  @override
  void printDetails() {
    print('📱 SUBSCRIPTION');
    print('$description ($provider - $plan)');
    print('Amount: \$${amount.toStringAsFixed(2)}/month');
    print('Started: ${startDate.toString().split(' ')[0]}');

    if (endDate != null) {
      print('Expires: ${endDate.toString().split(' ')[0]}');
      print('Remaining: ${getRemainingMonths()} months');
    } else {
      print('Expires: Never (ongoing)');
    }

    print('Status: ${isActive() ? "Active ✅" : "Expired ❌"}');
    print('Total cost: \$${getTotalCost().toStringAsFixed(2)}');
  }
}

void main() {
  var netflix = SubscriptionExpense(
    description: 'Netflix Premium',
    amount: 19.99,
    provider: 'Netflix',
    plan: 'Premium 4K',
    startDate: DateTime(2024, 1, 1),
    endDate: null,  // Ongoing
  );

  var trial = SubscriptionExpense(
    description: 'Adobe Creative Cloud',
    amount: 54.99,
    provider: 'Adobe',
    plan: 'All Apps',
    startDate: DateTime(2025, 9, 1),
    endDate: DateTime(2025, 12, 31),
  );

  netflix.printDetails();
  print('');
  trial.printDetails();
}

Common Mistakes & How to Fix Them

Mistake 1: Forgetting to Call super()

// ❌ Wrong - parent constructor not called
class RecurringExpense extends Expense {
  String frequency;

  RecurringExpense(String desc, double amt, String cat, this.frequency);
}

// ✅ Correct - call parent constructor
class RecurringExpense extends Expense {
  String frequency;

  RecurringExpense(String desc, double amt, String cat, this.frequency)
    : super(desc, amt, cat, DateTime.now());
}

Mistake 2: Wrong Parameter Order in super()

// ❌ Wrong - parameters in wrong order
RecurringExpense(String desc, double amt, String cat, this.frequency)
  : super(cat, amt, desc, DateTime.now());  // Wrong order!

// ✅ Correct - match parent constructor signature
RecurringExpense(String desc, double amt, String cat, this.frequency)
  : super(desc, amt, cat, DateTime.now());

Mistake 3: Not Using @override

// ❌ Wrong - typo in method name, no error!
class RecurringExpense extends Expense {
  void printDetail() {  // Missing 's' - creates new method instead of overriding
    print('Details...');
  }
}

// ✅ Correct - @override catches typos
class RecurringExpense extends Expense {
  @override
  void printDetails() {  // Compiler checks this matches parent
    print('Details...');
  }
}

Mistake 4: Trying to Access Private Parent Properties

class Expense {
  String _description;  // Private
  // ...
}

class RecurringExpense extends Expense {
  @override
  void printDetails() {
    print(_description);  // ❌ Error! Can't access private property
  }
}

// ✅ Correct - use getter or make property protected
class Expense {
  String description;  // Public or protected
  // ...
}

class RecurringExpense extends Expense {
  @override
  void printDetails() {
    print(description);  // ✅ Works!
  }
}

Key Concepts Review

✅ Inheritance lets you create specialized classes based on existing ones

✅ extends keyword creates child class from parent

✅ super() calls the parent constructor

✅ @override marks methods that replace parent methods

✅ IS-A relationship - child IS-A type of parent

✅ Polymorphism - treat different types uniformly

✅ Child classes inherit all parent properties and methods

✅ Child classes can add new properties and methods

✅ Use is keyword to check object type

Self-Check Questions

1. What's the difference between inheritance and composition?

Answer:

Inheritance (IS-A): RecurringExpense IS-A Expense - creates specialized versions
Composition (HAS-A): ExpenseManager HAS-A list of Expenses - contains other objects

2. When should you use inheritance?

Answer:
Use inheritance when:

You have a clear IS-A relationship
Child needs most/all of parent's features
You want to treat different types uniformly (polymorphism)
You're specializing behavior, not completely changing it

3. What does @override do?

Answer:
@override tells the compiler you're intentionally replacing a parent method. It helps catch typos - if the method doesn't exist in parent, you'll get an error.

What's Next?

In Lesson 8: Polymorphism Deep Dive, we'll learn:

Working with mixed lists of different types
Type checking and casting
Abstract classes (contracts that child classes must follow)
Interfaces with implements
When to use inheritance vs interfaces

Example preview:

abstract class Payable {
  void processPayment();
}

class RecurringExpense extends Expense implements Payable {
  @override
  void processPayment() {
    // Auto-pay logic
  }
}

See you in Lesson 8! 🚀

Additional Resources

Try creating more specialized expense types (GiftExpense, EmergencyExpense, etc.)
Think about what makes each type unique
Practice using polymorphism with mixed lists
Consider when inheritance makes sense vs when it doesn't

Remember: Use inheritance to model IS-A relationships and create specialized versions of existing classes. Don't force it where it doesn't fit naturally! 🌳

Dart Object Oriented For Beginner : Expense Manager Case Study Part 6

Putra Prima A — Wed, 08 Oct 2025 22:49:31 +0000

Lesson 6: Managing Multiple Expenses

Duration: 40 minutes

App Feature: 📊 Creating an Expense Manager

What You'll Build: A class to manage all your expenses together

Prerequisites: Complete Lessons 1-5

What We'll Learn Today

By the end of this lesson, you'll be able to:

✅ Create a manager class to handle collections of objects
✅ Work with Lists of expenses
✅ Add, remove, and update expenses
✅ Filter expenses by various criteria
✅ Calculate totals and statistics
✅ Generate reports from multiple expenses
✅ Sort expenses in different ways

Part 1: Introduction to Collections

Before we build the ExpenseManager, let's understand Lists:

void main() {
  var manager = ExpenseManager();

  // Add expenses
  manager.addExpense(Expense.quick('Groceries', 127.50, 'Food'));
  manager.addExpense(Expense.quick('Coffee', 4.50, 'Food'));
  manager.addExpense(Expense.quick('Dinner', 45.00, 'Food'));
  manager.addExpense(Expense.quick('Gas', 60.00, 'Transport'));

  // Set budgets
  manager.setBudget('Food', 150.0);
  manager.setBudget('Transport', 100.0);

  // Check budget status
  manager.printBudgetReport();
}

Exercise 3: Advanced Analytics (Hard)

Add these advanced methods:

getTopExpenses(int n) - return top N most expensive expenses
getCategoryTrend(String category, int days) - return daily average for category over last N days
predictMonthlyTotal() - predict month total based on current spending rate

Solution:

class ExpenseManager {
  List<Expense> _expenses = [];

  List<Expense> getTopExpenses(int n) {
    List<Expense> sorted = sortByAmountDesc();
    if (n >= sorted.length) return sorted;
    return sorted.sublist(0, n);
  }

  double getCategoryTrend(String category, int days) {
    DateTime cutoff = DateTime.now().subtract(Duration(days: days));
    var recentExpenses = _expenses.where((e) {
      return e.category == category && e.date.isAfter(cutoff);
    }).toList();

    if (recentExpenses.isEmpty) return 0;

    double total = recentExpenses.fold(0.0, (sum, e) => sum + e.amount);
    return total / days;
  }

  double predictMonthlyTotal() {
    if (_expenses.isEmpty) return 0;

    DateTime now = DateTime.now();
    var thisMonthExpenses = _expenses.where((e) {
      return e.date.year == now.year && e.date.month == now.month;
    }).toList();

    if (thisMonthExpenses.isEmpty) return 0;

    double totalSoFar = thisMonthExpenses.fold(0.0, (sum, e) => sum + e.amount);
    int daysPassed = now.day;
    int daysInMonth = DateTime(now.year, now.month + 1, 0).day;

    double dailyAverage = totalSoFar / daysPassed;
    return dailyAverage * daysInMonth;
  }

  Map<String, double> getCategoryTrends(int days) {
    Map<String, double> trends = {};
    var categories = getAllCategories();

    for (var category in categories) {
      trends[category] = getCategoryTrend(category, days);
    }

    return trends;
  }

  void printTrendReport(int days) {
    print('\n📈 SPENDING TRENDS (Last $days days)\n');
    var trends = getCategoryTrends(days);

    trends.forEach((category, dailyAvg) {
      double monthlyProjection = dailyAvg * 30;
      print('$category:');
      print('  Daily average: \${dailyAvg.toStringAsFixed(2)}');
      print('  Monthly projection: \${monthlyProjection.toStringAsFixed(2)}');
      print('');
    });

    print('💡 Predicted month total: \${predictMonthlyTotal().toStringAsFixed(2)}');
  }
}

void main() {
  var manager = ExpenseManager();

  // Add expenses spread over 15 days
  for (int i = 0; i < 15; i++) {
    var date = DateTime.now().subtract(Duration(days: i));
    manager.addExpense(Expense(
      description: 'Daily expense $i',
      amount: 10.0 + (i * 2),
      category: i % 2 == 0 ? 'Food' : 'Transport',
      date: date,
    ));
  }

  print('🏆 TOP 5 EXPENSES:');
  var top5 = manager.getTopExpenses(5);
  for (int i = 0; i < top5.length; i++) {
    print('${i + 1}. ${top5[i].description} - \${top5[i].amount}');
  }

  manager.printTrendReport(15);
}

Common Mistakes & How to Fix Them

Mistake 1: Modifying Original List

// ❌ Wrong - returns reference to internal list
List<Expense> getAllExpenses() {
  return _expenses;  // Can be modified by caller!
}

// ✅ Correct - return a copy
List<Expense> getAllExpenses() {
  return List.from(_expenses);
}

Mistake 2: Not Checking for Empty Lists

// ❌ Wrong - will crash if empty
Expense getLargestExpense() {
  return _expenses[0];  // Error if empty!
}

// ✅ Correct - check first
Expense? getLargestExpense() {
  if (_expenses.isEmpty) return null;
  return _expenses.reduce((a, b) => a.amount > b.amount ? a : b);
}

Mistake 3: Inefficient Filtering

// ❌ Wrong - creates multiple loops
List<Expense> getThisMonthFood() {
  var thisMonth = getThisMonth();
  List<Expense> food = [];
  for (var e in thisMonth) {
    if (e.category == 'Food') food.add(e);
  }
  return food;
}

// ✅ Correct - one pass
List<Expense> getThisMonthFood() {
  return _expenses.where((e) => 
    e.isThisMonth() && e.category == 'Food'
  ).toList();
}

Mistake 4: Not Validating Indices

// ❌ Wrong - no validation
void removeAt(int index) {
  _expenses.removeAt(index);  // Crash if invalid!
}

// ✅ Correct - check bounds
bool removeAt(int index) {
  if (index < 0 || index >= _expenses.length) {
    return false;
  }
  _expenses.removeAt(index);
  return true;
}

Key Concepts Review

✅ Manager classes handle collections of objects

✅ List operations add, remove, filter, sort data

✅ Filter methods return subsets based on criteria

✅ Statistics methods calculate totals, averages, etc.

✅ Sort methods order data in different ways

✅ Report methods display information clearly

✅ Always return copies of internal lists to protect data

✅ Check for empty lists before operations

Self-Check Questions

1. Why should getAllExpenses() return a copy of the list instead of the original?

Answer:
Returning a copy protects the internal list from being modified by external code. If you return the original list, callers can add/remove items directly, bypassing your manager's control and validation.

2. What's the difference between filter methods and sort methods?

Answer:

Filter methods: Return a subset of expenses that meet certain criteria (e.g., only Food expenses)
Sort methods: Return all expenses but in a different order (e.g., sorted by amount)

3. When should you use `where()` vs a for loop for filtering?

Answer:
Use where() when possible - it's more concise and functional. Use a for loop when you need more complex logic or need to modify items during iteration.

What's Next?

In Lesson 7: Inheritance - Different Types of Expenses, we'll learn:

Creating specialized expense types
RecurringExpense class (monthly bills, subscriptions)
OneTimeExpense class (special occasions)
Using inheritance to reuse code
The "IS-A" relationship

Example preview:

class RecurringExpense extends Expense {
  String frequency;  // 'weekly', 'monthly', 'yearly'

  double yearlyTotal() {
    if (frequency == 'monthly') return amount * 12;
    if (frequency == 'weekly') return amount * 52;
    return amount;
  }
}

See you in Lesson 7! 🚀

Additional Resources

Practice adding more filter methods for different scenarios
Try implementing a search feature that searches across all fields
Experiment with different sorting combinations
Think about what reports would be useful for your expense app

Remember: The ExpenseManager is the brain of your app - it organizes, analyzes, and presents your data. Make it smart and efficient! 💡

Part 1: Introduction to Collections

Before we build the ExpenseManager, let's understand Lists:

void main() {
  // Creating a list of expenses
  List<Expense> expenses = [];

  // Adding expenses
  expenses.add(Expense.quick('Coffee', 4.50, 'Food'));
  expenses.add(Expense.quick('Lunch', 12.75, 'Food'));
  expenses.add(Expense.quick('Gas', 45.00, 'Transport'));

  // Accessing expenses
  print('First expense: ${expenses[0].description}');
  print('Total count: ${expenses.length}');

  // Looping through expenses
  print('\nAll expenses:');
  for (var expense in expenses) {
    print(expense.getSummary());
  }

  // Removing an expense
  expenses.removeAt(1);  // Remove lunch
  print('\nAfter removing lunch: ${expenses.length} expenses');
}

Key List Operations:

add(item) - Add to end
insert(index, item) - Add at specific position
removeAt(index) - Remove by position
remove(item) - Remove by value
clear() - Remove all
length - Get count
[] - Access by index

Part 2: Basic ExpenseManager Class

Let's create our first version:

class ExpenseManager {
  // Private list to store all expenses
  List<Expense> _expenses = [];

  // Add an expense
  void addExpense(Expense expense) {
    _expenses.add(expense);
    print('✅ Added: ${expense.description}');
  }

  // Get all expenses (return a copy to protect internal list)
  List<Expense> getAllExpenses() {
    return List.from(_expenses);
  }

  // Get total number of expenses
  int getCount() {
    return _expenses.length;
  }

  // Calculate total spending
  double getTotalSpending() {
    double total = 0;
    for (var expense in _expenses) {
      total += expense.amount;
    }
    return total;
  }

  // Print a simple summary
  void printSummary() {
    print('\n💰 EXPENSE SUMMARY');
    print('Total expenses: ${getCount()}');
    print('Total spent: \$${getTotalSpending().toStringAsFixed(2)}');
  }
}

void main() {
  var manager = ExpenseManager();

  manager.addExpense(Expense.quick('Coffee', 4.50, 'Food'));
  manager.addExpense(Expense.quick('Uber', 12.00, 'Transport'));
  manager.addExpense(Expense.quick('Lunch', 15.75, 'Food'));

  manager.printSummary();

  print('\nAll expenses:');
  for (var expense in manager.getAllExpenses()) {
    print(expense.getSummary());
  }
}

Output:

✅ Added: Coffee
✅ Added: Uber
✅ Added: Lunch

💰 EXPENSE SUMMARY
Total expenses: 3
Total spent: $32.25

All expenses:
🟢 Coffee: $4.50 [Food]
🟢 Uber: $12.00 [Transport]
🟢 Lunch: $15.75 [Food]

Part 3: Filtering Expenses

Add methods to filter expenses by different criteria:

class ExpenseManager {
  List<Expense> _expenses = [];

  void addExpense(Expense expense) {
    _expenses.add(expense);
  }

  List<Expense> getAllExpenses() => List.from(_expenses);

  // Filter by category
  List<Expense> getByCategory(String category) {
    List<Expense> filtered = [];
    for (var expense in _expenses) {
      if (expense.category == category) {
        filtered.add(expense);
      }
    }
    return filtered;
  }

  // Filter by amount range
  List<Expense> getByAmountRange(double min, double max) {
    List<Expense> filtered = [];
    for (var expense in _expenses) {
      if (expense.amount >= min && expense.amount <= max) {
        filtered.add(expense);
      }
    }
    return filtered;
  }

  // Get major expenses only
  List<Expense> getMajorExpenses() {
    List<Expense> filtered = [];
    for (var expense in _expenses) {
      if (expense.isMajorExpense()) {
        filtered.add(expense);
      }
    }
    return filtered;
  }

  // Get this month's expenses
  List<Expense> getThisMonth() {
    List<Expense> filtered = [];
    for (var expense in _expenses) {
      if (expense.isThisMonth()) {
        filtered.add(expense);
      }
    }
    return filtered;
  }

  // Get paid/unpaid expenses
  List<Expense> getPaidExpenses() {
    List<Expense> filtered = [];
    for (var expense in _expenses) {
      if (expense.isPaid) {
        filtered.add(expense);
      }
    }
    return filtered;
  }

  List<Expense> getUnpaidExpenses() {
    List<Expense> filtered = [];
    for (var expense in _expenses) {
      if (!expense.isPaid) {
        filtered.add(expense);
      }
    }
    return filtered;
  }
}

void main() {
  var manager = ExpenseManager();

  manager.addExpense(Expense(description: 'Coffee', amount: 4.50, category: 'Food'));
  manager.addExpense(Expense(description: 'Rent', amount: 1200.0, category: 'Bills', isPaid: true));
  manager.addExpense(Expense(description: 'Laptop', amount: 899.99, category: 'Electronics'));
  manager.addExpense(Expense(description: 'Lunch', amount: 15.75, category: 'Food'));

  print('FOOD EXPENSES:');
  for (var expense in manager.getByCategory('Food')) {
    print(expense.getSummary());
  }

  print('\nMAJOR EXPENSES (>$100):');
  for (var expense in manager.getMajorExpenses()) {
    print(expense.getSummary());
  }

  print('\nUNPAID EXPENSES:');
  for (var expense in manager.getUnpaidExpenses()) {
    print(expense.getSummary());
  }
}

Part 4: Advanced Statistics

Add methods to calculate useful statistics:

class ExpenseManager {
  List<Expense> _expenses = [];

  void addExpense(Expense expense) => _expenses.add(expense);

  // Total spending
  double getTotalSpending() {
    double total = 0;
    for (var expense in _expenses) {
      total += expense.amount;
    }
    return total;
  }

  // Total by category
  double getTotalByCategory(String category) {
    double total = 0;
    for (var expense in _expenses) {
      if (expense.category == category) {
        total += expense.amount;
      }
    }
    return total;
  }

  // Average expense amount
  double getAverageExpense() {
    if (_expenses.isEmpty) return 0;
    return getTotalSpending() / _expenses.length;
  }

  // Largest expense
  Expense? getLargestExpense() {
    if (_expenses.isEmpty) return null;

    Expense largest = _expenses[0];
    for (var expense in _expenses) {
      if (expense.amount > largest.amount) {
        largest = expense;
      }
    }
    return largest;
  }

  // Smallest expense
  Expense? getSmallestExpense() {
    if (_expenses.isEmpty) return null;

    Expense smallest = _expenses[0];
    for (var expense in _expenses) {
      if (expense.amount < smallest.amount) {
        smallest = expense;
      }
    }
    return smallest;
  }

  // Count by category
  int countByCategory(String category) {
    int count = 0;
    for (var expense in _expenses) {
      if (expense.category == category) {
        count++;
      }
    }
    return count;
  }

  // Get all unique categories
  List<String> getAllCategories() {
    List<String> categories = [];
    for (var expense in _expenses) {
      if (!categories.contains(expense.category)) {
        categories.add(expense.category);
      }
    }
    return categories;
  }

  // Total unpaid amount
  double getTotalUnpaid() {
    double total = 0;
    for (var expense in _expenses) {
      if (!expense.isPaid) {
        total += expense.amount;
      }
    }
    return total;
  }

  // Get category breakdown (map of category -> total)
  Map<String, double> getCategoryBreakdown() {
    Map<String, double> breakdown = {};
    for (var expense in _expenses) {
      if (breakdown.containsKey(expense.category)) {
        breakdown[expense.category] = breakdown[expense.category]! + expense.amount;
      } else {
        breakdown[expense.category] = expense.amount;
      }
    }
    return breakdown;
  }
}

void main() {
  var manager = ExpenseManager();

  manager.addExpense(Expense(description: 'Coffee', amount: 4.50, category: 'Food'));
  manager.addExpense(Expense(description: 'Rent', amount: 1200.0, category: 'Bills', isPaid: true));
  manager.addExpense(Expense(description: 'Laptop', amount: 899.99, category: 'Electronics'));
  manager.addExpense(Expense(description: 'Lunch', amount: 15.75, category: 'Food'));
  manager.addExpense(Expense(description: 'Gas', amount: 45.00, category: 'Transport'));

  print('📊 STATISTICS:\n');
  print('Total spending: \$${manager.getTotalSpending().toStringAsFixed(2)}');
  print('Average expense: \$${manager.getAverageExpense().toStringAsFixed(2)}');
  print('Total unpaid: \$${manager.getTotalUnpaid().toStringAsFixed(2)}');

  var largest = manager.getLargestExpense();
  if (largest != null) {
    print('Largest: ${largest.description} - \$${largest.amount}');
  }

  var smallest = manager.getSmallestExpense();
  if (smallest != null) {
    print('Smallest: ${smallest.description} - \$${smallest.amount}');
  }

  print('\n📁 CATEGORY BREAKDOWN:');
  var breakdown = manager.getCategoryBreakdown();
  breakdown.forEach((category, total) {
    print('$category: \$${total.toStringAsFixed(2)}');
  });
}

Part 5: Sorting Expenses

Add methods to sort expenses in different ways:

class ExpenseManager {
  List<Expense> _expenses = [];

  void addExpense(Expense expense) => _expenses.add(expense);
  List<Expense> getAllExpenses() => List.from(_expenses);

  // Sort by amount (ascending)
  List<Expense> sortByAmountAsc() {
    List<Expense> sorted = List.from(_expenses);
    sorted.sort((a, b) => a.amount.compareTo(b.amount));
    return sorted;
  }

  // Sort by amount (descending)
  List<Expense> sortByAmountDesc() {
    List<Expense> sorted = List.from(_expenses);
    sorted.sort((a, b) => b.amount.compareTo(a.amount));
    return sorted;
  }

  // Sort by date (newest first)
  List<Expense> sortByDateDesc() {
    List<Expense> sorted = List.from(_expenses);
    sorted.sort((a, b) => b.date.compareTo(a.date));
    return sorted;
  }

  // Sort by date (oldest first)
  List<Expense> sortByDateAsc() {
    List<Expense> sorted = List.from(_expenses);
    sorted.sort((a, b) => a.date.compareTo(b.date));
    return sorted;
  }

  // Sort by category
  List<Expense> sortByCategory() {
    List<Expense> sorted = List.from(_expenses);
    sorted.sort((a, b) => a.category.compareTo(b.category));
    return sorted;
  }

  // Sort by description
  List<Expense> sortByDescription() {
    List<Expense> sorted = List.from(_expenses);
    sorted.sort((a, b) => a.description.compareTo(b.description));
    return sorted;
  }
}

void main() {
  var manager = ExpenseManager();

  manager.addExpense(Expense(description: 'Laptop', amount: 899.99, category: 'Electronics', date: DateTime(2025, 10, 5)));
  manager.addExpense(Expense(description: 'Coffee', amount: 4.50, category: 'Food', date: DateTime(2025, 10, 9)));
  manager.addExpense(Expense(description: 'Rent', amount: 1200.0, category: 'Bills', date: DateTime(2025, 10, 1)));
  manager.addExpense(Expense(description: 'Lunch', amount: 15.75, category: 'Food', date: DateTime(2025, 10, 8)));

  print('SORTED BY AMOUNT (highest first):');
  for (var expense in manager.sortByAmountDesc()) {
    print('${expense.description}: \$${expense.amount}');
  }

  print('\nSORTED BY DATE (newest first):');
  for (var expense in manager.sortByDateDesc()) {
    print('${expense.description}: ${expense.getFormattedDate()}');
  }

  print('\nSORTED BY CATEGORY:');
  for (var expense in manager.sortByCategory()) {
    print('${expense.category}: ${expense.description}');
  }
}

Part 6: Removing and Updating Expenses

Add methods to modify the expense list:

class ExpenseManager {
  List<Expense> _expenses = [];

  void addExpense(Expense expense) {
    _expenses.add(expense);
    print('✅ Added: ${expense.description}');
  }

  // Remove expense by index
  bool removeExpenseAt(int index) {
    if (index < 0 || index >= _expenses.length) {
      print('❌ Invalid index');
      return false;
    }
    var removed = _expenses.removeAt(index);
    print('🗑️ Removed: ${removed.description}');
    return true;
  }

  // Remove expense by description
  bool removeExpenseByDescription(String description) {
    for (int i = 0; i < _expenses.length; i++) {
      if (_expenses[i].description == description) {
        var removed = _expenses.removeAt(i);
        print('🗑️ Removed: ${removed.description}');
        return true;
      }
    }
    print('❌ Expense not found: $description');
    return false;
  }

  // Remove all expenses in a category
  int removeByCategory(String category) {
    int count = 0;
    _expenses.removeWhere((expense) {
      if (expense.category == category) {
        count++;
        return true;
      }
      return false;
    });
    print('🗑️ Removed $count expenses from category: $category');
    return count;
  }

  // Clear all expenses
  void clearAll() {
    int count = _expenses.length;
    _expenses.clear();
    print('🗑️ Cleared all $count expenses');
  }

  // Update expense at index
  bool updateExpense(int index, Expense newExpense) {
    if (index < 0 || index >= _expenses.length) {
      print('❌ Invalid index');
      return false;
    }
    _expenses[index] = newExpense;
    print('✏️ Updated expense at index $index');
    return true;
  }

  // Get expense by index
  Expense? getExpenseAt(int index) {
    if (index < 0 || index >= _expenses.length) {
      return null;
    }
    return _expenses[index];
  }

  // Find index of expense by description
  int findIndexByDescription(String description) {
    for (int i = 0; i < _expenses.length; i++) {
      if (_expenses[i].description == description) {
        return i;
      }
    }
    return -1;
  }
}

void main() {
  var manager = ExpenseManager();

  manager.addExpense(Expense.quick('Coffee', 4.50, 'Food'));
  manager.addExpense(Expense.quick('Lunch', 15.75, 'Food'));
  manager.addExpense(Expense.quick('Gas', 45.00, 'Transport'));

  print('\n--- Removing ---');
  manager.removeExpenseByDescription('Coffee');

  print('\n--- Updating ---');
  int index = manager.findIndexByDescription('Lunch');
  if (index != -1) {
    manager.updateExpense(index, Expense.quick('Dinner', 25.00, 'Food'));
  }

  print('\n--- Final list ---');
  for (var expense in manager.getAllExpenses()) {
    print(expense.getSummary());
  }
}

Part 7: Complete ExpenseManager Class

Here's the full-featured ExpenseManager:

class ExpenseManager {
  List<Expense> _expenses = [];

  // === ADD METHODS ===
  void addExpense(Expense expense) {
    _expenses.add(expense);
  }

  void addMultipleExpenses(List<Expense> expenses) {
    _expenses.addAll(expenses);
    print('✅ Added ${expenses.length} expenses');
  }

  // === GET METHODS ===
  List<Expense> getAllExpenses() => List.from(_expenses);

  int getCount() => _expenses.length;

  bool isEmpty() => _expenses.isEmpty;

  Expense? getExpenseAt(int index) {
    if (index < 0 || index >= _expenses.length) return null;
    return _expenses[index];
  }

  // === FILTER METHODS ===
  List<Expense> getByCategory(String category) {
    return _expenses.where((e) => e.category == category).toList();
  }

  List<Expense> getByAmountRange(double min, double max) {
    return _expenses.where((e) => e.amount >= min && e.amount <= max).toList();
  }

  List<Expense> getMajorExpenses() {
    return _expenses.where((e) => e.isMajorExpense()).toList();
  }

  List<Expense> getThisMonth() {
    return _expenses.where((e) => e.isThisMonth()).toList();
  }

  List<Expense> getPaidExpenses() {
    return _expenses.where((e) => e.isPaid).toList();
  }

  List<Expense> getUnpaidExpenses() {
    return _expenses.where((e) => !e.isPaid).toList();
  }

  // === STATISTICS METHODS ===
  double getTotalSpending() {
    return _expenses.fold(0.0, (sum, e) => sum + e.amount);
  }

  double getTotalByCategory(String category) {
    return _expenses
        .where((e) => e.category == category)
        .fold(0.0, (sum, e) => sum + e.amount);
  }

  double getAverageExpense() {
    if (_expenses.isEmpty) return 0;
    return getTotalSpending() / _expenses.length;
  }

  double getTotalUnpaid() {
    return _expenses
        .where((e) => !e.isPaid)
        .fold(0.0, (sum, e) => sum + e.amount);
  }

  Expense? getLargestExpense() {
    if (_expenses.isEmpty) return null;
    return _expenses.reduce((a, b) => a.amount > b.amount ? a : b);
  }

  Expense? getSmallestExpense() {
    if (_expenses.isEmpty) return null;
    return _expenses.reduce((a, b) => a.amount < b.amount ? a : b);
  }

  int countByCategory(String category) {
    return _expenses.where((e) => e.category == category).length;
  }

  List<String> getAllCategories() {
    return _expenses.map((e) => e.category).toSet().toList();
  }

  Map<String, double> getCategoryBreakdown() {
    Map<String, double> breakdown = {};
    for (var expense in _expenses) {
      breakdown[expense.category] = 
          (breakdown[expense.category] ?? 0) + expense.amount;
    }
    return breakdown;
  }

  Map<String, int> getCategoryCounts() {
    Map<String, int> counts = {};
    for (var expense in _expenses) {
      counts[expense.category] = (counts[expense.category] ?? 0) + 1;
    }
    return counts;
  }

  // === SORT METHODS ===
  List<Expense> sortByAmountDesc() {
    List<Expense> sorted = List.from(_expenses);
    sorted.sort((a, b) => b.amount.compareTo(a.amount));
    return sorted;
  }

  List<Expense> sortByAmountAsc() {
    List<Expense> sorted = List.from(_expenses);
    sorted.sort((a, b) => a.amount.compareTo(b.amount));
    return sorted;
  }

  List<Expense> sortByDateDesc() {
    List<Expense> sorted = List.from(_expenses);
    sorted.sort((a, b) => b.date.compareTo(a.date));
    return sorted;
  }

  List<Expense> sortByCategory() {
    List<Expense> sorted = List.from(_expenses);
    sorted.sort((a, b) => a.category.compareTo(b.category));
    return sorted;
  }

  // === REMOVE METHODS ===
  bool removeExpenseAt(int index) {
    if (index < 0 || index >= _expenses.length) return false;
    _expenses.removeAt(index);
    return true;
  }

  bool removeExpenseByDescription(String description) {
    int initialLength = _expenses.length;
    _expenses.removeWhere((e) => e.description == description);
    return _expenses.length < initialLength;
  }

  int removeByCategory(String category) {
    int initialLength = _expenses.length;
    _expenses.removeWhere((e) => e.category == category);
    return initialLength - _expenses.length;
  }

  void clearAll() {
    _expenses.clear();
  }

  // === SEARCH METHODS ===
  List<Expense> searchByDescription(String query) {
    String lowerQuery = query.toLowerCase();
    return _expenses
        .where((e) => e.description.toLowerCase().contains(lowerQuery))
        .toList();
  }

  int findIndexByDescription(String description) {
    return _expenses.indexWhere((e) => e.description == description);
  }

  // === REPORT METHODS ===
  void printSummary() {
    print('\n═══════════════════════════════════');
    print('💰 EXPENSE SUMMARY');
    print('═══════════════════════════════════');
    print('Total expenses: ${getCount()}');
    print('Total spent: \$${getTotalSpending().toStringAsFixed(2)}');
    print('Average expense: \$${getAverageExpense().toStringAsFixed(2)}');
    print('Total unpaid: \$${getTotalUnpaid().toStringAsFixed(2)}');

    var largest = getLargestExpense();
    if (largest != null) {
      print('Largest: ${largest.description} (\$${largest.amount})');
    }

    print('═══════════════════════════════════\n');
  }

  void printCategoryReport() {
    print('\n📊 CATEGORY BREAKDOWN\n');
    var breakdown = getCategoryBreakdown();
    var counts = getCategoryCounts();
    double total = getTotalSpending();

    breakdown.forEach((category, amount) {
      double percentage = (amount / total) * 100;
      int count = counts[category] ?? 0;
      print('$category:');
      print('  Amount: \$${amount.toStringAsFixed(2)} (${percentage.toStringAsFixed(1)}%)');
      print('  Count: $count expenses');
      print('');
    });
  }

  void printAllExpenses() {
    print('\n📋 ALL EXPENSES\n');
    if (_expenses.isEmpty) {
      print('No expenses to display');
      return;
    }

    for (int i = 0; i < _expenses.length; i++) {
      print('${i + 1}. ${_expenses[i].getFullDisplay()}');
    }
    print('');
  }
}

void main() {
  var manager = ExpenseManager();

  // Add expenses
  manager.addExpense(Expense(description: 'Coffee', amount: 4.50, category: 'Food'));
  manager.addExpense(Expense(description: 'Rent', amount: 1200.0, category: 'Bills', isPaid: true));
  manager.addExpense(Expense(description: 'Laptop', amount: 899.99, category: 'Electronics'));
  manager.addExpense(Expense(description: 'Lunch', amount: 15.75, category: 'Food'));
  manager.addExpense(Expense(description: 'Gas', amount: 45.00, category: 'Transport'));
  manager.addExpense(Expense(description: 'Groceries', amount: 127.50, category: 'Food', isPaid: true));

  // Print reports
  manager.printSummary();
  manager.printCategoryReport();
  manager.printAllExpenses();

  // Filter and display
  print('🍔 FOOD EXPENSES:');
  for (var expense in manager.getByCategory('Food')) {
    print('  ${expense.getSummary()}');
  }

  print('\n🔴 MAJOR EXPENSES:');
  for (var expense in manager.getMajorExpenses()) {
    print('  ${expense.getSummary()}');
  }
}

🎯 Practice Exercises

Exercise 1: Monthly Report (Easy)

Add a method to ExpenseManager:

getMonthlyReport(int year, int month) - returns all expenses for that month
getMonthlyTotal(int year, int month) - returns total for that month

Solution:

List<Expense> getMonthlyReport(int year, int month) {
  return _expenses.where((e) {
    return e.date.year == year && e.date.month == month;
  }).toList();
}

double getMonthlyTotal(int year, int month) {
  return getMonthlyReport(year, month)
      .fold(0.0, (sum, e) => sum + e.amount);
}

void main() {
  var manager = ExpenseManager();
  // Add expenses...

  var octoberExpenses = manager.getMonthlyReport(2025, 10);
  print('October expenses: ${octoberExpenses.length}');
  print('October total: \$${manager.getMonthlyTotal(2025, 10).toStringAsFixed(2)}');
}

Exercise 2: Budget Tracking (Medium)

Add these methods to ExpenseManager:

setBudget(String category, double amount) - set budget for a category
isOverBudget(String category) - check if category is over budget
getBudgetStatus(String category) - return how much under/over

Solution:


dart
class ExpenseManager {
  List<Expense> _expenses = [];
  Map<String, double> _budgets = {};

  void setBudget(String category, double amount) {
    _budgets[category] = amount;
    print('💰 Set budget for $category: \$${amount.toStringAsFixed(2)}');
  }

  bool isOverBudget(String category) {
    if (!_budgets.containsKey(category)) return false;
    double spent = getTotalByCategory(category);
    return spent > _budgets[category]!;
  }

  String getBudgetStatus(String category) {
    if (!_budgets.containsKey(category)) {
      return 'No budget set for $category';
    }

    double budget = _budgets[category]!;
    double spent = getTotalByCategory(category);
    double remaining = budget - spent;

    if (remaining >= 0) {
      return '\$${remaining.toStringAsFixed(2)} remaining (${((spent/budget)*100).toStringAsFixed(1)}% used)';
    } else {
      return '\$${remaining.abs().toStringAsFixed(2)} over budget!';
    }
  }

  void printBudgetReport() {
    print('\n💰 BUDGET REPORT\n');
    _budgets.forEach((category, budget) {
      double spent = getTotalByCategory(category);
      String status = isOverBudget(category) ? '❌' : '✅';
      print('$status $category:');
      print('   Budget: \$${budget.toStringAsFixed(2)}');
      print('   Spent: \$${spent.toStringAsFixed(2)}');
      print('   ${getBudgetStatus(category)}');
      print('');
    });
  }
}

void main() {

Dart Object Oriented For Beginner : Expense Manager Case Study Part 5

Putra Prima A — Wed, 08 Oct 2025 22:49:17 +0000

Lesson 5: Adding Useful Features (Methods)

Duration: 30 minutes

App Feature: ✨ Making Expenses Smarter

What You'll Build: Add helpful methods to analyze expenses

Prerequisites: Complete Lessons 1-4

What We'll Learn Today

By the end of this lesson, you'll be able to:

✅ Add methods that perform calculations
✅ Create methods that return different types
✅ Use optional and named parameters in methods
✅ Build methods that check conditions
✅ Format data for display
✅ Make your Expense class more powerful

Part 1: Methods That Return Boolean Values

Let's add methods to check various conditions about an expense:

class Expense {
  String _description;
  double _amount;
  String _category;
  DateTime _date;

  Expense(this._description, this._amount, this._category, this._date);

  // Getters
  String get description => _description;
  double get amount => _amount;
  String get category => _category;
  DateTime get date => _date;

  // Boolean methods - return true or false
  bool isMajorExpense() {
    return _amount > 100;
  }

  bool isThisMonth() {
    DateTime now = DateTime.now();
    return _date.year == now.year && _date.month == now.month;
  }

  bool isThisWeek() {
    DateTime now = DateTime.now();
    DateTime startOfWeek = now.subtract(Duration(days: now.weekday - 1));
    DateTime endOfWeek = startOfWeek.add(Duration(days: 6));
    return _date.isAfter(startOfWeek) && _date.isBefore(endOfWeek);
  }

  bool isToday() {
    DateTime now = DateTime.now();
    return _date.year == now.year && 
           _date.month == now.month && 
           _date.day == now.day;
  }

  bool isCategory(String category) {
    return _category == category;
  }

  bool isOlderThan(int days) {
    DateTime now = DateTime.now();
    int difference = now.difference(_date).inDays;
    return difference > days;
  }
}

void main() {
  var coffee = Expense('Coffee', 4.50, 'Food', DateTime.now());
  var laptop = Expense('Laptop', 899.99, 'Electronics', DateTime(2025, 10, 5));

  print('Coffee is major expense? ${coffee.isMajorExpense()}');
  print('Coffee is this month? ${coffee.isThisMonth()}');
  print('Coffee is today? ${coffee.isToday()}');
  print('Coffee is Food? ${coffee.isCategory("Food")}');

  print('\nLaptop is major expense? ${laptop.isMajorExpense()}');
  print('Laptop is older than 3 days? ${laptop.isOlderThan(3)}');
}

Output:

Coffee is major expense? false
Coffee is this month? true
Coffee is today? true
Coffee is Food? true

Laptop is major expense? true
Laptop is older than 3 days? true

Part 2: Methods That Return Formatted Strings

Add methods that return nicely formatted data:

class Expense {
  String _description;
  double _amount;
  String _category;
  DateTime _date;

  Expense(this._description, this._amount, this._category, this._date);

  // Getters
  String get description => _description;
  double get amount => _amount;
  String get category => _category;
  DateTime get date => _date;

  // Formatting methods
  String getFormattedAmount() {
    return '\$${_amount.toStringAsFixed(2)}';
  }

  String getFormattedDate() {
    List<String> months = [
      'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
      'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'
    ];
    return '${months[_date.month - 1]} ${_date.day}, ${_date.year}';
  }

  String getShortDate() {
    return '${_date.month}/${_date.day}/${_date.year}';
  }

  String getSummary() {
    String emoji = _amount > 100 ? '🔴' : '🟢';
    return '$emoji $_description: ${getFormattedAmount()} [$_category]';
  }

  String getDetailedSummary() {
    return '''
$_description
Amount: ${getFormattedAmount()}
Category: $_category
Date: ${getFormattedDate()}
''';
  }

  String getCategoryEmoji() {
    switch (_category) {
      case 'Food': return '🍔';
      case 'Transport': return '🚗';
      case 'Bills': return '💡';
      case 'Entertainment': return '🎬';
      case 'Health': return '💊';
      case 'Shopping': return '🛍️';
      default: return '📝';
    }
  }

  String getFullDisplay() {
    return '${getCategoryEmoji()} $_description - ${getFormattedAmount()}';
  }
}

void main() {
  var coffee = Expense('Coffee', 4.50, 'Food', DateTime.now());
  var laptop = Expense('Laptop', 899.99, 'Electronics', DateTime(2025, 10, 5));

  print(coffee.getSummary());
  print(coffee.getFormattedDate());
  print(coffee.getFullDisplay());

  print('\n${laptop.getDetailedSummary()}');
}

Part 3: Methods with Calculations

Add methods that perform calculations:

class Expense {
  String _description;
  double _amount;
  String _category;
  DateTime _date;

  Expense(this._description, this._amount, this._category, this._date);

  // Getters
  String get description => _description;
  double get amount => _amount;
  String get category => _category;
  DateTime get date => _date;

  // Calculation methods
  int getDaysAgo() {
    DateTime now = DateTime.now();
    return now.difference(_date).inDays;
  }

  double getTax({double taxRate = 0.10}) {
    return _amount * taxRate;
  }

  double getTotalWithTax({double taxRate = 0.10}) {
    return _amount + getTax(taxRate: taxRate);
  }

  double getPercentageOf(double total) {
    if (total == 0) return 0;
    return (_amount / total) * 100;
  }

  double getMonthlyAverage() {
    // Assumes this is an annual expense
    return _amount / 12;
  }

  // Split expense among people
  double splitAmount(int numberOfPeople) {
    if (numberOfPeople <= 0) return _amount;
    return _amount / numberOfPeople;
  }

  // Calculate what this expense would be with a discount
  double applyDiscount(double discountPercent) {
    if (discountPercent < 0 || discountPercent > 100) {
      return _amount;
    }
    return _amount * (1 - discountPercent / 100);
  }
}

void main() {
  var laptop = Expense('Laptop', 1000.0, 'Electronics', DateTime(2025, 10, 5));

  print('Amount: \$${laptop.amount}');
  print('Days ago: ${laptop.getDaysAgo()}');
  print('Tax (10%): \$${laptop.getTax().toStringAsFixed(2)}');
  print('Total with tax: \$${laptop.getTotalWithTax().toStringAsFixed(2)}');
  print('Split 4 ways: \$${laptop.splitAmount(4).toStringAsFixed(2)}');
  print('With 20% discount: \$${laptop.applyDiscount(20).toStringAsFixed(2)}');

  double totalSpending = 5000.0;
  print('Percentage of total: ${laptop.getPercentageOf(totalSpending).toStringAsFixed(1)}%');
}

Output:

Amount: $1000.0
Days ago: 4
Tax (10%): $100.00
Total with tax: $1100.00
Split 4 ways: $250.00
With 20% discount: $800.00
Percentage of total: 20.0%

Part 4: Methods with Optional Parameters

Create flexible methods using optional parameters:

class Expense {
  String _description;
  double _amount;
  String _category;
  DateTime _date;

  Expense(this._description, this._amount, this._category, this._date);

  // Getters
  String get description => _description;
  double get amount => _amount;
  String get category => _category;
  DateTime get date => _date;

  // Method with optional positional parameter
  void printDetails([bool showEmoji = false]) {
    String emoji = showEmoji ? getCategoryEmoji() : '';
    print('$emoji $_description: \$${_amount.toStringAsFixed(2)} [$_category]');
  }

  // Method with multiple optional parameters
  String format({
    bool showDate = false,
    bool showCategory = true,
    bool showEmoji = false,
    String currency = '\$',
  }) {
    String result = _description;

    if (showEmoji) {
      result = '${getCategoryEmoji()} $result';
    }

    result += ': $currency${_amount.toStringAsFixed(2)}';

    if (showCategory) {
      result += ' [$_category]';
    }

    if (showDate) {
      result += ' (${_date.toString().split(' ')[0]})';
    }

    return result;
  }

  String getCategoryEmoji() {
    switch (_category) {
      case 'Food': return '🍔';
      case 'Transport': return '🚗';
      case 'Bills': return '💡';
      default: return '📝';
    }
  }

  // Method with optional callback
  void process({void Function(String)? onComplete}) {
    // Do some processing
    print('Processing expense: $_description');

    // Call callback if provided
    if (onComplete != null) {
      onComplete('✅ Expense processed successfully');
    }
  }
}

void main() {
  var coffee = Expense('Coffee', 4.50, 'Food', DateTime.now());

  // Different ways to call printDetails
  coffee.printDetails();
  coffee.printDetails(true);

  // Different ways to format
  print('\n${coffee.format()}');
  print(coffee.format(showEmoji: true));
  print(coffee.format(showDate: true, showEmoji: true));
  print(coffee.format(currency: '€', showCategory: false));

  // Using callback
  print('');
  coffee.process(onComplete: (message) {
    print(message);
  });
}

Part 5: Comparison Methods

Add methods to compare expenses:

class Expense {
  String _description;
  double _amount;
  String _category;
  DateTime _date;

  Expense(this._description, this._amount, this._category, this._date);

  // Getters
  String get description => _description;
  double get amount => _amount;
  String get category => _category;
  DateTime get date => _date;

  // Comparison methods
  bool isMoreExpensiveThan(Expense other) {
    return _amount > other._amount;
  }

  bool isSameCategory(Expense other) {
    return _category == other._category;
  }

  bool isSameDay(Expense other) {
    return _date.year == other._date.year &&
           _date.month == other._date.month &&
           _date.day == other._date.day;
  }

  bool isNewerThan(Expense other) {
    return _date.isAfter(other._date);
  }

  int compareByAmount(Expense other) {
    if (_amount < other._amount) return -1;
    if (_amount > other._amount) return 1;
    return 0;
  }

  int compareByDate(Expense other) {
    return _date.compareTo(other._date);
  }

  double getDifferenceFrom(Expense other) {
    return (_amount - other._amount).abs();
  }
}

void main() {
  var coffee = Expense('Coffee', 4.50, 'Food', DateTime.now());
  var lunch = Expense('Lunch', 12.75, 'Food', DateTime.now());
  var laptop = Expense('Laptop', 899.99, 'Electronics', DateTime(2025, 10, 5));

  print('Lunch is more expensive than coffee? ${lunch.isMoreExpensiveThan(coffee)}');
  print('Lunch same category as coffee? ${lunch.isSameCategory(coffee)}');
  print('Lunch same day as coffee? ${lunch.isSameDay(coffee)}');
  print('Coffee newer than laptop? ${coffee.isNewerThan(laptop)}');
  print('Difference between lunch and coffee: \$${lunch.getDifferenceFrom(coffee).toStringAsFixed(2)}');
}

Part 6: Complete Enhanced Expense Class

Here's a comprehensive Expense class with all useful methods:

class Expense {
  String _description;
  double _amount;
  String _category;
  DateTime _date;
  String? _notes;
  bool _isPaid;

  static const List<String> validCategories = [
    'Food', 'Transport', 'Bills', 'Entertainment', 'Health', 'Shopping', 'Other'
  ];

  Expense({
    required String description,
    required double amount,
    required String category,
    DateTime? date,
    String? notes,
    bool isPaid = false,
  }) : _description = description,
       _amount = amount,
       _category = category,
       _date = date ?? DateTime.now(),
       _notes = notes,
       _isPaid = isPaid {
    if (_amount < 0) throw Exception('Amount cannot be negative');
    if (_description.trim().isEmpty) throw Exception('Description cannot be empty');
    if (!validCategories.contains(_category)) {
      _category = 'Other';
    }
  }

  // Getters
  String get description => _description;
  double get amount => _amount;
  String get category => _category;
  DateTime get date => _date;
  String? get notes => _notes;
  bool get isPaid => _isPaid;

  // Setters
  set amount(double value) {
    if (value < 0) throw Exception('Amount cannot be negative');
    _amount = value;
  }

  set isPaid(bool value) => _isPaid = value;
  set notes(String? value) => _notes = value;

  // Boolean check methods
  bool isMajorExpense() => _amount > 100;
  bool isThisMonth() {
    DateTime now = DateTime.now();
    return _date.year == now.year && _date.month == now.month;
  }
  bool isToday() {
    DateTime now = DateTime.now();
    return _date.year == now.year && _date.month == now.month && _date.day == now.day;
  }
  bool isCategory(String cat) => _category == cat;
  bool isOlderThan(int days) => DateTime.now().difference(_date).inDays > days;

  // Formatting methods
  String getFormattedAmount() => '\$${_amount.toStringAsFixed(2)}';

  String getFormattedDate() {
    List<String> months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
                           'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
    return '${months[_date.month - 1]} ${_date.day}, ${_date.year}';
  }

  String getCategoryEmoji() {
    switch (_category) {
      case 'Food': return '🍔';
      case 'Transport': return '🚗';
      case 'Bills': return '💡';
      case 'Entertainment': return '🎬';
      case 'Health': return '💊';
      case 'Shopping': return '🛍️';
      default: return '📝';
    }
  }

  String getSummary() {
    String emoji = isMajorExpense() ? '🔴' : '🟢';
    return '$emoji $_description: ${getFormattedAmount()} [$_category]';
  }

  String getFullDisplay() {
    String paid = _isPaid ? '✅' : '❌';
    String noteText = _notes != null ? ' - $_notes' : '';
    return '$paid ${getCategoryEmoji()} $_description: ${getFormattedAmount()}$noteText';
  }

  // Calculation methods
  int getDaysAgo() => DateTime.now().difference(_date).inDays;

  double getTax({double taxRate = 0.10}) => _amount * taxRate;

  double getTotalWithTax({double taxRate = 0.10}) => _amount + getTax(taxRate: taxRate);

  double getPercentageOf(double total) {
    if (total == 0) return 0;
    return (_amount / total) * 100;
  }

  double splitAmount(int numberOfPeople) {
    if (numberOfPeople <= 0) return _amount;
    return _amount / numberOfPeople;
  }

  // Comparison methods
  bool isMoreExpensiveThan(Expense other) => _amount > other._amount;
  bool isSameCategory(Expense other) => _category == other._category;
  bool isNewerThan(Expense other) => _date.isAfter(other._date);

  int compareByAmount(Expense other) {
    if (_amount < other._amount) return -1;
    if (_amount > other._amount) return 1;
    return 0;
  }

  // Action methods
  void markAsPaid() {
    _isPaid = true;
  }

  void markAsUnpaid() {
    _isPaid = false;
  }

  void addNote(String note) {
    if (_notes == null || _notes!.isEmpty) {
      _notes = note;
    } else {
      _notes = '$_notes; $note';
    }
  }

  void printDetails() {
    print('─────────────────────────────');
    print('${getCategoryEmoji()} $_description');
    print('💰 ${getFormattedAmount()}');
    print('📁 $_category');
    print('📅 ${getFormattedDate()}');
    print('${_isPaid ? "✅" : "❌"} ${_isPaid ? "Paid" : "Unpaid"}');
    if (_notes != null && _notes!.isNotEmpty) {
      print('📝 $_notes');
    }
    print('🕒 ${getDaysAgo()} days ago');
  }
}

void main() {
  print('🏦 ENHANCED EXPENSE CLASS DEMO\n');

  var expenses = [
    Expense(description: 'Morning coffee', amount: 4.50, category: 'Food'),
    Expense(description: 'Uber to work', amount: 12.00, category: 'Transport'),
    Expense(description: 'Laptop', amount: 899.99, category: 'Shopping', isPaid: true),
    Expense(description: 'Groceries', amount: 127.50, category: 'Food', notes: 'Weekly shopping'),
  ];

  // Print all summaries
  print('SUMMARY:');
  for (var expense in expenses) {
    print(expense.getSummary());
  }

  // Calculate totals
  double total = 0;
  for (var expense in expenses) {
    total += expense.amount;
  }

  print('\n─────────────────────────────');
  print('Total: \$${total.toStringAsFixed(2)}');

  // Show percentages
  print('\nPERCENTAGES:');
  for (var expense in expenses) {
    print('${expense.description}: ${expense.getPercentageOf(total).toStringAsFixed(1)}%');
  }

  // Show this month's expenses
  print('\nTHIS MONTH:');
  for (var expense in expenses) {
    if (expense.isThisMonth()) {
      print(expense.getFullDisplay());
    }
  }

  // Show major expenses
  print('\nMAJOR EXPENSES (>\$100):');
  for (var expense in expenses) {
    if (expense.isMajorExpense()) {
      expense.printDetails();
    }
  }
}

🎯 Practice Exercises

Exercise 1: Time-Based Methods (Easy)

Add these methods to the Expense class:

getWeekNumber() - returns the week number of the year
getQuarter() - returns which quarter (1-4) the expense is in
isWeekend() - returns true if expense was on Saturday or Sunday

Solution:

int getWeekNumber() {
  int dayOfYear = int.parse(DateFormat("D").format(_date));
  return ((dayOfYear - _date.weekday + 10) / 7).floor();
}

int getQuarter() {
  return ((_date.month - 1) / 3).floor() + 1;
}

bool isWeekend() {
  return _date.weekday == DateTime.saturday || _date.weekday == DateTime.sunday;
}

void main() {
  var expense = Expense(
    description: 'Weekend brunch',
    amount: 45.00,
    category: 'Food',
    date: DateTime(2025, 10, 11), // Saturday
  );

  print('Quarter: ${expense.getQuarter()}');
  print('Is weekend? ${expense.isWeekend()}');
}

Exercise 2: Statistical Methods (Medium)

Add these methods:

getAmountRounded() - returns amount rounded to nearest dollar
getDailyAverage(int days) - returns average per day over specified period
projectedYearly() - if this was monthly, what would yearly total be?

Solution:

double getAmountRounded() {
  return _amount.roundToDouble();
}

double getDailyAverage(int days) {
  if (days <= 0) return 0;
  return _amount / days;
}

double projectedYearly() {
  return _amount * 12;
}

void main() {
  var subscription = Expense(
    description: 'Netflix',
    amount: 15.99,
    category: 'Entertainment',
  );

  print('Amount: ${subscription.getFormattedAmount()}');
  print('Rounded: \$${subscription.getAmountRounded().toStringAsFixed(2)}');
  print('Daily average (30 days): \$${subscription.getDailyAverage(30).toStringAsFixed(2)}');
  print('Projected yearly: \$${subscription.projectedYearly().toStringAsFixed(2)}');
}

Exercise 3: Smart Analysis Methods (Hard)

Create these advanced methods:

getRiskLevel() - returns 'Low', 'Medium', or 'High' based on amount
getSavingSuggestion() - returns a tip for reducing this expense
compareToAverage(double avgExpense) - returns how much above/below average

Solution:

String getRiskLevel() {
  if (_amount < 50) return 'Low';
  if (_amount < 200) return 'Medium';
  return 'High';
}

String getSavingSuggestion() {
  if (_category == 'Food' && _amount > 50) {
    return 'Consider meal prepping to reduce food costs';
  }
  if (_category == 'Transport' && _amount > 100) {
    return 'Look into public transportation or carpooling';
  }
  if (_category == 'Entertainment' && _amount > 50) {
    return 'Try free entertainment options like parks or libraries';
  }
  if (_amount > 500) {
    return 'Major purchase - ensure it aligns with your budget goals';
  }
  return 'Expense looks reasonable';
}

String compareToAverage(double avgExpense) {
  double difference = _amount - avgExpense;
  double percentDiff = (difference / avgExpense * 100).abs();

  if (difference > 0) {
    return '\$${difference.toStringAsFixed(2)} (${percentDiff.toStringAsFixed(1)}%) above average';
  } else if (difference < 0) {
    return '\$${difference.abs().toStringAsFixed(2)} (${percentDiff.toStringAsFixed(1)}%) below average';
  } else {
    return 'Exactly average';
  }
}

void main() {
  var lunch = Expense(description: 'Lunch', amount: 85.00, category: 'Food');

  print('Risk level: ${lunch.getRiskLevel()}');
  print('Suggestion: ${lunch.getSavingSuggestion()}');
  print('vs Average: ${lunch.compareToAverage(50.0)}');
}

Common Mistakes & How to Fix Them

Mistake 1: Not Returning Values

// ❌ Wrong - method doesn't return anything
String getSummary() {
  '$_description: \$${_amount}';
}

// ✅ Correct - use return
String getSummary() {
  return '$_description: \$${_amount}';
}

Mistake 2: Forgetting to Handle Edge Cases

// ❌ Wrong - division by zero possible
double splitAmount(int numberOfPeople) {
  return _amount / numberOfPeople;
}

// ✅ Correct - check for invalid input
double splitAmount(int numberOfPeople) {
  if (numberOfPeople <= 0) return _amount;
  return _amount / numberOfPeople;
}

Mistake 3: Not Using Named Parameters When Appropriate

// ❌ Wrong - hard to remember order
String format(bool showDate, bool showCategory, bool showEmoji) { ... }

// ✅ Correct - use named parameters
String format({bool showDate = false, bool showCategory = true, bool showEmoji = false}) { ... }

Mistake 4: Making Methods Too Complex

// ❌ Wrong - doing too much
String doEverything() {
  // 100 lines of code doing multiple things
}

// ✅ Correct - separate concerns
String getSummary() { ... }
String getFormattedDate() { ... }
double calculateTotal() { ... }

Key Concepts Review

✅ Boolean methods return true/false for conditions

✅ Formatting methods return nicely formatted strings

✅ Calculation methods perform math and return results

✅ Optional parameters make methods flexible

✅ Comparison methods compare objects

✅ Action methods modify object state

✅ Keep methods focused - each does one thing well

Self-Check Questions

1. When should you use a method vs a computed getter?

Answer:

Method: When there are parameters, complex logic, or side effects
Getter: For simple property access or calculations without parameters
Example: getTax(taxRate: 0.15) is a method, isMajorExpense is a getter

2. What's the benefit of optional parameters?

Answer:
Optional parameters make methods flexible - users can provide values when needed but use defaults otherwise. This reduces the need for multiple method versions.

3. Why should methods be focused on one task?

Answer:

Easier to understand and test
More reusable in different contexts
Simpler to debug when issues arise
Follows "Single Responsibility Principle"

What's Next?

In Lesson 6: Managing Multiple Expenses, we'll learn:

Creating an ExpenseManager class
Working with lists of expenses
Filtering and sorting
Calculating totals across multiple expenses
Building reports

Example preview:

class ExpenseManager {
  List<Expense> _expenses = [];

  void addExpense(Expense expense) { ... }
  double getTotalSpending() { ... }
  List<Expense> getByCategory(String category) { ... }
  List<Expense> getThisMonth() { ... }
  Expense? getLargestExpense() { ... }
}

See you in Lesson 6! 🚀

Additional Resources

Try adding more methods to your Expense class
Think about what calculations would be useful for your app
Consider what formatting options users might want
Practice writing focused, single-purpose methods

Remember: Methods should make your objects useful and intelligent. Each method should do one thing well! 💪

Dart Object Oriented For Beginner : Expense Manager Case Study Part 4

Putra Prima A — Wed, 08 Oct 2025 22:49:01 +0000

Lesson 4: Protecting Your Data (Encapsulation)

Duration: 35 minutes

App Feature: 🔒 Making Sure Expenses Are Valid

What You'll Build: Add validation so users can't create invalid expenses

Prerequisites: Complete Lessons 1-3

What We'll Learn Today

By the end of this lesson, you'll be able to:

✅ Make properties private to protect data
✅ Use getters to read data safely
✅ Use setters to validate data before saving
✅ Prevent bugs like negative expenses or invalid categories
✅ Understand why encapsulation matters

Part 1: The Problem - Unprotected Data

Let's look at our current Expense class:

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  Expense(this.description, this.amount, this.category, this.date);
}

void main() {
  var coffee = Expense('Coffee', 4.50, 'Food', DateTime.now());

  // Uh oh... we can do this!
  coffee.amount = -100.50;  // Negative expense?!
  coffee.category = 'asdfgh';  // Invalid category!
  coffee.description = '';  // Empty description!

  print('Amount: \$${coffee.amount}');  // -$100.50 😱
}

Problems:

❌ Anyone can set amount to a negative number
❌ Invalid categories like "asdfgh" are allowed
❌ Empty descriptions are possible
❌ No way to validate data
❌ Easy to create bugs

What we need: A way to protect our data and validate it before accepting changes!

Part 2: Making Properties Private

In Dart, you make something private by adding an underscore _ prefix:

class Expense {
  String _description;  // Private - can't access from outside
  double _amount;       // Private
  String _category;     // Private
  DateTime _date;       // Private

  Expense(this._description, this._amount, this._category, this._date);
}

void main() {
  var coffee = Expense('Coffee', 4.50, 'Food', DateTime.now());

  // ❌ ERROR! These don't work anymore
  // coffee._amount = -100;
  // print(coffee._description);

  // Private properties can't be accessed from outside the class
}

Understanding Private Properties:

String _description;  // Underscore = private

Can only be accessed inside the class
Protected from outside modification
No one can directly change the value

But wait... If everything is private, how do we read or change values? 🤔

Part 3: Getters - Reading Data Safely

Getters let you read private data in a controlled way:

class Expense {
  String _description;
  double _amount;
  String _category;
  DateTime _date;

  Expense(this._description, this._amount, this._category, this._date);

  // Getters - read-only access
  String get description => _description;
  double get amount => _amount;
  String get category => _category;
  DateTime get date => _date;
}

void main() {
  var coffee = Expense('Coffee', 4.50, 'Food', DateTime.now());

  // ✅ Can read using getters
  print('Description: ${coffee.description}');
  print('Amount: \$${coffee.amount}');

  // ❌ But can't modify directly
  // coffee.amount = -100;  // ERROR!
}

Understanding Getter Syntax:

double get amount => _amount;

double = return type
get = keyword for getter
amount = getter name (no underscore!)
=> = arrow function (shorthand)
_amount = returns the private property

Alternative syntax (with function body):

double get amount {
  return _amount;
}

Both work the same way!

Part 4: Setters - Writing Data with Validation

Setters let you change private data, but with validation:

class Expense {
  String _description;
  double _amount;
  String _category;
  DateTime _date;

  Expense(this._description, this._amount, this._category, this._date);

  // Getters
  String get description => _description;
  double get amount => _amount;
  String get category => _category;
  DateTime get date => _date;

  // Setters with validation
  set amount(double value) {
    if (value < 0) {
      print('❌ Error: Amount cannot be negative!');
      return;  // Don't change the value
    }
    _amount = value;
  }

  set description(String value) {
    if (value.trim().isEmpty) {
      print('❌ Error: Description cannot be empty!');
      return;
    }
    _description = value;
  }

  set category(String value) {
    List<String> validCategories = [
      'Food', 
      'Transport', 
      'Bills', 
      'Entertainment', 
      'Health',
      'Shopping',
      'Other'
    ];

    if (!validCategories.contains(value)) {
      print('❌ Error: Invalid category "$value". Using "Other".');
      _category = 'Other';
      return;
    }
    _category = value;
  }
}

void main() {
  var coffee = Expense('Coffee', 4.50, 'Food', DateTime.now());

  // ✅ Valid changes work
  coffee.amount = 5.00;
  print('New amount: \$${coffee.amount}');

  // ❌ Invalid changes are rejected
  coffee.amount = -10;  // Prints error, doesn't change
  print('Amount still: \$${coffee.amount}');  // Still 5.00

  coffee.description = '';  // Prints error, doesn't change
  coffee.category = 'InvalidCategory';  // Changes to 'Other'
}

Output:

New amount: $5.00
❌ Error: Amount cannot be negative!
Amount still: $5.00
❌ Error: Description cannot be empty!
❌ Error: Invalid category "InvalidCategory". Using "Other".

Understanding Setter Syntax:

set amount(double value) {
  if (value < 0) {
    print('❌ Error: Amount cannot be negative!');
    return;
  }
  _amount = value;
}

set = keyword for setter
amount = setter name (matches getter name)
(double value) = the new value being set
Validate before setting _amount
return early if invalid

Part 5: Validation in Constructor

We should also validate when creating an expense:

class Expense {
  String _description;
  double _amount;
  String _category;
  DateTime _date;

  Expense(String description, double amount, String category, DateTime date)
    : _description = description,
      _amount = amount,
      _category = category,
      _date = date {
    // Validate in constructor body
    if (_amount < 0) {
      throw Exception('Amount cannot be negative!');
    }
    if (_description.trim().isEmpty) {
      throw Exception('Description cannot be empty!');
    }

    List<String> validCategories = [
      'Food', 'Transport', 'Bills', 'Entertainment', 'Health', 'Shopping', 'Other'
    ];
    if (!validCategories.contains(_category)) {
      print('⚠️ Warning: Invalid category "$_category". Changed to "Other".');
      _category = 'Other';
    }
  }

  // Getters
  String get description => _description;
  double get amount => _amount;
  String get category => _category;
  DateTime get date => _date;

  // Setters
  set amount(double value) {
    if (value < 0) {
      print('❌ Error: Amount cannot be negative!');
      return;
    }
    _amount = value;
  }

  set category(String value) {
    List<String> validCategories = [
      'Food', 'Transport', 'Bills', 'Entertainment', 'Health', 'Shopping', 'Other'
    ];
    if (!validCategories.contains(value)) {
      print('❌ Error: Invalid category. Using "Other".');
      _category = 'Other';
      return;
    }
    _category = value;
  }
}

void main() {
  try {
    var invalid = Expense('', -50, 'Food', DateTime.now());
  } catch (e) {
    print('Failed to create expense: $e');
  }

  // This works but changes category
  var expense = Expense('Coffee', 4.50, 'InvalidCat', DateTime.now());
  print('Category: ${expense.category}');  // 'Other'
}

Part 6: Computed Properties with Getters

Getters can also calculate values on-the-fly:

class Expense {
  String _description;
  double _amount;
  String _category;
  DateTime _date;

  Expense(this._description, this._amount, this._category, this._date) {
    if (_amount < 0) throw Exception('Amount cannot be negative!');
  }

  // Regular getters
  String get description => _description;
  double get amount => _amount;
  String get category => _category;
  DateTime get date => _date;

  // Computed getters - calculate on the fly
  bool get isMajorExpense => _amount > 100;

  bool get isThisMonth {
    DateTime now = DateTime.now();
    return _date.year == now.year && _date.month == now.month;
  }

  String get formattedAmount => '\$${_amount.toStringAsFixed(2)}';

  String get formattedDate => _date.toString().split(' ')[0];

  int get daysAgo => DateTime.now().difference(_date).inDays;

  String get summary => '$_description: $formattedAmount [$_category]';

  // Emoji based on amount
  String get categoryEmoji {
    switch (_category) {
      case 'Food': return '🍔';
      case 'Transport': return '🚗';
      case 'Bills': return '💡';
      case 'Entertainment': return '🎬';
      case 'Health': return '💊';
      case 'Shopping': return '🛍️';
      default: return '📝';
    }
  }
}

void main() {
  var coffee = Expense('Coffee', 4.50, 'Food', DateTime.now());
  var laptop = Expense('Laptop', 899.99, 'Shopping', DateTime(2025, 10, 5));

  print(coffee.summary);
  print('Is major? ${coffee.isMajorExpense}');
  print('Days ago: ${coffee.daysAgo}');
  print('${coffee.categoryEmoji} ${coffee.category}');

  print('\n${laptop.summary}');
  print('Is major? ${laptop.isMajorExpense}');
  print('${laptop.categoryEmoji} ${laptop.category}');
}

Output:

Coffee: $4.50 [Food]
Is major? false
Days ago: 0
🍔 Food

Laptop: $899.99 [Shopping]
Is major? true
🛍️ Shopping

Part 7: Complete Protected Expense Class

Here's a production-ready Expense class with full encapsulation:

class Expense {
  // Private properties
  String _description;
  double _amount;
  String _category;
  DateTime _date;
  String? _notes;
  bool _isPaid;

  // Valid categories list
  static const List<String> validCategories = [
    'Food',
    'Transport',
    'Bills',
    'Entertainment',
    'Health',
    'Shopping',
    'Other',
  ];

  // Constructor with validation
  Expense({
    required String description,
    required double amount,
    required String category,
    DateTime? date,
    String? notes,
    bool isPaid = false,
  }) : _description = description,
       _amount = amount,
       _category = category,
       _date = date ?? DateTime.now(),
       _notes = notes,
       _isPaid = isPaid {
    // Validate amount
    if (_amount < 0) {
      throw Exception('Amount cannot be negative');
    }

    // Validate description
    if (_description.trim().isEmpty) {
      throw Exception('Description cannot be empty');
    }

    // Validate category
    if (!validCategories.contains(_category)) {
      print('⚠️ Invalid category "$_category". Changed to "Other".');
      _category = 'Other';
    }
  }

  // Named constructor
  Expense.quick(String description, double amount, String category)
    : this(description: description, amount: amount, category: category);

  // Getters (read-only)
  String get description => _description;
  double get amount => _amount;
  String get category => _category;
  DateTime get date => _date;
  String? get notes => _notes;
  bool get isPaid => _isPaid;

  // Computed getters
  bool get isMajorExpense => _amount > 100;
  String get formattedAmount => '\$${_amount.toStringAsFixed(2)}';
  String get formattedDate => _date.toString().split(' ')[0];

  String get categoryEmoji {
    switch (_category) {
      case 'Food': return '🍔';
      case 'Transport': return '🚗';
      case 'Bills': return '💡';
      case 'Entertainment': return '🎬';
      case 'Health': return '💊';
      case 'Shopping': return '🛍️';
      default: return '📝';
    }
  }

  // Setters with validation
  set amount(double value) {
    if (value < 0) {
      throw Exception('Amount cannot be negative');
    }
    _amount = value;
  }

  set description(String value) {
    if (value.trim().isEmpty) {
      throw Exception('Description cannot be empty');
    }
    _description = value.trim();
  }

  set category(String value) {
    if (!validCategories.contains(value)) {
      throw Exception('Invalid category: $value');
    }
    _category = value;
  }

  set notes(String? value) {
    _notes = value;
  }

  set isPaid(bool value) {
    _isPaid = value;
  }

  // Methods
  void markAsPaid() {
    _isPaid = true;
    print('✅ Marked as paid: $_description');
  }

  void markAsUnpaid() {
    _isPaid = false;
    print('❌ Marked as unpaid: $_description');
  }

  void addNote(String note) {
    if (_notes == null || _notes!.isEmpty) {
      _notes = note;
    } else {
      _notes = '$_notes; $note';
    }
  }

  void printDetails() {
    String paidStatus = _isPaid ? '✅ Paid' : '❌ Unpaid';
    String noteText = _notes != null ? '\n   📝 $_notes' : '';

    print('─────────────────────────────');
    print('$categoryEmoji $_description');
    print('💰 $formattedAmount');
    print('📁 $_category');
    print('📅 $formattedDate');
    print('$paidStatus$noteText');
  }
}

void main() {
  print('🏦 EXPENSE MANAGER WITH VALIDATION\n');

  // Create valid expenses
  var coffee = Expense.quick('Morning coffee', 4.50, 'Food');
  var rent = Expense(
    description: 'Monthly rent',
    amount: 1200.0,
    category: 'Bills',
    isPaid: true,
  );

  coffee.printDetails();
  print('');
  rent.printDetails();

  print('\n📝 TESTING VALIDATION:\n');

  // Test setters
  print('Changing coffee amount to 5.00...');
  coffee.amount = 5.00;
  print('✅ Success! New amount: ${coffee.formattedAmount}');

  try {
    print('\nTrying to set negative amount...');
    coffee.amount = -10;
  } catch (e) {
    print('❌ Caught error: $e');
  }

  try {
    print('\nTrying to set empty description...');
    coffee.description = '';
  } catch (e) {
    print('❌ Caught error: $e');
  }

  try {
    print('\nTrying invalid category...');
    coffee.category = 'InvalidCategory';
  } catch (e) {
    print('❌ Caught error: $e');
  }

  print('\n✅ Adding valid note...');
  coffee.addNote('Bought at Starbucks');
  coffee.printDetails();
}

Part 8: Why Encapsulation Matters

Real-World Benefits:

1. Data Integrity 🛡️

// Without encapsulation - bugs everywhere!
expense.amount = -999;  // Oops!
expense.category = 'asfgh';  // Typo!

// With encapsulation - protected!
expense.amount = -999;  // ❌ Throws error
expense.category = 'asfgh';  // ❌ Throws error

2. Easier Debugging 🐛

// Without encapsulation - amount changes everywhere
// Where did the bug come from? No idea!

// With encapsulation - only through setters
// Search for "set amount" to find where it changes

3. Future Changes 🔄

// Need to change how amount is stored?
// With encapsulation, change internal code only
// External code using getters/setters keeps working!

class Expense {
  int _amountInCents;  // Changed storage format

  double get amount => _amountInCents / 100;  // Convert on read
  set amount(double value) => _amountInCents = (value * 100).round();
}

4. Business Rules 📋

// Enforce business logic in one place
set amount(double value) {
  if (value < 0) throw Exception('Negative amount');
  if (value > 10000) {
    print('⚠️ Large amount! Requires approval.');
  }
  _amount = value;
}

🎯 Practice Exercises

Exercise 1: Protected Category Class (Easy)

Create a Category class with:

Private properties: _name, _icon, _budget
Getters for all properties
Setter for budget that only allows positive values
Computed getter isOverBudget(double spent) that returns true if spent > budget

Solution:

class Category {
  String _name;
  String _icon;
  double _budget;

  Category(this._name, this._icon, this._budget) {
    if (_budget < 0) {
      throw Exception('Budget cannot be negative');
    }
  }

  // Getters
  String get name => _name;
  String get icon => _icon;
  double get budget => _budget;

  // Setter with validation
  set budget(double value) {
    if (value < 0) {
      throw Exception('Budget cannot be negative');
    }
    _budget = value;
  }

  // Method
  bool isOverBudget(double spent) {
    return spent > _budget;
  }

  void printStatus(double spent) {
    String status = isOverBudget(spent) ? '❌ Over budget!' : '✅ Within budget';
    print('$_icon $_name: \$${spent.toStringAsFixed(2)} / \$${_budget.toStringAsFixed(2)} - $status');
  }
}

void main() {
  var food = Category('Food', '🍔', 500.0);

  food.printStatus(350.0);  // Within budget
  food.printStatus(550.0);  // Over budget

  // Test validation
  try {
    food.budget = -100;
  } catch (e) {
    print('Error: $e');
  }
}

Exercise 2: Smart User Class (Medium)

Create a User class with:

Private: _name, _email, _age
Validate email must contain '@'
Validate age must be between 13 and 120
Computed getter isAdult (age >= 18)
Computed getter displayName (name + age category)

Solution:

class User {
  String _name;
  String _email;
  int _age;

  User({
    required String name,
    required String email,
    required int age,
  }) : _name = name,
       _email = email,
       _age = age {
    if (!_email.contains('@')) {
      throw Exception('Invalid email format');
    }
    if (_age < 13 || _age > 120) {
      throw Exception('Age must be between 13 and 120');
    }
  }

  // Getters
  String get name => _name;
  String get email => _email;
  int get age => _age;

  // Computed getters
  bool get isAdult => _age >= 18;

  String get ageCategory {
    if (_age < 18) return 'Minor';
    if (_age < 65) return 'Adult';
    return 'Senior';
  }

  String get displayName => '$_name ($ageCategory, $_age)';

  // Setters with validation
  set email(String value) {
    if (!value.contains('@')) {
      throw Exception('Invalid email format');
    }
    _email = value;
  }

  set age(int value) {
    if (value < 13 || value > 120) {
      throw Exception('Age must be between 13 and 120');
    }
    _age = value;
  }

  void printProfile() {
    print('👤 $displayName');
    print('📧 $_email');
    print('Status: ${isAdult ? "Adult ✅" : "Minor ❌"}');
  }
}

void main() {
  var user = User(name: 'John Doe', email: 'john@example.com', age: 25);
  user.printProfile();

  print('\n--- Testing validation ---');

  try {
    user.email = 'invalidemail';
  } catch (e) {
    print('❌ $e');
  }

  try {
    user.age = 150;
  } catch (e) {
    print('❌ $e');
  }
}

Exercise 3: Bank Account Class (Hard)

Create a BankAccount class with:

Private: _accountHolder, _balance, _pin
Methods: deposit(amount), withdraw(amount, pin)
Cannot withdraw without correct PIN
Cannot withdraw more than balance
Cannot deposit negative amounts
Getter for balance (but not setter!)
Method changePin(oldPin, newPin)

Solution:

class BankAccount {
  String _accountHolder;
  double _balance;
  String _pin;

  BankAccount({
    required String accountHolder,
    required String pin,
    double initialBalance = 0,
  }) : _accountHolder = accountHolder,
       _pin = pin,
       _balance = initialBalance {
    if (_pin.length != 4) {
      throw Exception('PIN must be 4 digits');
    }
    if (_balance < 0) {
      throw Exception('Initial balance cannot be negative');
    }
  }

  // Getters
  String get accountHolder => _accountHolder;
  double get balance => _balance;  // Read-only, no setter!

  // Deposit method
  void deposit(double amount) {
    if (amount <= 0) {
      print('❌ Deposit amount must be positive');
      return;
    }
    _balance += amount;
    print('✅ Deposited \$${amount.toStringAsFixed(2)}. New balance: \$${_balance.toStringAsFixed(2)}');
  }

  // Withdraw method with PIN validation
  bool withdraw(double amount, String pin) {
    if (pin != _pin) {
      print('❌ Incorrect PIN');
      return false;
    }

    if (amount <= 0) {
      print('❌ Withdrawal amount must be positive');
      return false;
    }

    if (amount > _balance) {
      print('❌ Insufficient funds. Balance: \$${_balance.toStringAsFixed(2)}');
      return false;
    }

    _balance -= amount;
    print('✅ Withdrew \$${amount.toStringAsFixed(2)}. New balance: \$${_balance.toStringAsFixed(2)}');
    return true;
  }

  // Change PIN
  bool changePin(String oldPin, String newPin) {
    if (oldPin != _pin) {
      print('❌ Incorrect old PIN');
      return false;
    }

    if (newPin.length != 4) {
      print('❌ New PIN must be 4 digits');
      return false;
    }

    _pin = newPin;
    print('✅ PIN changed successfully');
    return true;
  }

  void printStatement() {
    print('─────────────────────────────');
    print('Account Holder: $_accountHolder');
    print('Balance: \$${_balance.toStringAsFixed(2)}');
    print('─────────────────────────────');
  }
}

void main() {
  var account = BankAccount(
    accountHolder: 'John Doe',
    pin: '1234',
    initialBalance: 1000.0,
  );

  account.printStatement();

  print('\n--- Transactions ---');
  account.deposit(500.0);
  account.withdraw(200.0, '1234');
  account.withdraw(200.0, '0000');  // Wrong PIN
  account.withdraw(2000.0, '1234');  // Insufficient funds

  print('\n--- Change PIN ---');
  account.changePin('0000', '5678');  // Wrong old PIN
  account.changePin('1234', '5678');  // Success

  print('');
  account.printStatement();
}

Common Mistakes & How to Fix Them

Mistake 1: Forgetting the Underscore

// ❌ Wrong - not private
String description;

// ✅ Correct - private
String _description;

Mistake 2: Making Getter and Setter Names Different

// ❌ Wrong - names don't match
double get amount => _amount;
set setAmount(double value) { _amount = value; }

// ✅ Correct - same name
double get amount => _amount;
set amount(double value) { _amount = value; }

Mistake 3: Forgetting Validation

// ❌ Wrong - no validation
set amount(double value) {
  _amount = value;
}

// ✅ Correct - validate first
set amount(double value) {
  if (value < 0) {
    throw Exception('Amount cannot be negative');
  }
  _amount = value;
}

Mistake 4: Direct Access to Private Properties Outside Class

// ❌ Wrong - trying to access private property
print(expense._amount);

// ✅ Correct - use getter
print(expense.amount);

Key Concepts Review

✅ Private properties use underscore _ prefix

✅ Getters provide read access with get keyword

✅ Setters provide write access with set keyword and validation

✅ Validation prevents invalid data from entering your objects

✅ Encapsulation protects data and enforces business rules

✅ Computed getters calculate values on-the-fly

✅ Data integrity is maintained through controlled access

Self-Check Questions

1. What does encapsulation mean?

Answer:
Encapsulation means hiding internal data and providing controlled access through getters and setters. It protects data from invalid changes and enforces business rules.

2. Why use getters and setters instead of public properties?

Answer:

Validate data before accepting changes
Prevent invalid states (like negative amounts)
Can change internal implementation without breaking external code
Enforce business rules in one place
Better debugging (know where data changes)

3. What's the difference between a regular getter and a computed getter?

Answer:

Regular getter: Returns a stored private property (get amount => _amount)
Computed getter: Calculates a value on-the-fly (get isAdult => _age >= 18)

What's Next?

In Lesson 5: Adding Useful Features, we'll learn:

More advanced methods for our Expense class
Working with lists of expenses
Filtering and sorting
Calculating totals and statistics
Building helper methods

Example preview:

class ExpenseManager {
  List<Expense> _expenses = [];

  void addExpense(Expense expense) { ... }
  double getTotalSpending() { ... }
  List<Expense> getByCategory(String category) { ... }
  Expense? getLargestExpense() { ... }
}

See you in Lesson 5! 🚀

Additional Resources

Practice creating other protected classes: CreditCard, Budget, UserProfile
Think about what data should be protected in a real app
Consider what validation rules make sense for your expense manager

Remember: Encapsulation isn't about making everything private - it's about protecting data that needs protection and providing safe ways to interact with it! 🔒

Dart Object Oriented For Beginner : Expense Manager Case Study Part 3

Putra Prima A — Wed, 08 Oct 2025 22:48:43 +0000

Lesson 3: Different Ways to Create Expenses

Duration: 25 minutes

App Feature: 🔧 Making Expense Creation Easier

What You'll Build: Add multiple ways to create expenses with constructors

Prerequisites: Complete Lesson 1 & 2

What We'll Learn Today

By the end of this lesson, you'll be able to:

✅ Create named constructors for easier object creation
✅ Use optional parameters
✅ Set default values
✅ Build multiple constructor variations
✅ Make your code more flexible and user-friendly

Review: What We Know About Constructors

In Lesson 2, we learned the basic constructor:

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  Expense(this.description, this.amount, this.category, this.date);
}

void main() {
  var coffee = Expense('Coffee', 4.50, 'Food', DateTime.now());
}

The Problem: Every time we create an expense, we need to provide ALL four values. But what if:

Most expenses are from today? (we always type DateTime.now())
We want quick shortcuts for common scenarios?
Some values have sensible defaults?

The Solution: Named constructors and optional parameters!

Part 1: Named Constructors

A named constructor is an alternative way to create objects. You can have multiple constructors in one class, each with a different name.

Syntax:

ClassName.constructorName(parameters)

Example: Quick Expense Constructor

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  // Regular constructor
  Expense(this.description, this.amount, this.category, this.date);

  // Named constructor - assumes today's date
  Expense.quick(this.description, this.amount, this.category) 
    : date = DateTime.now();
}

void main() {
  // Using regular constructor
  var laptop = Expense('Laptop', 899.99, 'Electronics', DateTime(2025, 10, 5));

  // Using named constructor - much shorter!
  var coffee = Expense.quick('Coffee', 4.50, 'Food');
  var lunch = Expense.quick('Lunch', 12.75, 'Food');

  print('${coffee.description}: \$${coffee.amount} on ${coffee.date}');
}

Understanding the Syntax:

Expense.quick(this.description, this.amount, this.category) 
  : date = DateTime.now();

Expense.quick = class name + dot + constructor name
Parameters in () work like normal constructor
: date = DateTime.now() is the initializer list
Sets date property before the object is fully created

Part 2: Building a Better Expense Class

Let's add several named constructors for common scenarios:

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  // 1. Regular constructor - full control
  Expense(this.description, this.amount, this.category, this.date);

  // 2. Quick constructor - assumes today
  Expense.quick(this.description, this.amount, this.category) 
    : date = DateTime.now();

  // 3. Monthly bill constructor - assumes "Bills" category
  Expense.monthly(this.description, this.amount) 
    : category = 'Bills',
      date = DateTime.now();

  // 4. Yesterday constructor - for when you forget to log
  Expense.yesterday(this.description, this.amount, this.category) 
    : date = DateTime.now().subtract(Duration(days: 1));

  void printDetails() {
    print('$description: \$${amount.toStringAsFixed(2)} [$category] on ${date.toString().split(' ')[0]}');
  }
}

void main() {
  print('MY EXPENSES:\n');

  // Using different constructors
  var rent = Expense.monthly('Rent', 1200.0);
  var coffee = Expense.quick('Coffee', 4.50, 'Food');
  var dinner = Expense.yesterday('Dinner', 35.00, 'Food');
  var vacation = Expense('Flight', 450.0, 'Travel', DateTime(2025, 12, 20));

  rent.printDetails();
  coffee.printDetails();
  dinner.printDetails();
  vacation.printDetails();
}

Output:

MY EXPENSES:

Rent: $1200.00 [Bills] on 2025-10-09
Coffee: $4.50 [Food] on 2025-10-09
Dinner: $35.00 [Food] on 2025-10-08
Flight: $450.00 [Travel] on 2025-12-20

Part 3: Multiple Initializations in Initializer List

You can set multiple properties in the initializer list:

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  Expense(this.description, this.amount, this.category, this.date);

  // Initialize BOTH category and date
  Expense.subscription(this.description, this.amount) 
    : category = 'Entertainment',
      date = DateTime.now();

  // Initialize with calculations
  Expense.weekly(this.description, double weeklyAmount) 
    : amount = weeklyAmount * 52,  // Convert to yearly
      category = 'Recurring',
      date = DateTime.now();
}

void main() {
  var netflix = Expense.subscription('Netflix', 15.99);
  var coffee = Expense.weekly('Coffee habit', 25.00);  // $25/week

  netflix.printDetails();
  print('Coffee yearly: \$${coffee.amount.toStringAsFixed(2)}');
}

Key Points:

Separate multiple initializations with commas
Can include calculations or method calls
Runs BEFORE the constructor body (if you have one)

Part 4: Optional Parameters

Sometimes you want parameters that are... optional! Dart has two ways to do this:

A. Optional Positional Parameters (with `[]`)

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;
  String? notes;  // Nullable - can be null

  // Optional positional parameters in square brackets
  Expense(this.description, this.amount, this.category, [DateTime? date, this.notes]) 
    : date = date ?? DateTime.now();  // Use provided date OR current date
}

void main() {
  // With date and notes
  var expense1 = Expense('Laptop', 899.99, 'Electronics', DateTime(2025, 10, 5), 'Work laptop');

  // Without date (uses today)
  var expense2 = Expense('Coffee', 4.50, 'Food');

  // With date but no notes
  var expense3 = Expense('Dinner', 45.00, 'Food', DateTime(2025, 10, 8));
}

Understanding ?? operator:

date ?? DateTime.now() means: "use date if provided, otherwise use DateTime.now()"
This is called the "null-aware" operator

B. Named Optional Parameters (with `{}`)

Named parameters are more readable and can be provided in any order:

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;
  String? notes;
  bool isPaid;

  // Named optional parameters in curly braces
  Expense({
    required this.description,
    required this.amount,
    required this.category,
    DateTime? date,
    this.notes,
    this.isPaid = false,  // Default value
  }) : date = date ?? DateTime.now();
}

void main() {
  // Can provide parameters in any order
  var expense1 = Expense(
    amount: 45.00,
    description: 'Dinner',
    category: 'Food',
    notes: 'Birthday dinner',
    isPaid: true,
  );

  // Can skip optional parameters
  var expense2 = Expense(
    description: 'Coffee',
    amount: 4.50,
    category: 'Food',
  );

  // Can provide date if needed
  var expense3 = Expense(
    description: 'Rent',
    amount: 1200.0,
    category: 'Bills',
    date: DateTime(2025, 10, 1),
  );
}

Key Differences:

Feature	Positional `[]`	Named `{}`
Order matters	✅ Yes	❌ No
More readable	❌ Less	✅ More
Can be required	❌ No	✅ Yes (with `required`)
Default values	✅ Yes	✅ Yes

Part 5: Default Values

You can provide default values for optional parameters:

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;
  String currency;
  bool isPaid;

  Expense({
    required this.description,
    required this.amount,
    this.category = 'Other',        // Default: 'Other'
    DateTime? date,
    this.currency = 'USD',           // Default: 'USD'
    this.isPaid = false,             // Default: false
  }) : date = date ?? DateTime.now();

  void printDetails() {
    String paidStatus = isPaid ? '✅ Paid' : '❌ Unpaid';
    print('$description: $currency \$${amount.toStringAsFixed(2)} [$category] - $paidStatus');
  }
}

void main() {
  // Using all defaults
  var expense1 = Expense(
    description: 'Mystery purchase',
    amount: 25.00,
  );

  // Override some defaults
  var expense2 = Expense(
    description: 'Rent',
    amount: 1200.0,
    category: 'Bills',
    isPaid: true,
  );

  // Override currency
  var expense3 = Expense(
    description: 'Tokyo hotel',
    amount: 15000,
    currency: 'JPY',
    category: 'Travel',
  );

  expense1.printDetails();
  expense2.printDetails();
  expense3.printDetails();
}

Output:

Mystery purchase: USD $25.00 [Other] - ❌ Unpaid
Rent: USD $1200.00 [Bills] - ✅ Paid
Tokyo hotel: JPY $15000.00 [Travel] - ❌ Unpaid

Part 6: Combining Named Constructors with Optional Parameters

The most powerful approach combines both techniques:

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;
  String? notes;
  bool isPaid;

  // Regular constructor with named parameters
  Expense({
    required this.description,
    required this.amount,
    required this.category,
    DateTime? date,
    this.notes,
    this.isPaid = false,
  }) : date = date ?? DateTime.now();

  // Named constructor: quick expense (today, unpaid)
  Expense.quick(
    this.description,
    this.amount,
    this.category, {
    this.notes,
  }) : date = DateTime.now(),
       isPaid = false;

  // Named constructor: monthly bill (bills category, today, paid)
  Expense.bill(
    this.description,
    this.amount, {
    this.notes,
  }) : category = 'Bills',
       date = DateTime.now(),
       isPaid = true;

  // Named constructor: recurring subscription
  Expense.subscription({
    required this.description,
    required this.amount,
    this.notes,
  }) : category = 'Entertainment',
       date = DateTime.now(),
       isPaid = true;

  void printDetails() {
    String paid = isPaid ? '✅' : '❌';
    String noteText = notes != null ? ' - $notes' : '';
    print('$paid $description: \$${amount.toStringAsFixed(2)} [$category]$noteText');
  }
}

void main() {
  print('OCTOBER EXPENSES:\n');

  // Different ways to create expenses
  var coffee = Expense.quick('Coffee', 4.50, 'Food');

  var rent = Expense.bill('Rent', 1200.0, notes: 'October payment');

  var netflix = Expense.subscription(
    description: 'Netflix',
    amount: 15.99,
    notes: 'Premium plan',
  );

  var dinner = Expense(
    description: 'Dinner date',
    amount: 85.50,
    category: 'Food',
    notes: 'Anniversary',
  );

  coffee.printDetails();
  rent.printDetails();
  netflix.printDetails();
  dinner.printDetails();
}

Output:

OCTOBER EXPENSES:

❌ Coffee: $4.50 [Food]
✅ Rent: $1200.00 [Bills] - October payment
✅ Netflix: $15.99 [Entertainment] - Premium plan
❌ Dinner date: $85.50 [Food] - Anniversary

Part 7: Real-World Example - Complete Expense Class

Here's a production-ready Expense class with multiple constructors:

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;
  String? notes;
  bool isPaid;
  String paymentMethod;

  // Main constructor - full control
  Expense({
    required this.description,
    required this.amount,
    required this.category,
    DateTime? date,
    this.notes,
    this.isPaid = false,
    this.paymentMethod = 'Cash',
  }) : date = date ?? DateTime.now();

  // Quick daily expense
  Expense.quick(
    this.description,
    this.amount,
    this.category,
  ) : date = DateTime.now(),
      notes = null,
      isPaid = false,
      paymentMethod = 'Cash';

  // Monthly recurring bill
  Expense.monthlyBill(
    this.description,
    this.amount, {
    this.paymentMethod = 'Auto-pay',
  }) : category = 'Bills',
       date = DateTime.now(),
       notes = 'Monthly recurring',
       isPaid = true;

  // Credit card purchase
  Expense.creditCard(
    this.description,
    this.amount,
    this.category, {
    this.notes,
  }) : date = DateTime.now(),
       isPaid = false,
       paymentMethod = 'Credit Card';

  // Cash purchase (already paid)
  Expense.cash(
    this.description,
    this.amount,
    this.category, {
    this.notes,
  }) : date = DateTime.now(),
       isPaid = true,
       paymentMethod = 'Cash';

  // Yesterday's expense (for when you forget to log)
  Expense.yesterday(
    this.description,
    this.amount,
    this.category,
  ) : date = DateTime.now().subtract(Duration(days: 1)),
      notes = 'Logged late',
      isPaid = true,
      paymentMethod = 'Cash';

  void printDetails() {
    String paid = isPaid ? '✅ Paid' : '❌ Unpaid';
    String noteText = notes != null ? '\n   Note: $notes' : '';
    print('─────────────────────────────');
    print('$description');
    print('Amount: \$${amount.toStringAsFixed(2)}');
    print('Category: $category');
    print('Date: ${date.toString().split(' ')[0]}');
    print('Payment: $paymentMethod');
    print('Status: $paid$noteText');
  }

  bool isMajorExpense() => amount > 100;

  String getSummary() {
    String emoji = isMajorExpense() ? '🔴' : '🟢';
    return '$emoji \$${amount.toStringAsFixed(2)} - $description [$category]';
  }
}

void main() {
  print('📊 EXPENSE TRACKER\n');

  var expenses = [
    Expense.quick('Morning coffee', 4.50, 'Food'),
    Expense.monthlyBill('Internet', 59.99),
    Expense.creditCard('Groceries', 127.50, 'Food', notes: 'Weekly shopping'),
    Expense.cash('Parking', 5.00, 'Transport'),
    Expense.yesterday('Lunch', 15.00, 'Food'),
    Expense(
      description: 'New laptop',
      amount: 1299.99,
      category: 'Electronics',
      paymentMethod: 'Credit Card',
      notes: 'Work equipment',
    ),
  ];

  // Print all summaries
  print('Summary:');
  for (var expense in expenses) {
    print(expense.getSummary());
  }

  // Print details of major expenses
  print('\n\nMAJOR EXPENSES (>\$100):');
  for (var expense in expenses) {
    if (expense.isMajorExpense()) {
      expense.printDetails();
    }
  }

  // Calculate totals
  double total = 0;
  double unpaid = 0;

  for (var expense in expenses) {
    total += expense.amount;
    if (!expense.isPaid) {
      unpaid += expense.amount;
    }
  }

  print('\n─────────────────────────────');
  print('💰 Total Expenses: \$${total.toStringAsFixed(2)}');
  print('❌ Unpaid: \$${unpaid.toStringAsFixed(2)}');
  print('✅ Paid: \$${(total - unpaid).toStringAsFixed(2)}');
}

🎯 Practice Exercises

Exercise 1: Create a Budget Class (Easy)

Create a Budget class with:

Properties: category, limit, month, year
Regular constructor
Named constructor Budget.monthly(category, limit) that uses current month/year

Solution:

class Budget {
  String category;
  double limit;
  int month;
  int year;

  Budget(this.category, this.limit, this.month, this.year);

  Budget.monthly(this.category, this.limit)
    : month = DateTime.now().month,
      year = DateTime.now().year;

  void printDetails() {
    print('$category: \$${limit.toStringAsFixed(2)} for $month/$year');
  }
}

void main() {
  var foodBudget = Budget.monthly('Food', 500.0);
  var rentBudget = Budget('Rent', 1200.0, 10, 2025);

  foodBudget.printDetails();
  rentBudget.printDetails();
}

Exercise 2: Enhanced Expense Creation (Medium)

Add these named constructors to your Expense class:

Expense.splitBill(description, totalAmount, numberOfPeople) - divides amount by number of people
Expense.tip(description, baseAmount, tipPercent) - calculates total with tip
Expense.recurring(description, amount, frequency) - where frequency is 'weekly', 'monthly', or 'yearly'

Solution:

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;
  String? notes;

  Expense(this.description, this.amount, this.category, this.date, {this.notes});

  // Split bill constructor
  Expense.splitBill(
    String desc,
    double totalAmount,
    int people,
  ) : description = '$desc (split $people ways)',
      amount = totalAmount / people,
      category = 'Food',
      date = DateTime.now(),
      notes = 'Split with $people people';

  // Tip calculator constructor
  Expense.tip(
    String desc,
    double baseAmount,
    double tipPercent,
  ) : description = desc,
      amount = baseAmount * (1 + tipPercent / 100),
      category = 'Food',
      date = DateTime.now(),
      notes = '${tipPercent}% tip included';

  // Recurring expense constructor
  Expense.recurring(
    this.description,
    this.amount,
    String frequency,
  ) : category = 'Bills',
      date = DateTime.now(),
      notes = 'Recurring: $frequency';
}

void main() {
  var dinner = Expense.splitBill('Restaurant dinner', 120.00, 4);
  var lunch = Expense.tip('Lunch', 25.00, 20);
  var gym = Expense.recurring('Gym membership', 45.00, 'monthly');

  print('${dinner.description}: \$${dinner.amount.toStringAsFixed(2)} - ${dinner.notes}');
  print('${lunch.description}: \$${lunch.amount.toStringAsFixed(2)} - ${lunch.notes}');
  print('${gym.description}: \$${gym.amount.toStringAsFixed(2)} - ${gym.notes}');
}

Exercise 3: Flexible User Class (Hard)

Create a User class for your expense app with:

Properties: name, email, currency, monthlyBudget, notifications
Main constructor with named parameters (all required except notifications default = true)
User.quick(name, email) - uses USD currency, $2000 budget
User.premium(name, email, monthlyBudget) - USD currency, notifications on

Solution:

class User {
  String name;
  String email;
  String currency;
  double monthlyBudget;
  bool notifications;

  User({
    required this.name,
    required this.email,
    required this.currency,
    required this.monthlyBudget,
    this.notifications = true,
  });

  User.quick(this.name, this.email)
    : currency = 'USD',
      monthlyBudget = 2000.0,
      notifications = true;

  User.premium(this.name, this.email, this.monthlyBudget)
    : currency = 'USD',
      notifications = true;

  void printProfile() {
    String notif = notifications ? '✅' : '❌';
    print('─────────────────');
    print('👤 $name');
    print('📧 $email');
    print('💵 Budget: $currency \$${monthlyBudget.toStringAsFixed(2)}/month');
    print('🔔 Notifications: $notif');
  }
}

void main() {
  var user1 = User.quick('John Doe', 'john@example.com');
  var user2 = User.premium('Jane Smith', 'jane@example.com', 3500.0);
  var user3 = User(
    name: 'Bob Wilson',
    email: 'bob@example.com',
    currency: 'EUR',
    monthlyBudget: 2500.0,
    notifications: false,
  );

  user1.printProfile();
  user2.printProfile();
  user3.printProfile();
}

Common Mistakes & How to Fix Them

Mistake 1: Forgetting Initializer List Colon

// ❌ Wrong
Expense.quick(this.description, this.amount, this.category) 
  date = DateTime.now();

// ✅ Correct - need the colon
Expense.quick(this.description, this.amount, this.category) 
  : date = DateTime.now();

Mistake 2: Mixing Positional and Named Parameters Incorrectly

// ❌ Wrong - can't mix freely
Expense(this.description, {required this.amount}, this.category);

// ✅ Correct - positional first, then named
Expense(this.description, this.category, {required this.amount});

Mistake 3: Not Using `required` for Named Parameters

// ❌ Wrong - amount could be null
Expense({this.description, this.amount, this.category});

// ✅ Correct - make required fields explicit
Expense({
  required this.description,
  required this.amount,
  required this.category,
});

Mistake 4: Forgetting `this` in Named Constructors

// ❌ Wrong
Expense.quick(description, amount, category)
  : date = DateTime.now();

// ✅ Correct
Expense.quick(this.description, this.amount, this.category)
  : date = DateTime.now();

Key Concepts Review

✅ Named constructors let you create objects in different ways

✅ Initializer lists (:) set properties before object creation

✅ Optional positional parameters use [] brackets

✅ Named parameters use {} curly braces and are more readable

✅ Default values make parameters optional with sensible defaults

✅ required keyword makes named parameters mandatory

✅ Combine techniques for maximum flexibility

Self-Check Questions

1. What's the difference between a regular constructor and a named constructor?

Answer:

Regular constructor: Expense(...) - only one per class
Named constructor: Expense.quick(...) - can have multiple with different names, each providing different ways to create objects

2. What does the `:` (colon) mean in a constructor?

Answer:
The colon starts the initializer list, where you can set property values before the constructor body runs. It's used to initialize properties that aren't in the parameter list.

3. When should you use named parameters vs positional parameters?

Answer:

Positional: When order is obvious and there are few parameters (2-3)
Named: When you have many parameters, some are optional, or readability is important

What's Next?

In Lesson 4: Encapsulation, we'll learn:

How to make properties private (with _ underscore)
Why we should hide internal data
Getters and setters for controlled access
Validation to prevent invalid data
Keeping our expense data safe!

Example preview:

class Expense {
  String _description;  // Private!
  double _amount;       // Private!

  // Can't do: expense._amount = -100;
  // Must use: expense.setAmount(100);

  set amount(double value) {
    if (value < 0) {
      print('❌ Amount cannot be negative!');
      return;
    }
    _amount = value;
  }
}

See you in Lesson 4! 🚀

Additional Resources

Try creating constructors for other classes: Category, PaymentMethod, Budget
Experiment with combining multiple techniques
Think about which constructor style makes your code most readable

Remember: The goal is to make object creation easy and intuitive for whoever uses your class (including future you)! 💪

Dart Object Oriented For Beginner : Expense Manager Case Study Part 2

Putra Prima A — Wed, 08 Oct 2025 22:48:24 +0000

Lesson 2: Creating Your First Class

Duration: 30 minutes

App Feature: 💰 Building the Expense Class

What You'll Build: Create an Expense class to represent a single expense

Prerequisites: Complete Lesson 1

What We'll Learn Today

By the end of this lesson, you'll be able to:

✅ Write your first Dart class
✅ Understand properties (instance variables)
✅ Create objects from your class
✅ Use constructors to initialize objects
✅ Add methods to make objects do things
✅ Work with multiple expense objects

Review: What is a Class?

Remember from Lesson 1:

A class is a blueprint/template
An object is an actual instance created from that class
Example: Expense class → your coffee purchase object

Today we're going to actually write this code ourselves!

Part 1: Your First Class (The Basic Structure)

Let's start with the simplest possible Expense class:

class Expense {
  // Properties (also called instance variables or fields)
  String description;
  double amount;
  String category;
  DateTime date;

  // Constructor is required for null safety
  Expense({
    required this.description,
    required this.amount,
    required this.category,
    required this.date,
  });
}

Breaking It Down:

class Expense {

class keyword tells Dart we're creating a new class
Expense is the name (always start with capital letter!)
{ opens the class body

  String description;
  double amount;
  String category;
  DateTime date;

These are properties - data that each expense will store
String = text (description, category)
double = decimal number (amount like 4.50)
DateTime = date and time
All properties are non-nullable (must have a value)

  Expense({
    required this.description,
    required this.amount,
    required this.category,
    required this.date,
  });

Constructor with named parameters
required keyword ensures you can't forget to set values
This prevents null safety errors!

Closes the class body

🎯 Try It Yourself:

Create a file called expense.dart and type this class. Pay attention to:

Capital E in Expense
Semicolons ; after each property
Proper indentation (2 or 4 spaces)
The required keyword for null safety

Part 2: Creating Objects (Instances)

Now that we have our class, let's create actual expense objects!

void main() {
  // Create an object using the class
  var coffee = Expense(
    description: 'Morning coffee',
    amount: 4.50,
    category: 'Food',
    date: DateTime.now(),
  );

  // Print the details
  print('I spent \$${coffee.amount} on ${coffee.description}');
}

Understanding the Code:

var coffee = Expense(
  description: 'Morning coffee',
  amount: 4.50,
  category: 'Food',
  date: DateTime.now(),
);

var = variable (Dart figures out the type)
coffee = variable name (our choice)
Expense(...) = calling the class to create a new object
Named parameters make it clear what each value represents
Must provide all required parameters

coffee.description

Use dot notation (.) to access properties
Properties are already set by the constructor

DateTime.now()

Gets the current date and time
Perfect for tracking when you made the expense

🎯 Try It Yourself:

Add this code and run it. You should see:

I spent $4.50 on Morning coffee

Part 3: Why Null Safety Matters

With null safety, Dart prevents common bugs:

void main() {
  // ❌ This won't compile - missing required parameters!
  // var expense = Expense();

  // ✅ This is correct - all required values provided
  var expense = Expense(
    description: 'Coffee',
    amount: 4.50,
    category: 'Food',
    date: DateTime.now(),
  );

  // No need to check for null!
  print('Amount: ${expense.amount}'); // Always has a value
}

Benefits of Null Safety:

✅ Can't forget to set required values
✅ No null pointer errors
✅ IDE helps you with required parameters
✅ Code is safer and more reliable

Part 4: Positional vs Named Parameters

You can choose between two constructor styles:

Positional Parameters (Order matters):

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  // Positional constructor
  Expense(this.description, this.amount, this.category, this.date);
}

void main() {
  // Must be in exact order
  var coffee = Expense('Coffee', 4.50, 'Food', DateTime.now());
}

Named Parameters (Order doesn't matter):

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  // Named constructor
  Expense({
    required this.description,
    required this.amount,
    required this.category,
    required this.date,
  });
}

void main() {
  // Can be in any order, very clear
  var coffee = Expense(
    category: 'Food',
    description: 'Coffee',
    date: DateTime.now(),
    amount: 4.50,
  );
}

Recommendation: Use named parameters for classes with multiple properties. They're more readable and prevent mistakes!

🎯 Try It Yourself:

Update your Expense class to use named parameters and create 3 different expenses:

void main() {
  var coffee = Expense(
    description: 'Coffee',
    amount: 4.50,
    category: 'Food',
    date: DateTime.now(),
  );

  var lunch = Expense(
    description: 'Lunch at cafe',
    amount: 12.75,
    category: 'Food',
    date: DateTime.now(),
  );

  var netflix = Expense(
    description: 'Netflix subscription',
    amount: 15.99,
    category: 'Entertainment',
    date: DateTime.now(),
  );

  print('${coffee.description}: \$${coffee.amount}');
  print('${lunch.description}: \$${lunch.amount}');
  print('${netflix.description}: \$${netflix.amount}');
}

Part 5: Working with Multiple Objects

Now that we can create individual expenses, let's work with multiple objects using lists:

void main() {
  // Create a list to store multiple expenses
  var expenses = [
    Expense(
      description: 'Coffee',
      amount: 4.50,
      category: 'Food',
      date: DateTime.now(),
    ),
    Expense(
      description: 'Uber to work',
      amount: 8.20,
      category: 'Transport',
      date: DateTime.now(),
    ),
    Expense(
      description: 'Movie ticket',
      amount: 12.00,
      category: 'Entertainment',
      date: DateTime.now(),
    ),
  ];

  // Loop through and print each expense
  print('My Expenses:');
  for (var expense in expenses) {
    print('${expense.description}: \$${expense.amount}');
  }

  // Calculate total
  double total = 0;
  for (var expense in expenses) {
    total += expense.amount;
  }
  print('\nTotal: \$${total.toStringAsFixed(2)}');
}

Understanding Lists of Objects:

var expenses = [
  Expense(...),
  Expense(...),
  Expense(...),
];

Square brackets [] create a list
Each item is an Expense object
Comma after each object

for (var expense in expenses) {
  print('${expense.description}: \$${expense.amount}');
}

Loop through each expense in the list
expense is each individual object
Access properties with dot notation

🎯 Try It Yourself:

Create a list of 5 expenses from your recent spending and:

Print all expenses
Calculate the total amount
Count how many food expenses you have

Hint for counting:

int foodCount = 0;
for (var expense in expenses) {
  if (expense.category == 'Food') {
    foodCount++;
  }
}
print('Food expenses: $foodCount');

Part 6: Adding Methods (Making Objects DO Things)

So far our objects just hold data. Let's make them do something useful!

A method is a function inside a class that can work with the object's data.

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  Expense({
    required this.description,
    required this.amount,
    required this.category,
    required this.date,
  });

  // Method to print expense details
  void printDetails() {
    print('━━━━━━━━━━━━━━━━━━━━');
    print('📝 Description: $description');
    print('💵 Amount: \$${amount.toStringAsFixed(2)}');
    print('📁 Category: $category');
    print('📅 Date: ${date.toString().split(' ')[0]}');
    print('━━━━━━━━━━━━━━━━━━━━');
  }
}

void main() {
  var coffee = Expense(
    description: 'Morning coffee',
    amount: 4.50,
    category: 'Food',
    date: DateTime.now(),
  );

  // Call the method
  coffee.printDetails();
}

Understanding Methods:

void printDetails() {

void = doesn't return anything
printDetails = method name (use camelCase)
() = no parameters needed

print('💵 Amount: \$${amount.toStringAsFixed(2)}');

Inside methods, we can directly access properties
No need for this.amount, just amount
\$ escapes the dollar sign so it prints literally
toStringAsFixed(2) formats to 2 decimal places

coffee.printDetails();

Call methods using dot notation
Don't forget the ()!

🎯 Try It Yourself:

Add the printDetails() method and create 3 expenses. Call printDetails() on each:

void main() {
  var coffee = Expense(
    description: 'Coffee',
    amount: 4.50,
    category: 'Food',
    date: DateTime.now(),
  );

  var uber = Expense(
    description: 'Uber to work',
    amount: 8.20,
    category: 'Transport',
    date: DateTime.now(),
  );

  var movie = Expense(
    description: 'Movie ticket',
    amount: 12.00,
    category: 'Entertainment',
    date: DateTime.now(),
  );

  coffee.printDetails();
  uber.printDetails();
  movie.printDetails();
}

Part 7: Methods That Return Values

Methods can also calculate and return values:

class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  Expense({
    required this.description,
    required this.amount,
    required this.category,
    required this.date,
  });

  void printDetails() {
    print('━━━━━━━━━━━━━━━━━━━━');
    print('📝 $description');
    print('💵 \$${amount.toStringAsFixed(2)}');
    print('📁 $category');
    print('📅 ${date.toString().split(' ')[0]}');
    print('━━━━━━━━━━━━━━━━━━━━');
  }

  // Method that returns a boolean
  bool isMajorExpense() {
    return amount > 100;
  }

  // Method that returns a String
  String getSummary() {
    return '$description: \$${amount.toStringAsFixed(2)} [$category]';
  }

  // Method that returns a formatted amount
  String getFormattedAmount() {
    return '\$${amount.toStringAsFixed(2)}';
  }
}

void main() {
  var laptop = Expense(
    description: 'New laptop',
    amount: 899.99,
    category: 'Electronics',
    date: DateTime.now(),
  );

  var coffee = Expense(
    description: 'Coffee',
    amount: 4.50,
    category: 'Food',
    date: DateTime.now(),
  );

  // Using methods that return values
  print(laptop.getSummary());
  print('Is major expense? ${laptop.isMajorExpense()}');
  print('Formatted: ${laptop.getFormattedAmount()}');

  print('');

  print(coffee.getSummary());
  print('Is major expense? ${coffee.isMajorExpense()}');
}

Output:

New laptop: $899.99 [Electronics]
Is major expense? true
Formatted: $899.99

Coffee: $4.50 [Food]
Is major expense? false

Understanding Return Values:

bool isMajorExpense() {
  return amount > 100;
}

bool = this method returns true or false
return sends the value back
Can use the returned value in conditions or print it

String getSummary() {
  return '$description: \$${amount.toStringAsFixed(2)} [$category]';
}

String = returns text
Builds a nice formatted string
Return value can be stored in a variable or printed directly

Part 8: Complete Example

Here's our complete Expense class with everything we've learned:

class Expense {
  // Properties
  String description;
  double amount;
  String category;
  DateTime date;

  // Constructor with named parameters
  Expense({
    required this.description,
    required this.amount,
    required this.category,
    required this.date,
  });

  // Method: Print detailed information
  void printDetails() {
    print('━━━━━━━━━━━━━━━━━━━━');
    print('📝 Description: $description');
    print('💵 Amount: ${getFormattedAmount()}');
    print('📁 Category: $category');
    print('📅 Date: ${getFormattedDate()}');
    if (isMajorExpense()) {
      print('⚠️  This is a major expense!');
    }
    print('━━━━━━━━━━━━━━━━━━━━');
  }

  // Method: Check if major expense
  bool isMajorExpense() {
    return amount > 100;
  }

  // Method: Get one-line summary
  String getSummary() {
    String emoji = isMajorExpense() ? '🔴' : '🟢';
    return '$emoji $description: ${getFormattedAmount()} [$category]';
  }

  // Method: Get formatted amount with 2 decimals
  String getFormattedAmount() {
    return '\$${amount.toStringAsFixed(2)}';
  }

  // Method: Get formatted date (without time)
  String getFormattedDate() {
    return date.toString().split(' ')[0];
  }
}

void main() {
  print('🏦 MY EXPENSES\n');

  // Create multiple expenses
  var expenses = [
    Expense(
      description: 'Monthly rent',
      amount: 1200.00,
      category: 'Bills',
      date: DateTime.now(),
    ),
    Expense(
      description: 'Groceries',
      amount: 67.50,
      category: 'Food',
      date: DateTime.now(),
    ),
    Expense(
      description: 'Coffee',
      amount: 4.50,
      category: 'Food',
      date: DateTime.now(),
    ),
    Expense(
      description: 'New phone',
      amount: 799.99,
      category: 'Electronics',
      date: DateTime.now(),
    ),
    Expense(
      description: 'Gas',
      amount: 45.00,
      category: 'Transport',
      date: DateTime.now(),
    ),
  ];

  // Print summary for each
  print('SUMMARY:');
  for (var expense in expenses) {
    print(expense.getSummary());
  }

  print('\n');

  // Print details for major expenses
  print('MAJOR EXPENSES (>\$100):');
  for (var expense in expenses) {
    if (expense.isMajorExpense()) {
      expense.printDetails();
      print('');
    }
  }

  // Calculate total
  double total = 0;
  for (var expense in expenses) {
    total += expense.amount;
  }
  print('💰 TOTAL SPENT: \$${total.toStringAsFixed(2)}');
}

🎯 Practice Exercises

Now it's your turn to practice! Complete these exercises to solidify your understanding:

Exercise 1: Basic Class Creation (Easy)

Create a Category class with:

Properties: name (String), icon (String), color (String)
Constructor with named parameters (use required)
Method: getLabel() that returns "icon name" (e.g., "🍔 Food")

Solution:

class Category {
  String name;
  String icon;
  String color;

  Category({
    required this.name,
    required this.icon,
    required this.color,
  });

  String getLabel() {
    return '$icon $name';
  }
}

void main() {
  var food = Category(name: 'Food', icon: '🍔', color: 'green');
  var transport = Category(name: 'Transport', icon: '🚗', color: 'blue');

  print(food.getLabel());
  print(transport.getLabel());
}

Exercise 2: Adding Methods (Medium)

Add these methods to your Expense class:

isThisMonth() - returns true if expense is from current month
isFood() - returns true if category is "Food"
getDaysAgo() - returns how many days ago this expense was made

Hints:

Use DateTime.now() to get current date
Use date.difference(otherDate).inDays to calculate days
Use date.month and date.year to check if same month

Solution:

bool isThisMonth() {
  DateTime now = DateTime.now();
  return date.year == now.year && date.month == now.month;
}

bool isFood() {
  return category == 'Food';
}

int getDaysAgo() {
  DateTime now = DateTime.now();
  return now.difference(date).inDays;
}

Exercise 3: Real-World Scenario (Hard)

Create expenses for your last week and:

Print all expenses from this month
Calculate total food expenses
Find the largest expense
Count how many major expenses (>$100)

Challenge yourself before looking at the solution!

Solution:

void main() {
  var expenses = [
    Expense(
      description: 'Rent',
      amount: 1200.00,
      category: 'Bills',
      date: DateTime(2025, 10, 1),
    ),
    Expense(
      description: 'Lunch',
      amount: 15.50,
      category: 'Food',
      date: DateTime(2025, 10, 5),
    ),
    Expense(
      description: 'Coffee',
      amount: 4.50,
      category: 'Food',
      date: DateTime(2025, 10, 6),
    ),
    Expense(
      description: 'Groceries',
      amount: 89.30,
      category: 'Food',
      date: DateTime(2025, 10, 7),
    ),
    Expense(
      description: 'Uber',
      amount: 12.00,
      category: 'Transport',
      date: DateTime(2025, 10, 8),
    ),
  ];

  // 1. Print this month's expenses
  print('THIS MONTH\'S EXPENSES:');
  for (var expense in expenses) {
    if (expense.isThisMonth()) {
      print(expense.getSummary());
    }
  }

  // 2. Total food expenses
  double foodTotal = 0;
  for (var expense in expenses) {
    if (expense.category == 'Food') {
      foodTotal += expense.amount;
    }
  }
  print('\nTotal food: \$${foodTotal.toStringAsFixed(2)}');

  // 3. Find largest expense
  Expense? largest;
  for (var expense in expenses) {
    if (largest == null || expense.amount > largest.amount) {
      largest = expense;
    }
  }
  print('Largest: ${largest?.getSummary()}');

  // 4. Count major expenses
  int majorCount = 0;
  for (var expense in expenses) {
    if (expense.isMajorExpense()) {
      majorCount++;
    }
  }
  print('Major expenses: $majorCount');
}

Common Mistakes & How to Fix Them

Mistake 1: Forgetting `required` for Named Parameters

// ❌ Wrong - parameters are optional without 'required'
Expense({
  this.description,
  this.amount,
  this.category,
  this.date,
});

// ✅ Correct - use 'required' for non-nullable parameters
Expense({
  required this.description,
  required this.amount,
  required this.category,
  required this.date,
});

Mistake 2: Wrong Method Call

// ❌ Wrong - no parentheses
coffee.printDetails;

// ✅ Correct
coffee.printDetails();

Mistake 3: Using Class Name Instead of Object

// ❌ Wrong - Expense is the class, not an object
print(Expense.amount);

// ✅ Correct - coffee is the object
var coffee = Expense(
  description: 'Coffee',
  amount: 4.50,
  category: 'Food',
  date: DateTime.now(),
);
print(coffee.amount);

Mistake 4: Forgetting Return Statement

// ❌ Wrong - no return
String getSummary() {
  '$description: \$$amount';
}

// ✅ Correct
String getSummary() {
  return '$description: \$$amount';
}

Mistake 5: Not Handling Nullable Types

// If you have optional properties, use nullable types
class Expense {
  String description;
  double amount;
  String category;
  DateTime date;
  String? notes;  // ✅ Correct - nullable with ?

  Expense({
    required this.description,
    required this.amount,
    required this.category,
    required this.date,
    this.notes,  // Optional parameter
  });
}

Key Concepts Review

Before moving to Lesson 3, make sure you understand:

✅ Classes are blueprints - define structure with properties and methods

✅ Objects are instances - created using the class

✅ Constructors initialize objects - use named parameters with required

✅ Properties hold data - accessed with dot notation

✅ Methods define behavior - can be void or return values

✅ Null safety - prevents bugs by ensuring values are always set

✅ Use proper naming - classes PascalCase, methods camelCase

Self-Check Questions

Test your understanding:

1. What's the difference between a property and a method?

Answer:

Property = data (like description, amount)
Method = behavior/action (like printDetails(), getSummary())

2. Why do we use constructors?

Answer:
To initialize objects with data when we create them, ensuring all required values are set. This prevents null safety errors.

3. What does `required` mean in a constructor?

Answer:
required means you must provide a value for that parameter when creating an object. It ensures you don't forget important values and prevents null safety errors.

4. What's the difference between nullable and non-nullable types?

Answer:

Non-nullable (String): Must always have a value, cannot be null
Nullable (String?): Can be null or have a value, use when something is optional

What's Next?

In Lesson 3: Constructors Deep Dive, we'll learn:

Named constructors for easier object creation
Optional parameters with default values
Factory constructors
Making our Expense class even more flexible!

Example preview:

// Instead of this:
var expense = Expense(
  description: 'Coffee',
  amount: 4.50,
  category: 'Food',
  date: DateTime.now(),
);

// We'll be able to do this:
var expense = Expense.quick(
  description: 'Coffee',
  amount: 4.50,
  category: 'Food',
);

var bill = Expense.monthly(
  description: 'Rent',
  amount: 1200.00,
);

Much cleaner, right? See you in Lesson 3! 🚀

Additional Resources

Dart Language Tour: https://dart.dev/guides/language/language-tour#classes
Dart Null Safety: https://dart.dev/null-safety
Practice: Try creating other classes like Budget, User, or Transaction
Next Step: Move on to Lesson 3 when you're comfortable with this material

Remember: Don't rush! Make sure you can complete the exercises before moving forward. Practice is key! �

Dart Object Oriented For Beginner : Expense Manager Case Study Part 1

Putra Prima A — Wed, 08 Oct 2025 22:48:01 +0000

Lesson 1: What is OOP? (Why We Need It)

Duration: 15 minutes

App Feature: 🎯 Planning our Expense Manager

What You'll Learn: Understand how OOP helps organize our expense tracking app

Introduction

Welcome to your journey of learning Dart and Object-Oriented Programming! Instead of learning abstract concepts, we're going to build a real expense manager app together. By the end of this tutorial, you'll understand not just what OOP is, but why it's essential for building apps.

The Problem: Life Without OOP

Imagine you want to track your expenses. Let's say you want to record:

A coffee you bought for $4.50
Groceries for $85.50
Netflix subscription for $15.99

Approach 1: Separate Variables (The Worst Way)

void main() {
  // First expense - Coffee
  String expense1Description = 'Coffee';
  double expense1Amount = 4.50;
  String expense1Category = 'Food';
  DateTime expense1Date = DateTime.now();

  // Second expense - Groceries
  String expense2Description = 'Groceries';
  double expense2Amount = 85.50;
  String expense2Category = 'Food';
  DateTime expense2Date = DateTime.now();

  // Third expense - Netflix
  String expense3Description = 'Netflix';
  double expense3Amount = 15.99;
  String expense3Category = 'Entertainment';
  DateTime expense3Date = DateTime.now();

  print('Expense 1: $expense1Description - \$expense1Amount');
  print('Expense 2: $expense2Description - \$expense2Amount');
  print('Expense 3: $expense3Description - \$expense3Amount');
}

Problems:

❌ Messy and repetitive - We need 4 variables for each expense!
❌ Hard to manage - 50 expenses = 200 variables!
❌ No relationship - Nothing connects expense1Description with expense1Amount
❌ Error-prone - Easy to mix up expense1Amount with expense2Amount
❌ Can't reuse code - Want to calculate total? You need to add each variable manually

🔴 Real Problem Example:

void main() {
  String expense1Description = 'Coffee';
  double expense1Amount = 4.50;
  String expense1Category = 'Food';

  String expense2Description = 'Lunch';
  double expense2Amount = 12.50;
  String expense2Category = 'Food';

  // You want to calculate total food expenses
  // You have to manually remember and type each variable!
  double foodTotal = expense1Amount + expense2Amount;  // Only works for 2 expenses

  // What if you have 10 food expenses? You have to type all 10!
  // What if you accidentally use the wrong variable?
  double wrongTotal = expense1Amount + expense1Amount;  // BUG! Used expense1 twice

  // Want to find the most expensive? Manual comparison for each one!
  double mostExpensive = expense1Amount;
  if (expense2Amount > mostExpensive) {
    mostExpensive = expense2Amount;
  }
  // Imagine doing this for 50 expenses... nightmare!
}

The nightmare scenario:

// You have 20 expenses, then you want to add a new field "notes"
// Now you need to add 20 new variables!
String expense1Notes = 'Morning coffee';
String expense2Notes = 'Lunch with team';
String expense3Notes = 'Monthly subscription';
// ... 17 more variables!

// This is completely unmaintainable! 😱

Approach 2: Using Arrays/Lists (Better, but Still Problematic)

void main() {
  // Use lists to group data
  List<String> descriptions = ['Coffee', 'Groceries', 'Netflix'];
  List<double> amounts = [4.50, 85.50, 15.99];
  List<String> categories = ['Food', 'Food', 'Entertainment'];
  List<DateTime> dates = [DateTime.now(), DateTime.now(), DateTime.now()];

  // Print expenses
  for (int i = 0; i < descriptions.length; i++) {
    print('${descriptions[i]}: \${amounts[i]} [${categories[i]}]');
  }

  // Calculate total - much easier!
  double total = 0;
  for (var amount in amounts) {
    total += amount;
  }
  print('\nTotal: \${total.toStringAsFixed(2)}');
}

This is better because:

✅ Can handle any number of expenses
✅ Easier to calculate totals
✅ Less variables overall

But still has problems:

❌ Data is disconnected - descriptions[0] relates to amounts[0], but nothing enforces this
❌ Easy to make mistakes - What if you add to descriptions but forget to add to amounts?
❌ Hard to maintain - Adding a new field means adding a new list everywhere
❌ Confusing indices - Was index 2 the Netflix or the groceries?
❌ Can get out of sync - If you delete from one list but not others, everything breaks!

🔴 Real Problem Example - Data Gets Out of Sync:

void main() {
  List<String> descriptions = ['Coffee', 'Groceries', 'Netflix'];
  List<double> amounts = [4.50, 85.50, 15.99];
  List<String> categories = ['Food', 'Food', 'Entertainment'];

  print('Before deletion:');
  for (int i = 0; i < descriptions.length; i++) {
    print('${descriptions[i]}: \${amounts[i]} [${categories[i]}]');
  }

  // User deletes "Groceries" - you remove from descriptions
  descriptions.removeAt(1);  // Remove "Groceries"

  // Oops! Forgot to remove from amounts and categories!
  // Now everything is WRONG!

  print('\nAfter deletion:');
  for (int i = 0; i < descriptions.length; i++) {
    print('${descriptions[i]}: \${amounts[i]} [${categories[i]}]');
  }

  /* OUTPUT - EVERYTHING IS WRONG! 😱
  Before deletion:
  Coffee: $4.50 [Food]
  Groceries: $85.50 [Food]
  Netflix: $15.99 [Entertainment]

  After deletion:
  Coffee: $4.50 [Food]        ✓ Correct
  Netflix: $85.50 [Food]      ✗ WRONG! Should be $15.99 [Entertainment]
  */
}

🔴 Real Problem Example - Adding New Data:

void main() {
  List<String> descriptions = ['Coffee', 'Lunch'];
  List<double> amounts = [4.50, 12.50];
  List<String> categories = ['Food', 'Food'];

  // You want to add a new expense
  descriptions.add('Netflix');
  amounts.add(15.99);
  // Oops! Forgot to add to categories!

  // Later, you try to access all data...
  for (int i = 0; i < descriptions.length; i++) {
    print('${descriptions[i]}: \${amounts[i]} [${categories[i]}]');
  }

  /* CRASH! 💥
  RangeError: Index out of range
  Because categories only has 2 items but we're trying to access index 2!
  */
}

🔴 Real Problem Example - Adding a New Field:

void main() {
  // You have expenses stored in 3 lists
  List<String> descriptions = ['Coffee', 'Lunch', 'Uber', 'Movie'];
  List<double> amounts = [4.50, 12.50, 8.00, 15.00];
  List<String> categories = ['Food', 'Food', 'Transport', 'Entertainment'];

  // Now you want to add "payment method" to track how you paid
  // You need to create a NEW list and initialize ALL existing data
  List<String> paymentMethods = ['Cash', 'Card', 'Cash', 'Card'];

  // Then update ALL your code that works with expenses
  // Every loop needs to be updated!
  for (int i = 0; i < descriptions.length; i++) {
    print('${descriptions[i]}: \${amounts[i]} [${categories[i]}] - ${paymentMethods[i]}');
  }

  // Now you have 4 lists to keep in sync! 
  // What if you want to add "notes" too? That's 5 lists!
  // This gets unmanageable FAST! 😰
}

Approach 3: Using Maps (Even Better, but Still Not Ideal)

void main() {
  // Each expense is a map
  List<Map<String, dynamic>> expenses = [
    {
      'description': 'Coffee',
      'amount': 4.50,
      'category': 'Food',
      'date': DateTime.now(),
    },
    {
      'description': 'Groceries',
      'amount': 85.50,
      'category': 'Food',
      'date': DateTime.now(),
    },
    {
      'description': 'Netflix',
      'amount': 15.99,
      'category': 'Entertainment',
      'date': DateTime.now(),
    },
  ];

  // Print expenses
  for (var expense in expenses) {
    print('${expense['description']}: \${expense['amount']} [${expense['category']}]');
  }

  // Calculate total
  double total = 0;
  for (var expense in expenses) {
    total += expense['amount'];
  }
  print('\nTotal: \${total.toStringAsFixed(2)}');
}

This is much better because:

✅ Data stays together - can't get out of sync
✅ Easy to add expenses
✅ Easy to add new fields

But still has problems:

❌ Typos cause bugs - 'ammount' vs 'amount' won't show an error!
❌ No type safety - Could accidentally put a string where a number should be
❌ No methods - Can't add functions like isExpensive() or getFormattedAmount()
❌ No validation - Nothing stops you from creating invalid expenses
❌ Hard to read - expense['description'] is confusing

🔴 Real Problem Example - Typos Are Silent:

void main() {
  var expense = {
    'description': 'Coffee',
    'amoutn': 4.50,  // TYPO! Should be 'amount'
    'category': 'Food',
  };

  // Try to get the amount
  print('Amount: ${expense['amount']}');  // Prints: Amount: null

  // No error! The typo is silent and gives you null
  // You won't know there's a bug until runtime!

  // Try to calculate total
  double total = 0;
  List<Map<String, dynamic>> expenses = [expense];

  for (var exp in expenses) {
    total += exp['amount'] ?? 0;  // Have to use ?? because might be null
  }

  print('Total: $total');  // Total: 0 (WRONG! Should be 4.50)
  // The bug is hidden! No error message! 😱
}

🔴 Real Problem Example - Wrong Types Accepted:

void main() {
  // These compile fine but are completely wrong!
  var badExpense1 = {
    'description': 'Coffee',
    'amount': 'four dollars fifty',  // String instead of number!
    'category': 'Food',
  };

  var badExpense2 = {
    'description': 12345,  // Number instead of string!
    'amount': 'expensive',  // String instead of number!
    'category': DateTime.now(),  // DateTime instead of string!
  };

  // No errors during compilation!
  // But when you try to use them...

  List<Map<String, dynamic>> expenses = [badExpense1, badExpense2];

  double total = 0;
  for (var expense in expenses) {
    // This will crash! Can't add a string to a number
    total += expense['amount'];  // 💥 Runtime error!
  }
}

🔴 Real Problem Example - No Autocomplete:

void main() {
  var expense = {
    'description': 'Coffee',
    'amount': 4.50,
    'category': 'Food',
    'paymentMethod': 'Cash',
  };

  // When typing, your IDE doesn't help you!
  // You have to remember: was it 'description' or 'desc'?
  // Was it 'category' or 'cat'? 
  // Was it 'paymentMethod' or 'payment_method'?

  print(expense['descryption']);  // Typo! Returns null, no error
  print(expense['kategory']);     // Typo! Returns null, no error
  print(expense['payment']);      // Typo! Returns null, no error

  // With classes, IDE autocomplete helps you avoid typos!
}

🔴 Real Problem Example - No Validation:

void main() {
  // Nothing stops you from creating completely invalid data!
  var invalidExpense = {
    'description': '',  // Empty string - should not be allowed!
    'amount': -100.50,  // Negative amount - impossible!
    'category': 'asdfgh',  // Invalid category
    'date': 'yesterday',  // String instead of DateTime!
  };

  // This compiles and runs!
  // Your app will have bad data and bugs everywhere

  List<Map<String, dynamic>> expenses = [invalidExpense];

  // Later, your code assumes valid data...
  for (var expense in expenses) {
    if (expense['description'].isEmpty) {  // Wait, what is this expense?
      print('Warning: Empty expense!');
    }

    if (expense['amount'] < 0) {  // Negative money?!
      print('Warning: Negative expense!');
    }

    // You need to manually check EVERYTHING!
    // With classes, validation happens automatically!
  }
}

The Journey So Far:

Approach	Main Problem	Example Issue
Separate Variables	Can't scale	Need 200 variables for 50 expenses
Arrays	Gets out of sync	Delete from one list, forget another → data mismatch
Maps	No type safety	Typos and wrong types = silent bugs

All of these approaches share common problems:

😰 Easy to make mistakes
🐛 Bugs are hidden until runtime
📝 No IDE help (autocomplete)
❌ No validation
🔧 Hard to add features
📚 Can't add related functions

We need a solution that:

✅ Keeps data together
✅ Catches errors at compile time
✅ Provides IDE autocomplete
✅ Allows validation
✅ Lets us add methods
✅ Is easy to read and maintain

That solution is... Object-Oriented Programming with Classes! 🎉

The Problem: Life Without OOP

Imagine you want to track your expenses. Let's say you want to record:

A coffee you bought for $4.50
Groceries for $85.50
Netflix subscription for $15.99

Approach 1: Separate Variables (The Bad Way)

void main() {
  // First expense - Coffee
  String expense1Description = 'Coffee';
  double expense1Amount = 4.50;
  String expense1Category = 'Food';
  DateTime expense1Date = DateTime.now();

  // Second expense - Groceries
  String expense2Description = 'Groceries';
  double expense2Amount = 85.50;
  String expense2Category = 'Food';
  DateTime expense2Date = DateTime.now();

  // Third expense - Netflix
  String expense3Description = 'Netflix';
  double expense3Amount = 15.99;
  String expense3Category = 'Entertainment';
  DateTime expense3Date = DateTime.now();

  print('Expense 1: $expense1Description - \$$expense1Amount');
  print('Expense 2: $expense2Description - \$$expense2Amount');
  print('Expense 3: $expense3Description - \$$expense3Amount');
}

Problems with This Approach:

Messy and repetitive - We need 4 variables for each expense!
Hard to manage - What if you have 50 expenses? That's 200 variables!
No relationship - Nothing connects expense1Description with expense1Amount
Error-prone - Easy to mix up expense1Amount with expense2Amount
Can't reuse code - Want to calculate total? You need to add each variable manually

Try to imagine tracking 10 expenses this way... That's 40 separate variables! 😱

The Solution: Object-Oriented Programming

OOP lets us bundle related data together. Instead of 4 separate variables per expense, we create a blueprint (called a class) and make objects from it.

Think of it Like This:

🏠 Analogy 1: House Blueprint

House Blueprint (Class)

A blueprint shows what every house should have: rooms, doors, windows
It's not an actual house, just a template
You can't live in a blueprint!

Actual Houses (Objects)

You can build many houses from one blueprint
Each house is unique (different colors, sizes) but follows the blueprint
These are real houses people can live in

🍪 Analogy 2: Cookie Cutter

Cookie Cutter (Class)

The cookie cutter defines the shape
It's just a tool, not something you can eat
One cookie cutter can make hundreds of cookies

Actual Cookies (Objects)

Each cookie is made from the same cutter
But each can have different decorations, flavors
These are the real cookies you can eat!

📱 Analogy 3: Smartphone Model

iPhone Design/Model (Class)

Apple designs one iPhone 15 model
The design specifies: screen size, camera specs, processor
You can't make calls on a design document!

Your Actual iPhone (Object)

Your specific iPhone 15 with your apps, photos, contacts
Your friend's iPhone 15 with their different data
Each is a real, working phone created from the same design

🚗 Analogy 4: Car Manufacturing

Tesla Model 3 Blueprint (Class)

Tesla's design for Model 3
Specifies: 4 wheels, electric motor, touchscreen, autopilot
Can't drive a blueprint!

Actual Tesla Cars (Objects)

Each Model 3 rolling off the assembly line
Same design, but different colors, VIN numbers, owners
These are real cars you can drive!

🎂 Analogy 5: Cake Recipe

Chocolate Cake Recipe (Class)

Recipe lists ingredients: flour, sugar, eggs, chocolate
Lists steps: mix, bake, cool
You can't eat a recipe!

Actual Cakes (Objects)

Each cake you bake following the recipe
Same recipe, but might have different decorations
These are real cakes you can eat!

In Programming:

📋 Expense Class (Blueprint)

Defines what every expense should have: description, amount, category, date
Defines what every expense can do: calculate total, check if expensive
Just a template, not actual data
You can't track spending with just a class!

💰 Expense Objects (Actual Expenses)

Coffee expense: $4.50, Food, Today
Netflix expense: $15.99, Entertainment, Today
Rent expense: $1200, Bills, This month
Each is a real expense created from the template
These are your actual spending records!

Key Understanding:

Class (Blueprint)           →    Objects (Real Things)
─────────────────────────────────────────────────────────
Cookie Cutter              →    Cookie #1, Cookie #2, Cookie #3
iPhone Design              →    Your iPhone, Friend's iPhone
Car Blueprint              →    Car with VIN 123, Car with VIN 456
Recipe                     →    Cake you baked today, Cake from yesterday
Expense Class              →    Coffee expense, Rent expense, Gas expense

ONE CLASS                  →    MANY OBJECTS
(Define once)              →    (Create as many as you need)

The Power:

✨ Define the structure once (the class)
🚀 Create unlimited real instances (objects)
🎯 Each object has its own data
🔧 All objects follow the same structure
💪 Change the class, all objects get the update!

Understanding Classes and Objects

What is a Class?

A class is a blueprint or template that defines:

Properties (data): what information it stores
Methods (actions): what it can do

Think of it as a cookie cutter - it shapes what the cookies will look like, but it's not the cookie itself.

What is an Object?

An object is an actual instance created from a class.

Think of it as the cookies - real things you can eat, made from the cookie cutter template.

Our First Look at OOP Code

Don't worry if you don't understand everything yet - we'll learn step by step. This is just to show you the difference:

// The BLUEPRINT - This is a class
class Expense {
  String description;
  double amount;
  String category;
  DateTime date;

  // Constructor - required to initialize all properties
  Expense({
    required this.description,
    required this.amount,
    required this.category,
    required this.date,
  });
}

void main() {
  // Creating OBJECTS from the blueprint
  var coffee = Expense(
    description: 'Coffee',
    amount: 4.50,
    category: 'Food',
    date: DateTime.now(),
  );

  var netflix = Expense(
    description: 'Netflix',
    amount: 15.99,
    category: 'Entertainment',
    date: DateTime.now(),
  );

  print('${coffee.description}: \${coffee.amount}');
  print('${netflix.description}: \${netflix.amount}');
}

Output:

Coffee: $4.50
Netflix: $15.99

See the difference?

We defined the Expense structure once
We created multiple expenses easily
Each expense is a separate object with its own data
The code is cleaner and more organized
Dart's null safety ensures we never forget to set required values!

Why OOP Matters for Your Expense Manager

As we build our expense manager app, you'll see how OOP helps us:

1. Organization

Without OOP: 100 expenses = 400+ variables floating around
With OOP: 100 expense objects, each neatly packaged

2. Reusability

// Want to add a new expense? Just create an object!
var lunch = Expense(
  description: 'Lunch',
  amount: 12.50,
  category: 'Food',
  date: DateTime.now(),
);
var dinner = Expense(
  description: 'Dinner',
  amount: 25.00,
  category: 'Food',
  date: DateTime.now(),
);
var gas = Expense(
  description: 'Gas',
  amount: 45.00,
  category: 'Transport',
  date: DateTime.now(),
);
// Same blueprint, different data

3. Maintainability

// Need to add a "notes" field to all expenses?
// Change the class ONCE, all objects get the new feature
class Expense {
  String description;
  double amount;
  String category;
  DateTime date;
  String? notes; // Added here - affects all expenses! (? means optional)

  Expense({
    required this.description,
    required this.amount,
    required this.category,
    required this.date,
    this.notes, // Optional parameter
  });
}

4. Real-World Modeling

Your app will have:
- Expense objects (each purchase)
- Category objects (Food, Transport, etc.)
- Budget objects (monthly limits)
- User object (your profile)

Each is a separate class, working together!

The Four Pillars of OOP

As we build our expense manager, we'll learn these four core concepts:

1. Encapsulation 🔒

Bundle data and methods together, hide internal details.

In our app: Keep expense data safe, validate amounts (can't be negative!)

2. Inheritance 🌳

Create new classes based on existing ones.

In our app: RecurringExpense (like Netflix) inherits from Expense but adds frequency

3. Polymorphism 🎭

One action, multiple forms.

In our app: All expenses can printDetails(), but recurring ones show frequency too

4. Abstraction 🎯

Hide complex details, show only what's necessary.

In our app: You don't need to know HOW expenses are stored, just add/view/delete them

Don't worry if these seem confusing now! We'll learn each one by actually using it in our app.

What We're Building Together

Over the next lessons, we'll build a complete expense tracking system:

📱 Expense Manager App
├── 💰 Expense Class
│   ├── Track amount, date, category
│   ├── Validate data (no negative amounts!)
│   └── Calculate totals
│
├── 🔄 RecurringExpense Class
│   ├── Monthly bills (rent, subscriptions)
│   └── Calculate yearly costs
│
├── 🎯 OneTimeExpense Class
│   ├── Special purchases (gifts, emergencies)
│   └── Tag occasions
│
├── 💳 PaymentMethod Classes
│   ├── Credit card, cash, digital wallet
│   └── Process payments differently
│
└── 📊 ExpenseManager Class
    ├── Store all expenses
    ├── Filter by category
    ├── Calculate totals
    └── Generate reports

Quick Check: Do You Understand?

Before moving to the next lesson, make sure you can answer these:

✅ Self-Check Questions:

What's the difference between a class and an object? Click to see answer

Class = Blueprint/template (defines structure)
Object = Actual instance (real data)
Example: Expense is the class, your coffee purchase is an object

Why is OOP better than using separate variables? Click to see answer

Organizes related data together
Easier to manage many items
Less error-prone
Code is reusable

Name one real-world example of a class and its objects Click to see answer

Examples:

Class: Car → Objects: Your Toyota, Your friend's Honda
Class: Student → Objects: John, Sarah, Mike
Class: Song → Objects: "Bohemian Rhapsody", "Hotel California"

Try It Yourself! 🎯

Before moving to Lesson 2, think about what properties an Expense should have:

Your Task:

Write down (on paper or in notes) what information you'd want to track for each expense:

Example answers:

✓ Description (what you bought)
✓ Amount (how much it cost)
✓ Category (Food, Transport, etc.)
✓ Date (when you bought it)
? What else would be useful?

Bonus questions to think about:

Should expenses have a unique ID number?
Should we track the payment method (cash, card)?
Should we allow notes or tags?

We'll use your ideas in the next lesson when we actually create the Expense class!

Key Takeaways 🎓

Before moving forward, remember:

✅ OOP organizes code into objects - like real-world things

✅ Classes are blueprints - they define structure

✅ Objects are instances - actual data created from classes

✅ OOP makes code cleaner - easier to read and maintain

✅ Perfect for apps - Flutter itself is built on OOP principles

What's Next?

In Lesson 2, we'll:

Write our first Expense class
Create actual expense objects
Learn about constructors
Add methods to print expense details
See our code actually work!

Time to get hands-on and write real code! 🚀

Need Help?

Common questions beginners ask:

Q: Do I need to memorize all the OOP terms?

A: No! Focus on understanding the concepts. The terms will become natural as you use them.

Q: Is OOP hard?

A: It might feel strange at first, but by building a real app, you'll see why it's actually easier than the alternative!

Q: Can I skip OOP and just learn Flutter?

A: Flutter IS built with OOP! Every widget is a class. Understanding OOP will make Flutter much easier.

Q: What if I get stuck?

A: That's normal! Re-read sections, try the examples, and remember - we're building this step by step together.

Ready for Lesson 2? Let's write some code! →

Laravel Auto CRUD Generator: Save 8+ Hours Per Project

Putra Prima A — Tue, 11 Mar 2025 11:00:00 +0000

Tired of writing repetitive CRUD code? This tool generates it all in 30 seconds.

Ever found yourself writing the same controllers, requests, and views over and over again for each model in your Laravel project? What if I told you there's a way to automate all of that tedious work with just a single command? Keep reading to discover how you can save hours of development time on every project.

🚀 What Is Laravel Auto CRUD Generator?

Laravel Auto CRUD Generator is a powerful package that revolutionizes how you handle CRUD (Create, Read, Update, Delete) operations in your Laravel applications. Instead of manually coding controllers, requests, routes, and views for each model, this package generates everything automatically.

With a single command, you can have a fully functional CRUD implementation for any model in your application. This means you can focus on building the unique aspects of your application rather than writing boilerplate code.

💡 Why You Need This In Your Development Toolkit

Let's be honest - writing CRUD operations is necessary but repetitive. For each new model, you typically need to:

Create a controller with 7 methods (index, create, store, show, edit, update, destroy)
Build validation requests
Set up API resources if you're building an API
Configure routes
Create views for each action
Implement repositories and services if you follow that pattern

That's a lot of work! And it's the same pattern repeated for every single model in your application.

Laravel Auto CRUD Generator completely eliminates this repetitive work.

✨ Impressive Features That Will Transform Your Workflow

The package comes loaded with features designed to make your development experience smoother:

🔍 Smart Model Detection

The package automatically scans your app/Models folder to find all available models, saving you from having to remember and type model names manually.

💻 Interactive CLI Experience

Enjoy a friendly command-line interface that guides you through the generation process, making it accessible even for those new to Laravel.

🏗️ Complete Code Generation

It doesn't just create basic templates - it generates fully functional:

Controllers (for both web and API)
Request validation classes
Resource classes for API responses
Routes configured and ready to use
Views with proper forms and listings
Repositories and services (if you use that pattern)

🔄 Multiple Architecture Support

Whether you prefer:

Standard Laravel controllers
Repository pattern implementation
Service layer architecture
Spatie Data integration

The package has you covered with code generated specifically for your preferred architecture style.

🌐 API Development Support

Building an API? The package generates:

API controllers with proper status codes
JSON resources for standardized responses
Optional CURL command examples
Postman collection export

📚 Best Practices Compliance

All generated code follows Laravel's best practices for clean and maintainable code, so you don't have to worry about technical debt.

🛠️ How To Install and Configure

Getting started with Laravel Auto CRUD Generator is straightforward:

Install the package via Composer:

composer require mrmarchone/laravel-auto-crud --dev

Publish the configuration file to customize the generator:

php artisan vendor:publish --provider="Mrmarchone\LaravelAutoCrud\LaravelAutoCrudServiceProvider" --tag="auto-crud-config"

That's it! You're ready to start generating CRUD operations.

🔥 Using Laravel Auto CRUD Generator

The magic happens with a single Artisan command:

php artisan auto-crud:generate

This command provides several options to customize the generation process:

Options:
  -M, --model[=MODEL]             Select one or more of your models
  -T, --type[=TYPE]               Select whether to generate API or web controllers
  -R, --repository                Work with repository design pattern
  -O, --overwrite                 Overwrite existing files
  -P, --pattern[=PATTERN]         Support for Spatie-Data Pattern
  -C, --curl                      Generate CURL requests for API
  -MP, --model-path[=MODEL-PATH]  Set custom models path
  -PM, --postman                  Generate Postman Collection for API

Example Command

Here's a comprehensive example:

php artisan auto-crud:generate --model-path=app/AnotherModels --model=User --model=Manager --overwrite --type=api --repository --pattern=spatie-data --curl --postman

This command will:

Look for models in the app/AnotherModels directory
Generate CRUD operations for both User and Manager models
Overwrite any existing files
Create API controllers instead of web controllers
Implement the repository pattern
Use Spatie's Data pattern
Generate CURL examples
Create a Postman collection

📊 What Gets Generated?

Let's look at what files the package creates for a User model:

1. API Controller

<?php

namespace App\Http\Controllers\API;

use App\Http\Controllers\Controller;
use App\Http\Requests\UserRequest;
use App\Http\Resources\UserResource;
use App\Models\User;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class UserController extends Controller
{
    public function index(): \Illuminate\Http\Resources\Json\AnonymousResourceCollection
    {
        return UserResource::collection(User::latest()->paginate(10));
    }

    public function store(UserRequest $request): UserResource|\Illuminate\Http\JsonResponse
    {
        try {
            $user = User::create($request->validated());
            return new UserResource($user);
        } catch (\Exception $exception) {
            report($exception);
            return response()->json(['error' => 'There is an error.'], Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    public function show(User $user): UserResource
    {
        return UserResource::make($user);
    }

    public function update(UserRequest $request, User $user): UserResource|\Illuminate\Http\JsonResponse
    {
        try {
            $user->update($request->validated());
            return new UserResource($user);
        } catch (\Exception $exception) {
            report($exception);
            return response()->json(['error' => 'There is an error.'], Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    public function destroy(User $user): \Illuminate\Http\JsonResponse
    {
        try {
            $user->delete();
            return response()->json(['message' => 'Deleted successfully'], Response::HTTP_NO_CONTENT);
        } catch (\Exception $exception) {
            report($exception);
            return response()->json(['error' => 'There is an error.'], Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }
}

2. Web Controller

<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Http\Requests\UserRequest;
use App\Models\User;

class UserController extends Controller
{
    public function index(): \Illuminate\Contracts\View\View
    {
        $users = User::latest()->paginate(10);
        return view('users.index', compact('users'));
    }

    public function create(): \Illuminate\Contracts\View\View
    {
        return view('users.create');
    }

    public function store(UserRequest $request): \Illuminate\Http\RedirectResponse
    {
        User::create($request->validated());
        return redirect()->route('users.index')->with('success', 'Created successfully');
    }

    public function show(User $user): \Illuminate\Contracts\View\View
    {
        return view('users.show', compact('user'));
    }

    public function edit(User $user): \Illuminate\Contracts\View\View
    {
        return view('users.edit', compact('user'));
    }

    public function update(UserRequest $request, User $user): \Illuminate\Http\RedirectResponse
    {
        $user->update($request->validated());
        return redirect()->route('users.index')->with('success', 'Updated successfully');
    }

    public function destroy(User $user): \Illuminate\Http\RedirectResponse
    {
        $user->delete();
        return redirect()->route('users.index')->with('success', 'Deleted successfully');
    }
}

3. Validation Request

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class UserRequest extends FormRequest
{
    public function authorize(): bool
    {
        return true;
    }

    public function rules(): array
    {
        return [
            'name' => 'required|string|max:255',
            'email' => 'required|string|max:255|unique:users,email',
            'email_verified_at' => 'nullable|date',
            'password' => 'required|string|max:255',
            'remember_token' => 'nullable|string|max:100',
        ];
    }
}

4. API Resource

<?php

namespace App\Http\Resources;

use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\JsonResource;

class UserResource extends JsonResource
{
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            'email_verified_at' => $this->email_verified_at,
            'password' => $this->password,
            'remember_token' => $this->remember_token,
            'created_at' => $this->created_at,
            'updated_at' => $this->updated_at,
        ];
    }
}

5. Routes

The package also generates routes in both web.php and api.php files:

// api.php
Route::apiResource('/users', App\Http\Controllers\API\UserController::class);

// web.php
Route::resource('/users', App\Http\Controllers\UserController::class);

6. Repository and Service (if enabled)

When using the repository pattern, it generates properly structured repository and service classes:

<?php
namespace App\Repositories;

use App\Models\User;

class UserRepository
{
    // Repository implementation
}

<?php
namespace App\Services;

use App\Models\User;
use App\Repositories\UserRepository;

class UserService
{
    // Service implementation
}

7. Spatie Data (if enabled)

<?php

namespace App\Data;

use Spatie\LaravelData\Data;
use Spatie\LaravelData\Attributes\Validation\Max;
use Spatie\LaravelData\Attributes\Validation\Unique;
use Spatie\LaravelData\Attributes\Validation\Date;
use Carbon\Carbon;

class UserData extends Data
{
    #[Max(255)]
    public string $name;
    #[Max(255), Unique('users', 'email')]
    public string $email;
    #[Date]
    public ?Carbon $email_verified_at;
    #[Max(255)]
    public string $password;
    #[Max(100)]
    public ?string $remember_token;
}

⚠️ Important Notes

When working with models outside the default app/Models directory, the command will generate files following your custom directory structure. For example:

If you use --model-path=app/AnotherModels/Models, it will generate controllers at app/Http/Controllers/AnotherModels/Models/ModelController.php.

🌟 Real-World Impact

Let's put this in perspective:

Without Laravel Auto CRUD Generator:

Creating CRUD operations for 10 models: ~10 hours
Implementing repository pattern: +5 hours
Setting up API resources and proper error handling: +3 hours
Total: ~18 hours of repetitive coding

With Laravel Auto CRUD Generator:

Setting up the package: 5 minutes
Running the command for 10 models: 5 minutes
Review and minor adjustments: 30 minutes
Total: ~40 minutes

That's a time saving of over 17 hours on a single project! 🤯

🧰 Requirements

To use Laravel Auto CRUD Generator, you need:

Laravel 10+
PHP 8.1+
Laravel Data Spatie (optional, only if using the Spatie Data pattern)

🚀 Take Your Laravel Development to the Next Level

By adding Laravel Auto CRUD Generator to your toolkit, you'll:

Save hours of development time on every project
Reduce bugs by using consistently generated code
Maintain clean architecture across your entire application
Focus on building unique features rather than repetitive CRUD operations

🙋‍♂️ Ready to supercharge your Laravel development?

If you're tired of writing the same CRUD code over and over again, it's time to try Laravel Auto CRUD Generator.

Who's with me? Drop a comment below if you're going to give this a try on your next project! I'd love to hear how many hours it saves you.

Check out more developer tools and tutorials on:

YouTube: https://www.youtube.com/@dosenNgoding
LinkedIn: https://www.linkedin.com/in/putra-prima-arhandi/
GitHub: https://github.com/siubie/kaido-kit

✋ Raise your hand if you're ready to save 8+ hours on your next Laravel project!

Route Declaration Order: Laravel's Hidden Routing Rule

Putra Prima A — Sat, 08 Mar 2025 11:00:00 +0000

Ever wondered why your custom Laravel routes suddenly disappeared? Trust me, you're not alone. I've spent countless hours debugging this exact issue – and now I'm sharing the solution that will save you major headaches.

The Hidden Laravel Routing Rule That's Breaking Your Code

Laravel's routing system is elegant and powerful, but there's one crucial detail that isn't immediately obvious in the documentation. When you're working with resource controllers alongside custom routes for the same resource, the order of declaration matters significantly. Let me break this down for you:

// This works correctly ✅
Route::get('posts/featured', 'PostController@featured');
Route::resource('posts', 'PostController');

// This will fail ❌
Route::resource('posts', 'PostController');
Route::get('posts/featured', 'PostController@featured');

Why Does This Happen?

When Laravel processes your routes, it registers them in the exact order they appear in your routes file. Resource routes are particularly special because they expand into multiple route definitions covering all the standard CRUD operations:

GET /posts (index)
GET /posts/create (create)
POST /posts (store)
GET /posts/{post} (show)
GET /posts/{post}/edit (edit)
PUT/PATCH /posts/{post} (update)
DELETE /posts/{post} (destroy)

The problem occurs with the show route - GET /posts/{post}. This route contains a wildcard parameter {post} that will match any segment after /posts/, including segments like "featured" that you might want to use for custom functionality.

The Detailed Explanation

Let's walk through exactly what happens in each scenario:

Scenario 1: Custom Route Declared First (Correct Order)

Route::get('posts/featured', 'PostController@featured');
Route::resource('posts', 'PostController');

Laravel registers the explicit route for posts/featured
Then it registers all the resource routes
When a request comes in for /posts/featured:
- Laravel checks registered routes in order
- It finds the explicit match first and routes to PostController@featured

Scenario 2: Resource Route Declared First (Incorrect Order)

Route::resource('posts', 'PostController');
Route::get('posts/featured', 'PostController@featured');

Laravel registers all the resource routes, including GET /posts/{post}
Then it registers the explicit route for posts/featured
When a request comes in for /posts/featured:
- Laravel checks registered routes in order
- It sees that /posts/{post} matches by treating "featured" as the {post} parameter
- It routes to PostController@show with "featured" as the post ID
- Your custom route never gets called! 😱

Real-World Example

Let's say you're building a blog system with posts that can be featured. You want a special page to display all featured posts:

// routes/web.php - WRONG ORDER
Route::resource('posts', PostController::class);
Route::get('posts/featured', [PostController::class, 'featured']);

With this configuration, when you visit /posts/featured, Laravel interprets "featured" as a post ID and tries to find a post with ID "featured" in your database!

// routes/web.php - CORRECT ORDER
Route::get('posts/featured', [PostController::class, 'featured']);
Route::resource('posts', PostController::class);

Now when you visit /posts/featured, you'll properly reach your custom method that shows featured posts.

Practical Solutions & Best Practices

1. Always Define Custom Routes Before Resource Routes

This is the simplest solution - just always put your custom routes first:

// Custom routes
Route::get('posts/featured', [PostController::class, 'featured']);
Route::get('posts/archived', [PostController::class, 'archived']);
Route::get('posts/statistics', [PostController::class, 'statistics']);

// Then resource route
Route::resource('posts', PostController::class);

2. Use Route Groups for Better Organization

As your application grows, you might want to group related routes together:

Route::prefix('posts')->group(function () {
    // Custom routes first
    Route::get('featured', [PostController::class, 'featured']);
    Route::get('archived', [PostController::class, 'archived']);
    Route::get('statistics', [PostController::class, 'statistics']);
});

// Then resource route
Route::resource('posts', PostController::class);

3. Exclude Specific Methods from Resource Routes

If you have many custom routes, you can exclude specific actions from the resource route:

// Custom routes
Route::get('posts/show/{post}', [PostController::class, 'show']);

// Resource route without show method
Route::resource('posts', PostController::class)->except(['show']);

4. Use Route Names for Clearer Reference

Always name your routes for easier reference in your views and controllers:

Route::get('posts/featured', [PostController::class, 'featured'])->name('posts.featured');
Route::resource('posts', PostController::class);

Then in your Blade templates or controllers:

// In Blade template
<a href="{{ route('posts.featured') }}">Featured Posts</a>

// In controller
return redirect()->route('posts.featured');

Common Issues & Troubleshooting

1. Route Not Found Exceptions

If you're seeing "Route not found" exceptions for your custom routes despite defining them, check:

Route order (resource routes might be catching your requests)
Route caching (use php artisan route:clear to clear cached routes)
Typos in route definitions
Middleware that might be interfering

2. Unexpected Parameter Behavior

If your route parameters aren't behaving as expected:

// This route
Route::get('posts/{category}/in-category', [PostController::class, 'byCategory']);

// Might conflict with
Route::resource('posts', PostController::class);

Because the resource's show method would catch posts/{category} before it reaches your custom route.

3. Using Route::apiResource

When building APIs, similar principles apply to Route::apiResource():

// Custom API endpoints first
Route::get('api/posts/trending', [ApiPostController::class, 'trending']);

// Then API resource routes
Route::apiResource('api/posts', ApiPostController::class);

Advanced Routing Techniques

Route Model Binding

Laravel's route model binding can make your custom routes more elegant:

// Define binding in RouteServiceProvider
public function boot()
{
    Route::model('featured_post', \App\Models\Post::class, function ($value) {
        return \App\Models\Post::where('is_featured', true)->find($value);
    });
}

// Then in routes
Route::get('posts/featured/{featured_post}', [PostController::class, 'showFeatured']);
Route::resource('posts', PostController::class);

Custom Route Parameters with Constraints

You can use regex constraints to differentiate between IDs and custom slugs:

Route::get('posts/{post}', [PostController::class, 'show'])->where('post', '[0-9]+');
Route::get('posts/{slug}', [PostController::class, 'showBySlug'])->where('slug', '[a-z0-9\-]+');

Route Caching for Production

In production, always cache your routes for better performance:

php artisan route:cache

Just remember to clear the cache when you make route changes during development:

php artisan route:clear

Case Study: A Complex Blog Platform

Let's imagine we're building a sophisticated blog platform with various specialized routes:

// Custom post routes (must come first)
Route::prefix('posts')->group(function () {
    Route::get('featured', [PostController::class, 'featured'])->name('posts.featured');
    Route::get('recent', [PostController::class, 'recent'])->name('posts.recent');
    Route::get('by-author/{author}', [PostController::class, 'byAuthor'])->name('posts.by-author');
    Route::get('in-category/{category}', [PostController::class, 'byCategory'])->name('posts.by-category');
    Route::get('search', [PostController::class, 'search'])->name('posts.search');
    Route::get('statistics', [PostController::class, 'statistics'])->name('posts.statistics')->middleware('auth:admin');
});

// Standard resource routes
Route::resource('posts', PostController::class);

// Comment routes for posts
Route::resource('posts.comments', CommentController::class)->shallow();

// Tag routes
Route::resource('tags', TagController::class)->only(['index', 'show']);

This organization ensures all custom routes are properly accessible while maintaining the convenience of resource routes for standard CRUD operations.

Performance Considerations

The order of route declarations doesn't just affect functionality—it can impact performance too. Laravel stops matching routes as soon as it finds the first match, so:

Put your most frequently accessed routes first (after any custom routes for resources)
Group similar routes together with prefixes
Use middleware groups efficiently to avoid running unnecessary middleware

Conclusion: Master Laravel Routing Order for Better Applications

The order of your Laravel routes isn't just a minor implementation detail—it's a crucial aspect of building robust, bug-free applications. By understanding how Laravel processes route definitions and following the "custom routes first, resource routes second" principle, you'll avoid one of the most common and frustrating issues in Laravel development.

This knowledge might seem simple once you know it, but it's exactly these kinds of "hidden rules" that separate beginners from experienced Laravel developers.

🙋‍♂️ Got a Laravel routing issue I didn't cover?

Drop me a comment below or DM me directly! I'd love to help you solve your Laravel routing challenges.

Are you actively developing with Laravel? Check out my YouTube channel for more Laravel tips and tricks, connect with me on LinkedIn for professional discussion, or explore my Laravel packages and tools on GitHub.

Happy routing! 🚀