What are instance variables and methods

Instance variables and methods are elements that specifically belong to each particular instance created from a class.

In other words, each instance we create from a class will have its own unique and independent copy of these variables and methods.

For example, if we have a class Person, which contains two texts Name and Id.

Each instance of person that we create with this class will have its own Name and Id. They will be theirs, own, and independent of all others.

Instance Variables and Methods

Instance Variables

Instance variables, also called fields or properties, are used to store the state of an instance.

Each object created from the class will have its own copy of these variables. For this, each one will have its own memory space to store the information.

Instance Methods

Instance methods are functions that act upon an instance. They can access and manipulate the variables of the same instance. They can also invoke other instance methods.

On the other hand, unlike instance variables, instance methods do not take up memory for each instance. In general, the compiler will substitute it with a single function that receives a reference to the instance.

Practical Case

Let’s go back to our class Person, which now contains two variables Name and Id, as well as two methods Greet() or SendEmail(). That is,

Now, we create two instances of the class Person, which we will call luis and maria. Each of them has different values for the variables Name and Id.

Person luis = new Person();
luis.Name = "Luis";
luis.Id = "000000000";

Person maria = new Person();
maria.Name = "Maria";
maria.Id = "000000001";

We could also use the method Greet() to print the Name variable of each instance.

luis.Greet()  // would display 'Luis' on screen
maria.Greet()  // would display 'Maria' on screen

This is possible because instance methods have access to the variables and methods of this instance.

Examples in Different Languages

Finally, let’s see how different languages implement instance variables and methods.

public class Counter
{
    // Instance variable
    public int Counter;

    // Instance method
    public void IncrementCounter()
    {
        Counter++;
    }
}

// Usage
var counter = new Counter();
counter.IncrementCounter();
Console.WriteLine(counter.Counter);

#include <iostream>

class Counter {
public:
    // Instance variable
    int Counter = 0;

    // Instance method
    void IncrementCounter() {
        Counter++;
    }
};

// Usage
Counter counter;
counter.IncrementCounter();
std::cout << counter.Counter << std::endl;  

class Counter {
    // Instance variable
    constructor() {
        this.counter = 0;
    }

    // Instance method
    incrementCounter() {
        this.counter++;
    }
}

// Usage
const counter = new Counter();
counter.incrementCounter();
console.log(counter.counter);

class Counter {
    // Instance variable
    counter: number = 0;

    // Instance method
    incrementCounter(): void {
        this.counter++;
    }
}

// Usage
const counter = new Counter();
counter.incrementCounter();
console.log(counter.counter);

class Counter:
    def __init__(self):
        # Instance variable
        self.counter = 0

    # Instance method
    def increment_counter(self):
        self.counter += 1

# Usage
counter = Counter()
counter.increment_counter()
print(counter.counter)