When is a method considered overridden?

The method is considered overridden in the following cases:

1. It is declared in a subclass.
2. It has the same name as a method in the parent class.
3. It has the same signature (number and types of parameters) and parameter order.
4. It has a return type compatible with the return type of the parent class method (covariance, if applicable).
5. It has the same or a more permissive access modifier than the parent class method (in most object-oriented languages).
6. The parent method is declared as virtual, abstract, or interface (in languages that require explicit indication of override capability, e.g., C# with the virtual keyword).

Example in Java:

// Parent class
class SuperClass {
    // Method that can be overridden
    public void display() {
        System.out.println("This is SuperClass display method.");
    }
}

// Child class
class SubClass extends SuperClass {
    // Overridden display method
    @Override // Annotation to check override at compile time
    public void display() {
        System.out.println("This is SubClass display method.");
    }
}

Example in Python:

# Parent class
class SuperClass:
    # Method that can be overridden
    def display(self):
        print("This is SuperClass display method.")

# Child class
class SubClass(SuperClass):
    # Overridden display method
    def display(self):
        print("This is SubClass display method.")

The key point is to keep the method name and signature the same, but change its behavior in the subclass.

An important distinction from overloading: overloading is declaring multiple methods with the same name in one class but with different signatures. Overriding is declaring a method in a subclass with the same name and signature as in the parent class.