Métodos
## Objetivos de Aprendizaje
- Definir y llamar métodos
- Comprender parámetros y valores de retorno
- Dominar la sobrecarga de métodos
- Aprender argumentos variables
## Definición de Métodos
### Estructura Básica
```java
public static void greet() {
System.out.println("Hello!");
}
```
### Método con Tipo de Retorno
```java
public static int add(int a, int b) {
return a + b;
}
```
### Llamando Métodos
```java
public class Main {
public static void main(String[] args) {
greet(); // método void
int sum = add(5, 3); // retorna 8
System.out.println(sum);
}
public static void greet() {
System.out.println("Hello!");
}
public static int add(int a, int b) {
return a + b;
}
}
```
## Parámetros y Argumentos
### Pasando Argumentos
```java
public static void printName(String name) {
System.out.println("Name: " + name);
}
// Llamar con argumento
printName("Alice");
```
### Múltiples Parámetros
```java
public static int calculateArea(int width, int height) {
return width * height;
}
int area = calculateArea(5, 10); // 50
```
### Valores de Retorno
```java
public static boolean isEven(int number) {
return number % 2 == 0;
}
if (isEven(4)) {
System.out.println("Even");
}
```
## Tipos de Retorno
### void (Sin Retorno)
```java
public static void printHello() {
System.out.println("Hello");
}
```
### Retornar Temprano
```java
public static String getGrade(int score) {
if (score >= 90) return "A";
if (score >= 80) return "B";
if (score >= 70) return "C";
return "F";
}
```
### Múltiples Retornos (Cláusulas de Guardia)
```java
public static boolean validate(int age, String name) {
if (age < 0) return false;
if (name == null || name.isEmpty()) return false;
// validación principal
return true;
}
```
## Sobrecarga de Métodos
### Mismo Nombre, Diferentes Parámetros
```java
public static int add(int a, int b) {
return a + b;
}
public static double add(double a, double b) {
return a + b;
}
public static int add(int a, int b, int c) {
return a + b + c;
}
```
### Cómo Funciona
```java
add(5, 3); // Llama a add(int, int)
add(5.0, 3.0); // Llama a add(double, double)
add(1, 2, 3); // Llama a add(int, int, int)
```
### Resolución de Sobrecarga
Java determina qué método llamar basándose en:
1. Número de argumentos
2. Tipo de argumentos
3. Orden de tipos de argumentos
## varargs (Argumentos Variables)
### Sintaxis
```java
public static int sum(int... numbers) {
int total = 0;
for (int num : numbers) {
total += num;
}
return total;
}
// Puede pasar cualquier número de argumentos
sum(1, 2, 3); // suma de 1, 2, 3 = 6
sum(1, 2, 3, 4, 5); // suma de 1, 2, 3, 4, 5 = 15
sum(); // 0
```
### Con Parámetros Regulares
```java
public static void printAll(String prefix, int... numbers) {
for (int num : numbers) {
System.out.println(prefix + num);
}
}
printAll("Value: ", 1, 2, 3);
// Value: 1
// Value: 2
// Value: 3
```
## Métodos Estáticos
### Pertenecen a la Clase, No a la Instancia
```java
public class MathUtils {
public static int square(int x) {
return x * x;
}
}
// Llamar sin crear instancia
int result = MathUtils.square(5);
```
### Cuándo Usar static
- Métodos utilitarios (Math.random(), Arrays.sort())
- Métodos que no necesitan datos de instancia
- Constantes
## Métodos de Instancia
### Requieren Instancia de Objeto
```java
public class Person {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}
// Debe crear instancia
Person p = new Person();
p.setName("Alice");
System.out.println(p.getName());
```
## Pasando Primitivos vs Referencias
### Primitivos (Pasados por Valor)
```java
public static void doubleIt(int x) {
x = x * 2; // Solo afecta la copia local
}
int num = 5;
doubleIt(num);
System.out.println(num); // Sigue siendo 5
```
### Objetos (Pasados por Valor de Referencia)
```java
public static void changeName(Person p) {
p.setName("Bob"); // Afecta el objeto original
}
Person person = new Person();
person.setName("Alice");
changeName(person);
System.out.println(person.getName()); // Bob
```
### Reasignando Referencia
```java
public static void reassign(Person p) {
p = new Person(); // Solo afecta la copia local
p.setName("Charlie");
}
Person person = new Person();
person.setName("Alice");
reassign(person);
System.out.println(person.getName()); // Alice
```
## Recursión
### Método Llamándose a Sí Mismo
```java
public static int factorial(int n) {
if (n <= 1) return 1;
return n * factorial(n - 1);
}
// factorial(5) = 5 * 4 * 3 * 2 * 1 = 120
```
### Alternativa Iterativa
```java
public static int factorial(int n) {
int result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}
```
## Resumen
- Métodos: `modificador_acceso static? tipo_retorno nombre(params) { }`
- Sobrecarga: mismo nombre, diferentes parámetros
- varargs: `tipo... nombre` para argumentos variables
- static: pertenece a la clase, llamado como `NombreClase.método()`
- Primitivos pasados por valor; objetos pasados por valor de referencia
- Recursión: método se llama a sí mismo (asegurar caso base)
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →