Chapter 12: Fundamentals of Vala Programming - Conditional Statements, Looping Structures and Object Oriented Programming 

Chapter 12: Fundamentals of Vala Programming - Conditional Statements, Looping Structures, and Object-Oriented Programming

12.1 Introduction

Vala, a modern programming language with strong object-oriented features, is designed to make GNOME application development more efficient and accessible. This chapter introduces you to the core programming constructs in Vala, including conditional statements, looping structures, and the basics of object-oriented programming (OOP). Each section includes practical examples to help you understand these fundamental concepts.

12.2 Conditional Statements in Vala

Conditional statements allow your program to make decisions and execute different code blocks based on certain conditions.

If-Else Statement

The if-else statement is the simplest form of conditional execution.

int number = 10;

if (number > 0) {

    print("Number is positive\n");

} else {

    print("Number is non-positive\n");


Switch Statement

The switch statement allows for more complex conditional logic.

string color = "blue";

switch (color) {

    case "red":

        print("Color is red\n");


    case "blue":

        print("Color is blue\n");



        print("Color is unknown\n");


12.3 Looping Structures in Vala

Loops allow you to execute a block of code repeatedly.

For Loop

The for loop is commonly used for iterating over a range of values.

for (int i = 0; i < 5; i++) {

    print("i = %d\n", i);


While Loop

The while loop continues execution as long as the condition is true.

int count = 0;

while (count < 5) {

    print("count = %d\n", count);



Foreach Loop

The foreach loop is particularly useful for iterating over collections.

string[] colors = {"red", "green", "blue"};

foreach (string color in colors) {

    print("Color: %s\n", color);


12.4 Object-Oriented Programming in Vala

Vala is an object-oriented language, and understanding classes, objects, and methods is crucial.

Defining a Class

A class is a blueprint for objects. It encapsulates data and methods.

public class Animal {

    public string name;

    public Animal(string name) { = name;


    public void speak() {

        print("%s says hello\n", name);



Creating and Using Objects

Objects are instances of a class.

void main() {

    Animal cat = new Animal("Whiskers");

    cat.speak(); // Output: Whiskers says hello



Inheritance allows a class to inherit properties and methods from another class.

public class Dog : Animal {

    public Dog(string name) : base(name) {}

    public void bark() {

        print("%s barks\n", name);



12.5 Conclusion

This chapter provided a primer on some of the key constructs in Vala programming: conditional statements, loops, and the basics of object-oriented programming. These foundational concepts are essential for building efficient and effective applications in Vala. As

you continue to explore Vala, you will discover its full potential in developing high-performance, readable, and maintainable GNOME applications.

Through practical examples and explanations, this chapter aims to equip beginners with a solid understanding of the fundamental programming constructs in Vala. Mastery of these concepts is crucial for any aspiring Vala programmer, setting the stage for more advanced topics in future chapters.

Section 12.6: Declaring Variables and Understanding Data Types in Vala

12.6.1 Introduction to Variables and Data Types

In any programming language, variables are fundamental. They are named storage locations that can hold data. Vala, being a strongly typed language, requires you to specify the type of data a variable can hold. This section will guide you through declaring variables in Vala, understanding its data types, and using constants.

12.6.2 Declaring Variables

In Vala, a variable is declared by specifying its type followed by its name. Optionally, you can initialize it with a value.


type variableName = initialValue;


int age = 25;

string name = "Alice";

bool isActive = true;

12.6.3 Data Types in Vala

Vala supports a variety of data types, which are broadly categorized into primitive types, composite types, and reference types.

Primitive Types:

int: Integer number.

double: Floating-point number.

bool: Boolean value (true or false).

char: Single character.

string: Sequence of characters.

Composite Types:

Arrays: e.g., int[], string[].

Structures: User-defined data types, e.g., struct Point { int x; int y; }.

Reference Types:

Classes: e.g., class Person { }.


12.6.4 Constants

Constants are variables whose value cannot be changed once assigned. In Vala, you declare a constant using the const or readonly keyword.

const: Used for compile-time constants.

readonly: Used for run-time constants, typically for class members.


const double PI = 3.14159;

readonly string APP_VERSION = "1.0.0";

12.6.5 Best Practices

Always choose the most appropriate data type for your variables.

Use meaningful names for variables and constants.

Keep in mind the scope of variables: whether they are local to a method or accessible throughout the class.

For constants, use uppercase letters and underscores (e.g., MAX_SPEED).

12.6.6 Conclusion

Understanding how to declare variables and use the correct data types is a cornerstone of programming in Vala. This knowledge forms the basis of more complex operations and data manipulations that you will encounter as you delve deeper into Vala programming.

This section introduces the basics of variable declarations and data types in Vala, ensuring that learners have a solid foundation for understanding how data is stored and manipulated in the language. The examples and best practices provided are designed to help beginners grasp these essential concepts effectively.

Section 12.7: Declaring Arrays in Vala

12.7.1 Introduction to Arrays in Vala

Arrays are a fundamental data structure in programming, allowing you to store multiple values in a single, contiguous block of memory. Each element in an array can be accessed by its index. In Vala, arrays are straightforward to declare and use. This section will show you how to declare arrays in Vala with sample code.

12.7.2 Declaring Arrays

Arrays in Vala can be declared in several ways, depending on whether you know the elements in advance or need to allocate space for them dynamically.

Fixed-Size Array: When the size and elements of the array are known at compile time.

int[] fixedArray = {1, 2, 3, 4, 5};

Dynamic Array: When the size of the array is not known at compile time, and you want to add elements later.

int[] dynamicArray = new int[5]; // Array with 5 integer elements

12.7.3 Initializing Arrays

Arrays can be initialized at the time of declaration, or their elements can be set individually.

Initialization at Declaration:

string[] names = {"Alice", "Bob", "Charlie"};

Setting Individual Elements:

dynamicArray[0] = 10;

dynamicArray[1] = 20;

dynamicArray[2] = 30;

// and so on...

12.7.4 Accessing Array Elements

You can access elements of an array using their index, which starts from 0.

int firstElement = fixedArray[0]; // Accessing the first element

print("First Element: %d\n", firstElement);

12.7.5 Looping Through Arrays

You can loop through an array using a for or foreach loop.

Using for Loop:

for (int i = 0; i < fixedArray.length; i++) {

    print("%d\n", fixedArray[i]);


Using foreach Loop:

foreach (int element in fixedArray) {

    print("%d\n", element);


12.7.6 Best Practices

Always initialize arrays before using them to prevent undefined behavior.

Be cautious of array bounds; accessing beyond the array size will cause runtime errors.

Use foreach for simplicity when you don't need the index of the elements.

12.7.7 Conclusion

Arrays are a versatile data structure essential for many programming tasks. In Vala, arrays are easy to declare and use, whether you are dealing with fixed-size or dynamic arrays. Understanding how to work with arrays is fundamental to effective programming in Vala.

This section on arrays in Vala provides beginners with essential knowledge on how to declare and use arrays effectively in their programming tasks. The examples are designed to be clear and concise, ensuring a solid understanding of this critical concept.