Structured & OOP

Functions, Procedures & Methods

Comparative analysis of subprograms in Java, C, JavaScript, and Python.

1. Pure Functions vs Procedures

A subprogram can act as a pure function (evaluates inputs & returns result) or as a procedure (executes side-effect actions).

Pure Function: Zero side effects. Same input always produces same output.

Procedure (void): Mutates external state, prints UI, or writes DB without returning a value.

RETURN TYPES BY LANGUAGE

Java / Cvoid

JavaScriptundefined

PythonNone

2. Syntax & Access Modifiers

Java: public static int sumar(int a, int b)
C: int sumar(int a, int b)
JavaScript: function sumar(a, b) / const sumar = (a, b) => a + b
Python: def sumar(a: int, b: int) -> int:

Methods.java

public class Operaciones {
    // Método de clase (Estático)
    public static int multiplicar(int x, int y) {
        return x * y;
    }
    
    // Procedimiento (void)
    public static void saludar(String nombre) {
        System.out.println("Hola " + nombre);
    }
}

3. Static vs Instance Methods

Estáticos (Class Methods): Pertencen a la clase. Se invocan sin instanciar (`Math.max()`).

De Instancia: Operan sobre el estado interno del objeto (`this` en Java/JS, `self` en Python).

Car.java

public class Car {
    private int speed;

    // Método de instancia
    public void accelerate(int increment) {
        this.speed += increment;
    }
}

4. Overloading & Default Params

Java resolves overloading at compile time by parameter types. JS and Python use default & variadic params.

default_params.py

def saludar(nombre, mensaje="Bienvenido"):
    return f"{mensaje}, {nombre}!"

print(saludar("Ana")) # Bienvenido, Ana!
print(saludar("Ana", "Hola")) # Hola, Ana!

5. Multiple Returns & Tuples

C and Java functions return a single value/object. Python and JS allow tuple/array destructuring.

destructure.js

// Retorno de múltiples valores mediante desestructuración
function getCoords() {
    return [10.5, 40.2];
}

const [lat, lng] = getCoords();

6. Interactive Method Playground

Select a subprogram pattern to evaluate across languages:

Java

public static int add(int a, int b) { return a + b; }

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

JavaScript

const add = (a, b) => a + b;

Python

def add(a: int, b: int) -> int: return a + b