> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/ud2-programacion-estructurada/funcions-e-procedementos.md).

# Funcións e procedementos

O paradigma modular é unha técnica de deseño de software que consiste en dividir un programa en módulos independentes e reutilizables, para face-lo código máis mantible, reusable e escalable.\
Un módulo é unha unidade de código que encapsula unha funcionalidade específica, resolvendo un subproblema do problema orixinal. Cada módulo pode recibir parámetros de entrada, realizar operacións sobre eles e, opcionalmente, devolver un resultado.

O deseño modular baséase no principio **"Divide e vencerás"** ou análise descendente (Top-Down), no que un problema complexo se descompón en partes máis pequenas e manexables\
Os módulos implemétanse nas linguaxes estructurados mediante **procedementos ou funcións**, nos orientados por **obxectos mediante clases** e nos funcionais mediante **funcións**

## Funcións en Java

En Java non existe o concepto de función como tal, senon que o que se pode imlplantar son métodos estaticos de clase. Como aínda non chegamos ao tema de orientación a obxectos, imos obviar este punto. Poderiamos simplificar a definición de función da seguinte forma:

<pre class="language-java"><code class="lang-java"><strong>static tipodevuelto nombreFuncion(tipo param1, tipo2 param, ...) {
</strong>    //declaración de variables locales
    tipodevuelto nomeVariable;
    //cuerpo de la función
    nomeVariable = ... // asignamos o valor a unha variable
    //return finaliza a función devolvendo un valor.
    return nomeVariable;
}
</code></pre>

A nivel de función imos atopar os seguintes elementos:

* **nombreFuncion:** É o nome que lle damos a función: esPar, calcularFactura, imprimirResultados,... Utilizase a notación camelCase o igual que nos variables
* **Parámetros de entrada:** Conxunto de valores que recibe a función para realizar os cálculos necesarios. Unha función pode recibir 0,1 ou N parámetros.
* **tipodevuelto:** Representa o tipo de dato devolto pola función que estamos a definir
* **static:** Palabra reservada en Java que se emprega para definir un método como estático (de clase). Polo de agora compre saber que debemos de definir as funcions e os procedementos utilizando esta palabra
* **return:** Palabra reservada que finaliza a execución da función e devolve un resultado

```java
public class EjemploFuncion {

    // Función que devuelve true si el número es par
    static boolean esPar(int numero) {
        boolean resultado;
        resultado = (numero % 2 == 0);
        return resultado;
    }

    public static void main(String[] args) {
        int num = 10;
        if (esPar(num)) {
            System.out.println(num + " es par.");
        } else {
            System.out.println(num + " es impar.");
        }
    }
}
```

## Procedementos en Java

Un procedemento é un modulo de código que non devolve valor, senon que sinxelamente realiza unha operación. **En Java os procedementos e funcións reciben os parámetros de tipo simple por valor,** por isto a utilización de procedementos con estes tipos esta moi limitada.

Un procedemento vai devolver sempre o tipo **void** (vacío), e igual que as funcións, pode recibir 0,1 ou N parametros.

```java
public class EjemploProcedimiento {

    // Procedimiento: non devolve valor (void)
    static void imprimirSaudo(String nome, int curso) {
        System.out.println("Boas tardes, " + nome + "!");
        System.out.println("¿Como estas?");
        System.out.println("Benvido/a a " + curso + "º de DAW");
    }

    public static void main(String[] args) {
        imprimirSaudo("Lucía", 1);
        imprimirSaudo("Carlos", 2);
    }
}
```

## Ámbito das variables en procedementos e funcións

O ámbito das variables que se declaran dentro de procedementos e funcións é local, de tal forma que ditas variables non van existir fora do procedemento ou función.

```java
public class AmbitoFunción {

    static int sumar(int a, int b) {
        int resultado = a + b;  // 'resultado' é local a esta función
        return resultado;
    }

    public static void main(String[] args) {
        int num1 = 5;
        int num2 = 3;

        int total = sumar(num1, num2);

        System.out.println("A suma é: " + total);

        // A seguinte liña daría erro de compilación:
        // System.out.println(resultado); // ERRO: 'resultado' non existe aquí
    }
}
```

{% hint style="warning" %}
As **variables globales (non estáticas) non son visibles dentro de un procedemento ou función se non o pasamos como parámetro**
{% endhint %}

{% hint style="warning" %}
As **variables con tipo básico** pasadas como parametros, consideranse locales dentro do procedemento, co que **as operacions realizadas dentro do procedemento non se reflicten fora.**
{% endhint %}

```java
public class AmbitoGlobalLocal {

   static void incrementar() {
        int incremento = 1;  // Variable local: só visible aquí
        //A VARIABLE CONTADOR NON É VISIBLE AQUI, O CÓDIGO DA ERRO
        // contador = contador + incremento;
        //System.out.println("Contador dentro da función: " + contador);
    }

    static void incrementar2(int contador) {
        int incremento = 1;  // Variable local: só visible aquí
        //A VARIABLE CONTADOR NON É VISIBLE AQUI
        contador = contador + incremento;
        System.out.println("Contador dentro da función: " + contador);
    }

    public static void main(String[] args) {
        int contador = 0;
        //incrementar(); Esta chamada da error
        System.out.println("Valor final do contador: " + contador);
        contador = 0;
        incrementar2(contador);
        System.out.println("Valor final do contador con incrementar2: " + contador);
    }
}
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://educacion.gitbook.io/programacion/ud2-programacion-estructurada/funcions-e-procedementos.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.