Object-Oriented Programming in Modern Fortran

Welcome to a comprehensive guide on Object-Oriented Programming (OOP) in Modern Fortran. While Fortran is often associated with its procedural heritage, Fortran 2003 and later standards introduced powerful OOP features that rival those found in Java, C++, and D. This document explores how Fortran approaches OOP concepts and provides practical examples using the GNU Fortran Compiler (gfortran). By understanding Fortran's OOP capabilities, you'll be able to write more modular, maintainable, and reusable scientific and engineering code.

📚 Learning Objectives

After completing this exercise, you will be able to:

Understand how Modern Fortran implements Object-Oriented Programming
Define derived types with type-bound procedures (methods)
Create constructors using generic interfaces
Implement encapsulation using public and private access modifiers
Use inheritance with the extends keyword
Understand polymorphism using class and select type
Organize OOP code using Fortran modules
Compile multi-file Fortran OOP programs with gfortran

❓ What is Object-Oriented Programming?

Object-Oriented Programming is a paradigm that organizes code around "objects" that contain both data (variables) and functions (methods). Think of an object like a blueprint: a Drink type defines what properties all drinks have and what operations can be performed on them.

Modern Fortran (2003 and later) supports all of these principles through derived types, type-bound procedures, type extension, and polymorphic variables.

📊 Language Feature Comparison Table

✏️ Example 1: Basic Type Definition

Feature	Java	C++	D	Modern Fortran
Class/Type Definition	`class ClassName`	`class ClassName`	`class ClassName`	`type :: TypeName`
Constructor	`ClassName()`	`ClassName()`	`this()`	Interface + function
Destructor	Automatic (GC)	`~ClassName()`	Automatic or `~this()`	`final :: cleanup`
Inheritance	`extends`	`:`	`:`	`extends(ParentType)`
Access Modifiers	`public, private, protected`	`public, private, protected`	`public, private, protected`	`public, private`
Method Binding	Automatic	`virtual` keyword	Automatic	`procedure ::` in `contains`
Polymorphism	Virtual by default	Must use `virtual`	Virtual by default	`class()` + `select type`
Memory Management	Automatic (GC)	Manual (`new/delete`)	Automatic or Manual	`allocatable` + auto dealloc
Abstract Types	`abstract class`	Pure virtual classes	`abstract` keyword	`abstract` + `deferred`
Constants	`final` keyword	`const` keyword	`immutable` keyword	`parameter` attribute
This/Self Reference	`this`	`this->`	`this`	Passed argument (e.g., `self`)
Compilation	`javac`	`g++`	`gdc`	`gfortran`

☕ Java

public class Drink {
    final int MAXIMUM = 10;
    private String name;
    
    public Drink(String brandName) {
        name = brandName;
    }
    
    public String getName() {
        return name;
    }
}

⚙️ C++

class Drink {
private:
    static const int MAXIMUM = 10;
    string name;
    
public:
    Drink(string brandName) {
        name = brandName;
    }
    
    string getName() {
        return name;
    }
};

🐲 D

class Drink {
    immutable int MAXIMUM = 10;
    private string name;
    
    this(string brandName) {
        name = brandName;
    }
    
    string getName() {
        return name;
    }
}

🔬 Modern Fortran

type :: Drink
    integer, parameter :: MAXIMUM = 10
    private
    character(len=50) :: name
contains
    procedure :: get_name
end type Drink

interface Drink
    module procedure create_drink
end interface

Key Observations for Fortran:

✏️ Example 2: Constructor Patterns

Fortran uses a different approach to constructors than other OOP languages. Instead of a special constructor syntax, Fortran uses interface blocks to create constructor-like behavior:

☕ Java

public Drink(String name) {
    this.name = name;
    this.cost = 1.75;
}

public Drink(String name, 
             double cost) {
    this.name = name;
    this.cost = cost;
}

🔬 Modern Fortran

! Generic interface acts as constructor
interface Drink
    module procedure create_drink
    module procedure create_drink_cost
