> 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/ud3-introducion-a-programacion-orientada-a-obxectos/metodos.md).
# Métodos
* O comportamento dos obxectos dunha clase implemétase mediante **métodos**.
* Un método é un conxunto de instrucións que realizan unha determinada tarefa e son similares ás funcións das linguaxes estruturados.
* A interacción entre obxectos prodúcese mediante mensaxes.
* As **mensaxes** son chamadas a métodos dun obxecto en particular (a súa firma)
* Podemos dicir que o obxecto Persoa envía a mensaxe "retirar diñeiro" co obxecto ContaBancaria
* As mensaxes poden conter parámetros. Por exemplo tendo un método na clase ContaBancaria chamado "retirar(double)" que recibe como parámetro a cantidade que hai que retirar
* Unha mensaxe está composto polos seguintes tres elementos:
* O **obxecto destino**, cara ao cal a mensaxe é enviado
* ○ El **nombre del método** a invocar
* Os **parámetros solicitados** polo método
## Métodos en Java
As clases tamén dispoñen de comportamentos. Estes comportamentos chámanse **métodos** e son similares as funcións da programación estruturada. Por exemplo, a clase `Persoa`:copy: pode ter os seguintes métodos: `saudar`:copy:, `cumprirAnos`:copy:, `crecer`:copy:, etc.
Definamos os distintos elementos dun método:
* **Firma do método**: é a declaración do método. Especificase o nome, o tipo de dato que devolve e os parámetros que utiliza.
* **Corpo do método**: é o bloque de código que executa o método cada vez que recibe unha mensaxe.
### Firma de métodos
A sintaxe do prototipo método é a seguinte:
```java
tipoDevolto nomeMetodo(tipoParametro1 parametro1, tipoParametr2 parametro2,...) {
//corpo do método
}
```
`tipoDevolto`:copy: é o tipo de dato do valor devolto polo método. Pode ser calquera tipo de dato primitivo ou unha clase. Se non se devolve ningún tipo de dato, utilízase o literal `void`.
En canto os parámetros de entrada, poden definirse tantos como sexan necesarios, pero tamén é posible que non se necesite ningún, polo que a paréntese estaría baleira. Para cada parámetro debemos indicar o seu tipo de dato e o nome do parámetro.
O método `cumprirAnos`:copy:por exemplo non necesita ningún parámetro de entrada nin devolve ningún valor. Polo tanto o seu prototipo sería o seguinte:
```java
void cumprirAnos(){
// corpo
}
```
O método `crecer`:copy: necesita como parámetro de entrada o incremento que é un `double`:copy: e neste caso tampouco devolve nada. Polo tanto temos o seguinte prototipo:
```java
void crecer(double incremento){
// corpo
}
```
Un terceiro exemplo sería o método `saudar`:copy: que nos devolvería un `String`:copy: que sería o saúdo da persoa. Non necesitaría de ningún parámetro de entrada.
```java
String saudar(){
// corpo
}
```
### Corpo de métodos
Dentro do corpo dos métodos podemos utilizar tanto os parámetros de entrada do método, como os atributos da clase. Por exemplo no método `cumprirAnos`:copy: utilizamos o atributo `idade`:
```java
void cumprirAnos(){
idade++;
}
```
No caso do método crecer utilizamos tanto os parámetros de entrada como os atributos da clase:
```java
void crecer(double incremento){
estatura += incremento;
}
```
No método `saudar`:copy: necesitamos devolver un valor. Isto realízase coa palabra reservada `return`:copy:. O funcionamento deste operador é similar ao visto en Python, agás que en Java só se pode devolver un único valor:
```java
String saudar(){
return "Ola";
}
```
## Exemplo de utilización e creación de obxectos
class Persoa{
String nome;
int idade;
double estatura;
void cumprirAnos(){
idade++;
}
void crecer(double incremento){
estatura+=incremento;
}
String saudar(){
return "Ola";
}
}
```java
class App {
public static void main(String[] args){
Persoa p = new Persoa();
p.idade = 18;
p.cumprirAnos();
System.out.println(p.idade); //Imprimese o valor 19
System.out.println(p.saudar()); //Imprimese "Ola"
p.estatura = 1.70;
p.crecer(0.21);
System.out.println(p.estatura); //Imprimese 1,91
}
}
```
---
# 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/ud3-introducion-a-programacion-orientada-a-obxectos/metodos.md?ask=
```
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.