• Modules: organize shared helpers that don’t store data. They just do a job and return a result.
• Classes: represent objects that keep data and have actions.
• Interfaces: agreements about what methods exist so parts can work together without caring how they’re built.
• Delegates: a way to pass a function around so another part of your app can call it later (a callback).

Modules

Purpose

• Provide a namespace for related helpers, constants, and enums.
• Offer reusable helpers that don’t remember data between calls.
• Add extension methods that make calling code cleaner.

Use when

• You need shared helpers (formatting, parsing, conversions).
• You want to group constants/enums (error codes, log levels).
• You’re adding behavior to existing types via extension methods.

Avoid when

• You’re tempted to store changeable global data that creates hidden dependencies.

Benefits

Read more: Xojo Modules Documentation

Classes

Purpose

• Represent real concepts in your app (e.g., an order, a report, a session).
• Keep data and the related rules/actions in one place.
• Separate concerns: core logic in classes, screen logic in the UI.

Use when

• You have data that changes over time and rules to enforce.
• You need services that coordinate steps (for example, “Export report” or “Sync data”).
• You want testable units that don’t depend on UI elements.

Avoid when

• You only need a simple helper that returns a result (that belongs in a Module).
• Platform-specific calls would leak into core logic (hide those behind Interfaces).

Benefits

• Clear rules kept close to the data they protect.
• Clean boundaries between UI, core logic, and data access.

Read more: Xojo OOP Classes Documentation

Interfaces

Purpose

• Define the what without the how.
• Let you swap implementations (e.g., memory vs. SQLite vs. REST) without changing calling code.
• Make testing simple by substituting fakes/mocks.

Use when

• A feature may vary by platform or environment (file system, keychain, camera, notifications).
• You want to keep app logic separate from the details of databases, files, or network calls.
• You’ll have multiple strategies that share the same shape.

Avoid when

• There’s only one implementation and you don’t need to test in isolation.

Benefits

• Loose coupling and easier future changes.
• Cleaner, more stable internal APIs.

Read more: Xojo Interfaces Documentation

Delegates

Purpose

• Provide type-safe callbacks by letting you hand a function to another part of your app.
• Enable flexible behavior without defining a whole interface and class.
• Power progress updates, cancel handlers, filters, or small strategies.

Use when

• You need a one-off callback (progress, completion, error reporting).
• You want to inject small pieces of behavior (sorting, filtering, formatting).
• You’re wiring up dynamic behavior at runtime.

Avoid when

• You need a broader contract with multiple related methods (use an Interface instead).
• You need lifecycle or semantic grouping (a Class with events may be clearer).

Benefits

• Lightweight and expressive.
• Less boilerplate than creating full classes for simple callbacks.
• Encourages small, composable, testable pieces.

Read more: Xojo Delegates Documentation

Quick Decision Guide

• I need to group common helpers and constants. → Module
• I’m modeling an object with data and rules. → Class
• I want to depend on behavior, not a specific implementation. → Interface
• I need a small callback or injected behavior. → Delegate
• I need many subscribers to a lifecycle change. → Event on a class

Quick glossary

• Interface: a contract, a named list of methods something promises to have.
• Delegate: a variable that holds a function to call later (a callback).
• Event: a signal that something happened; other parts can listen for it.

Use Modules to organize shared helpers, Classes to model your world, Interfaces to decouple and swap implementations, and Delegates to pass behavior flexibly. Combined thoughtfully, these features keep Xojo projects easy to change, easy to test, and ready to ship across platforms.

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

What is an Interface?

An Interface in Object-Oriented Programming acts as a contract or a blueprint. It defines a set of methods (functions) that a class must implement, but it does not provide the actual implementation of those methods. Think of it as a list of rules or requirements that a class agrees to follow. This approach makes your code more flexible, reusable, and easier to maintain.

For example, imagine you are building a game with different types of characters, such as warriors, wizards, and archers. Each character might have an attack method, but the way they attack is different. An Interface ensures that all characters have an attack method, but each class can implement it in its own unique way.

Why Use Interfaces?