end interface

! Constructor function 1
function create_drink(name) result(d)
    character(len=*), intent(in) :: name
    type(Drink) :: d
    d%name = name
    d%cost = 1.75
end function

! Constructor function 2
function create_drink_cost(name, cost) &
         result(d)
    character(len=*), intent(in) :: name
    real, intent(in) :: cost
    type(Drink) :: d
    d%name = name
    d%cost = cost
end function

✏️ Example 3: Methods and Type-Bound Procedures

Here's how methods work in Fortran compared to other languages, using the vending machine example:

☕ Java

public void vend() {
    if (available > 0) {
        available -= 1;
        consumed += 1;
        moneyMade += cost;
        System.out.println(
            name + " Purchased.");
    }
}

public double profit() {
    return moneyMade;
}

🔬 Modern Fortran

subroutine vend(self)
    class(Drink), intent(inout) :: self
    if (self%available > 0) then
        self%available = self%available - 1
        self%consumed = self%consumed + 1
        self%money_made = self%money_made &
                        + self%cost
        print *, trim(self%name), &
                 " Purchased."
    end if
end subroutine vend

real function profit(self)
    class(Drink), intent(in) :: self
    profit = self%money_made
end function profit

Key Observations for Fortran Methods:

🥤 The Complete Vending Machine Example

Now let's look at a complete, working example using Modern Fortran and the GNU Fortran Compiler (gfortran). This program implements a simple vending machine that tracks drink sales and profits using separate module and program files.

Why Modules Are Essential for Fortran OOP

⚡ Compilation and Execution Instructions

Step-by-Step: Two-File Compilation with gfortran

The Difference Between Compilation Approaches

Sample Output

📖 Understanding the Code

Module Organization

In Fortran, modules serve as the container for derived types and their associated procedures:

Type Components vs. Type-Bound Procedures

Encapsulation in Action

Approach	Command	When to Use
All at once	`gfortran module.f90 main.f90 -o prog`	Small projects, quick testing
Separate compilation	`gfortran -c module.f90` `gfortran -c main.f90` `gfortran *.o -o prog`	Larger projects, when only some files change
Using Makefile	`make`	Professional projects, automated builds

File	Declaration	Purpose
drink_module.f90	`module drink_module`	Contains the Drink type and all its methods
drink_module.f90	`public :: Drink`	Exports the type and constructor for external use
machine.f90	`use drink_module`	Imports the Drink type into the main program

Aspect	Type Components (Data)	Type-Bound Procedures (Methods)
Declaration	`character(len=50) :: name`	`procedure :: vend`
Location	Before `contains`	After `contains` in type definition
Access	`self%name`	`call self%vend()`
Encapsulation	Usually `private`	Usually `public`

Notice that in the Drink type, all data members are declared private. This means they cannot be accessed directly from outside the module. Instead, users must use the public methods:

❌ Common Mistakes and Solutions

Mistake 1: Compiling in the Wrong Order

Mistake 2: Using type() Instead of class() in Methods

Mistake 3: Forgetting to Declare Procedures in Type Definition

Mistake 4: Calling Methods Without call for Subroutines

Mistake 5: Using . Instead of % for Component Access

Mistake 6: Forgetting intent for the Self Argument

Mistake 7: Module Name Doesn't Match Use Statement

✏️ Your Programming Exercise

Objective

Modify the vending machine program to replace the V8 Splash drink with a new beverage of your choice.

Assignment

The current program includes V8 Splash at $4.25 as the fourth drink. Your task is to:

Replace V8 Splash: Change the drink name to something different (e.g., "Orange Juice", "Apple Cider", "Iced Tea", "Lemonade", etc.) and choose a new price (different from $4.25)
Modify the vending operations: Change how many times each drink is purchased by modifying the number of vend() method calls for each drink
Update the output display: Ensure all the drink names and restock amounts are printed correctly
Test your program: Compile with gfortran and run it to ensure it works properly

Specific Changes to Make

