Language Fundamentals

Introduction

This document delves into the fundamental building blocks of the programming language, providing a comprehensive overview of its core syntax, structure, and paradigms. Understanding these fundamentals is crucial for writing efficient, maintainable, and robust code.

We will cover topics ranging from basic data representation to advanced object-oriented concepts, offering practical examples and best practices throughout.

Variables and Data Types

Variables are named storage locations that hold data. The language supports a rich set of primitive and complex data types:

Primitive Types

• Integers: For whole numbers (e.g., int, long).
• Floating-Point Numbers: For numbers with decimal points (e.g., float, double).
• Booleans: For logical values (true or false).
• Characters: For single characters (e.g., char).

Complex Types

• Strings: For sequences of characters.
• Arrays: For ordered collections of elements of the same type.
• Structures/Records: For grouping related data items.
• Objects: Instances of classes, representing more complex data structures and behaviors.

Variable declaration typically involves specifying the data type and a unique identifier:

int age = 30;
string name = "Alice";
double price = 19.99;

Operators

Operators are special symbols that perform operations on operands (variables and values). Common categories include:

• Arithmetic Operators: +, -, *, /, % (modulo).
• Comparison Operators: ==, !=, <, >, <=, >=.
• Logical Operators: && (AND), || (OR), ! (NOT).
• Assignment Operators: =, +=, -=, etc.
• Bitwise Operators: For manipulating bits directly.

Operator precedence determines the order in which operations are performed. Parentheses can be used to explicitly control the order.

int result = (10 + 5) * 2; // result will be 30

Control Flow

Control flow statements dictate the order in which instructions are executed. This allows programs to make decisions and repeat actions.

Conditional Statements

• if, else if, else: Execute code blocks based on conditions.
• switch: Select one of many code blocks to execute based on a value.

Loops

• for: Iterate a specific number of times.
• while: Iterate as long as a condition is true.
• do-while: Iterate at least once, then as long as a condition is true.
• foreach (or similar): Iterate over elements of a collection.

Example using an if statement and a for loop:

int count = 0;
for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        count++;
    }
}
// count will be 5

Functions and Methods

Functions (or methods within classes) are blocks of reusable code that perform a specific task. They help in modularizing code and reducing redundancy.

Functions can accept parameters (inputs) and return values (outputs).

// Function definition
int add(int a, int b) {
    return a + b;
}

// Function call
int sum = add(5, 7); // sum will be 12

Classes and Objects

Object-Oriented Programming (OOP) is a paradigm that uses "objects" – which can contain data fields and methods – to design applications. Classes are blueprints for creating objects.

• Classes: Define the structure and behavior of objects.
• Objects: Instances of classes.
• Encapsulation: Bundling data and methods that operate on that data within a single unit.
• Inheritance: Allowing a new class to inherit properties and methods from an existing class.
• Polymorphism: Allowing objects of different classes to be treated as objects of a common superclass.

class Dog {
    string breed;
    void bark() {
        print("Woof!");
    }
}

Dog myDog = new Dog();
myDog.breed = "Labrador";
myDog.bark(); // Prints "Woof!"

Error Handling

Robust applications need to gracefully handle errors and exceptions that may occur during runtime.

• Exceptions: Events that occur during program execution that disrupt the normal flow of instructions.
• Try-Catch Blocks: Used to detect and handle exceptions.

try {
    // Code that might throw an exception
    int result = 10 / 0;
} catch (DivideByZeroException ex) {
    // Handle the exception
    print("Error: Cannot divide by zero.");
} finally {
    // Code that always executes, whether an exception occurred or not
    print("Cleanup complete.");
}