1. Flexibility: Interfaces allow different classes to be used interchangeably if they implement the same Interface. This makes your code adaptable and scalable.
2. Reusability: You can write code that works with any class that implements the Interface, promoting code reuse.
3. Consistency: Interfaces enforce consistency across classes, ensuring they all have the required methods.
4. Polymorphism: Interfaces enable polymorphism, allowing you to handle different objects through the same interface.

How to Use Interfaces in Xojo

In Xojo, you can create and implement Interfaces to define a set of methods that multiple classes can share, even if they do not share a common superclass. Follow these steps to use Interfaces in Xojo:

1. Create an Interface: Go to the Insert menu in the Xojo IDE and select Class Interface. Give the Interface a descriptive name.

1. Define Methods: Add methods to the Interface. These methods have no code; they only define the method names and parameters.

1. Implement the Interface in a Class: For a class to use the Interface, select the class and from the Inspector, press the Choose button and mark the newly created Interface.

Example 1: Beginner-Friendly Interface

Let’s start with a simple example. Create an Interface called IAnimal that defines a Speak method. Then, create two classes, Dog and Cat, that implement this Interface.

Step-by-Step Guide

1. Define the Interface
   • From the Insert menu, select Class Interface, name it IAnimal and then create a new method Speak.
2. Create the Dog Class
   • Create a class named Dog (Insert menu > Class) and from the Inspector, make sure to select the Interface. Xojo will automatically add the Speak method to the class so let’s add some code:MessageBox("Woof!")
3. Create the Cat Class
   • Create another class, named Cat (Insert menu > Class) and add the following code to the Speak method:MessageBox("Meow!")
4. Test the Interface

Add the following code, to test the Interface, either in the Pressed event of a DesktopButton, or to the Opening event of a DesktopWindow:

Var animals() As IAnimal
animals.Add(New Dog)
animals.Add(New Cat)

For Each animal As IAnimal In animals
  animal.Speak()
Next

Example 2: Interface with Parameters

Now, create a new Class Interface called ICalculator that defines a Calculate method. This method takes two numbers as parameters and returns a result. Then, create two classes, Adder and Multiplier, that implement this Interface.

Step-by-Step Guide

1. Define the Interface
   • Add the following method to define the Interface: Public Function Calculate(a As Integer, b As Integer) As Integer
2. Create the Adder Class
   • Add the following code to theCalculate function: Return a + b
3. Create the Multiplier Class
   • Add the following code to theCalculate function: Return a * b
4. Test the Interface

  Var calculators() As ICalculator
  calculators.Add(New Adder)
  calculators.Add(New Multiplier)

  For Each calc As ICalculator In calculators
    MessageBox("Result: " + calc.Calculate(7, 2).ToString)
  Next

Some Practical Use Cases for Interfaces

Interfaces are versatile and can be used in many situations to make your code more modular and easier to maintain. Here are some practical use cases for Interfaces in Object-Oriented Programming:

1. Data Access Abstraction

Abstract data access using Interfaces. For example, define an IDatabase Interface with methods Connect, Query, and Disconnect. Classes that implement this Interface can interact with different database systems (like MySQL, PostgreSQL, SQLite), allowing you to switch databases without changing your core code.

2. Cross-Platform Development

Abstract platform-specific functionality using Interfaces. For instance, define an IFileSystem Interface with methods ReadFile and WriteFile. Implement this Interface differently for Windows, macOS, and Linux. Your main code can remain the same across platforms.

3. Polymorphism

Enable polymorphism with Interfaces. This lets you process objects differently based on their actual class, but through the same Interface. This is useful when you want to write code that works with any class that implements a particular Interface.

Key Takeaways

• Interfaces define a set of methods that classes must implement.
• They make your code flexible, reusable, and easier to understand.
• Interfaces enforce consistency across different classes.
• They enable polymorphic behavior, allowing you to write generic code.

Conclusion

Whether you’re building a simple application or a complex system, interfaces are a powerful tool in your Object-Oriented Programming toolkit, and Xojo makes them incredibly easy to use. They promote better code organization, flexibility, and reusability. Start experimenting with Interfaces in your projects, and you will see how they can improve your code!

Additional info on Interfaces: https://documentation.xojo.com/getting_started/object-oriented_programming/interfaces.html

If you have questions or want to share your own Interface examples, feel free to start a forum discussion. Happy coding!

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

• Facebook
• X
• LinkedIn
• GitHub
• YouTube