In machine.f90, change the line:

drink4 = Drink("V8 Splash", 4.25)

to your new drink with a new price, for example:

drink4 = Drink("Orange Juice", 3.50)

Keep all four drinks in the program
Keep all the vend() calls (you can change the number of times each is called)
Keep the final output section that displays totals and restocking information

Testing Your Solution

Make your changes to machine.f90 (the module file doesn't need changes)
Save the file

Compile both files together:

gfortran drink_module.f90 machine.f90 -o machine

Run:
```
./machine
```
Verify the output shows your new drink name and the correct profit calculations

🎯 Challenge

Before running your program, calculate what the total profit should be. Does your output match your prediction?

Hint: Total profit = (# of Cokes × $1.75) + (# of Sprites × $1.75) + (# of Dr Peppers × $1.75) + (# of your drink × your price)

🚀 Advanced Topics: Inheritance and Polymorphism

Modern Fortran supports inheritance and polymorphism, though we haven't used them in the vending machine example. Here's a brief overview:

Inheritance with extends

Polymorphism with class and select type

⭐ Key Takeaways About OOP in Modern Fortran

✓ Derived types are Fortran's equivalent of classes
✓ Type-bound procedures in the contains section define methods
✓ Generic interfaces with the type name act as constructors
✓ Use class(TypeName) for polymorphic arguments, type(TypeName) for non-polymorphic
✓ Access components and methods with % operator (not .)
✓ The self argument must be explicitly declared in all methods
✓ Always specify intent for the self argument (in, out, or inout)
✓ Use private for encapsulation and public to export interfaces
✓ Modules must be compiled before program units that use them
✓ Use call for subroutine methods: call obj%method()
✓ Function methods can be used directly in expressions: x = obj%method()
✓ String concatenation uses // and trim() removes trailing spaces

Language	Strengths	Best For
Java	Write once, run anywhere; Strong ecosystem; Great for large projects	Enterprise applications, web backends, Android apps
C++	High performance; Maximum control; Close to hardware	System software, games, performance-critical apps
D	Combines best of Java and C++; Modern features; Fast compilation	Systems programming, learning OOP, rapid development
Modern Fortran	Excellent array handling; Mature numerical libraries; Legacy code compatibility	Scientific computing, numerical simulation, HPC

🔬 Object-Oriented Programming in Modern Fortran

📚 Learning Objectives

❓ What is Object-Oriented Programming?

📊 Language Feature Comparison Table

✏️ Example 1: Basic Type Definition

☕ Java

⚙️ C++

🐲 D

🔬 Modern Fortran

Key Observations for Fortran:

✏️ Example 2: Constructor Patterns

☕ Java

🔬 Modern Fortran

✏️ Example 3: Methods and Type-Bound Procedures

☕ Java

🔬 Modern Fortran

Key Observations for Fortran Methods:

🥤 The Complete Vending Machine Example

Why Modules Are Essential for Fortran OOP

⚡ Compilation and Execution Instructions

Step-by-Step: Two-File Compilation with gfortran

The Difference Between Compilation Approaches

Sample Output

📖 Understanding the Code

Module Organization

Type Components vs. Type-Bound Procedures

Encapsulation in Action

❌ Common Mistakes and Solutions

Mistake 1: Compiling in the Wrong Order

Mistake 2: Using type() Instead of class() in Methods

Mistake 3: Forgetting to Declare Procedures in Type Definition

Mistake 4: Calling Methods Without call for Subroutines

Mistake 5: Using . Instead of % for Component Access

Mistake 6: Forgetting intent for the Self Argument

Mistake 7: Module Name Doesn't Match Use Statement

✏️ Your Programming Exercise

Objective

Assignment

Specific Changes to Make

Testing Your Solution

🎯 Challenge

🚀 Advanced Topics: Inheritance and Polymorphism

Inheritance with extends

Polymorphism with class and select type

⭐ Key Takeaways About OOP in Modern Fortran

🏆 Language Strengths Summary