Ir al contenido principal

Clases y objetos en Java

Introducción

Las clases y los objetos constituyen el núcleo de la programación orientada a objetos en Java. Una clase es una plantilla o modelo que define las características y comportamientos que tendrán los objetos creados a partir de ella. Los objetos, por su parte, son instancias concretas de estas clases, con valores específicos para sus atributos y la capacidad de ejecutar los métodos definidos. En este artículo, exploraremos estos conceptos fundamentales que te permitirán comenzar a estructurar tus programas de manera orientada a objetos.

Definición de una clase en Java

Una clase en Java se define utilizando la palabra clave class seguida del nombre de la clase y un bloque de código delimitado por llaves {}. Dentro de este bloque, definimos los atributos (variables) y métodos (funciones) que conformarán la clase.

public class Coche {
    // Atributos (también llamados variables de instancia)
    String marca;
    String modelo;
    int año;
    String color;
    double velocidad;
    
    // Métodos
    void acelerar(double incremento) {
        velocidad += incremento;
        System.out.println("El coche acelera a " + velocidad + " km/h");
    }
    
    void frenar(double decremento) {
        if (velocidad - decremento >= 0) {
            velocidad -= decremento;
        } else {
            velocidad = 0;
        }
        System.out.println("El coche frena hasta " + velocidad + " km/h");
    }
    
    void mostrarInfo() {
        System.out.println("Coche: " + marca + " " + modelo + " (" + año + ")");
        System.out.println("Color: " + color);
        System.out.println("Velocidad actual: " + velocidad + " km/h");
    }
}

En este ejemplo, hemos definido una clase Coche con varios atributos que describen sus características (marca, modelo, año, color y velocidad) y métodos que representan acciones que un coche puede realizar (acelerar, frenar y mostrar información).

Creación de objetos (instanciación)

Una vez definida una clase, podemos crear objetos (instancias) de esa clase utilizando el operador new. Este proceso se conoce como instanciación.

public class PruebaCoche {
    public static void main(String[] args) {
        // Creación de un objeto de la clase Coche
        Coche miCoche = new Coche();
        
        // Asignación de valores a los atributos
        miCoche.marca = "Seat";
        miCoche.modelo = "Ibiza";
        miCoche.año = 2020;
        miCoche.color = "Rojo";
        miCoche.velocidad = 0;
        
        // Llamada a los métodos del objeto
        miCoche.mostrarInfo();
        miCoche.acelerar(50);
        miCoche.mostrarInfo();
        miCoche.frenar(20);
        miCoche.mostrarInfo();
        
        // Creación de un segundo objeto
        Coche otroCoche = new Coche();
        otroCoche.marca = "Renault";
        otroCoche.modelo = "Clio";
        otroCoche.año = 2019;
        otroCoche.color = "Azul";
        otroCoche.velocidad = 0;
        
        otroCoche.mostrarInfo();
        otroCoche.acelerar(70);
    }
}

La salida de este programa sería algo así:

Coche: Seat Ibiza (2020)
Color: Rojo
Velocidad actual: 0.0 km/h
El coche acelera a 50.0 km/h
Coche: Seat Ibiza (2020)
Color: Rojo
Velocidad actual: 50.0 km/h
El coche frena hasta 30.0 km/h
Coche: Seat Ibiza (2020)
Color: Rojo
Velocidad actual: 30.0 km/h
Coche: Renault Clio (2019)
Color: Azul
Velocidad actual: 0.0 km/h
El coche acelera a 70.0 km/h

Atributos de clase

Los atributos de una clase (también llamados campos o variables de instancia) definen las características o propiedades que tendrán los objetos de esa clase. Cada objeto tendrá su propia copia de estos atributos con valores independientes.

Declaración de atributos

Los atributos se declaran dentro de la clase pero fuera de cualquier método:

public class Persona {
    // Atributos
    String nombre;
    String apellido;
    int edad;
    double altura;
    boolean esEstudiante;
}

Tipos de atributos

Los atributos pueden ser de cualquier tipo de dato en Java:

  • Tipos primitivos: int, double, boolean, etc.
  • Tipos de referencia: String, arrays, otras clases, etc.

Modificadores de acceso para atributos

Podemos definir quién puede acceder a los atributos utilizando modificadores de acceso:

public class Empleado {
    // Público - accesible desde cualquier parte
    public String nombre;
    
    // Privado - solo accesible dentro de la clase
    private double salario;
    
    // Protegido - accesible en la clase y sus subclases
    protected int añosAntiguedad;
    
    // Sin modificador (paquete) - accesible dentro del mismo paquete
    String departamento;
}

Métodos de clase

Los métodos definen el comportamiento de los objetos, es decir, las acciones que pueden realizar. Son similares a las funciones en otros lenguajes de programación.

Declaración de métodos

Un método se declara con un tipo de retorno (o void si no devuelve nada), un nombre, y opcionalmente una lista de parámetros:

public class Calculadora {
    // Método que recibe dos parámetros y devuelve un resultado
    int sumar(int a, int b) {
        return a + b;
    }
    
    // Método que no devuelve nada (void)
    void mostrarMensaje(String mensaje) {
        System.out.println("Mensaje: " + mensaje);
    }
}

Llamada a métodos

Para llamar a un método, utilizamos la sintaxis objeto.metodo(argumentos):

Calculadora miCalculadora = new Calculadora();
int resultado = miCalculadora.sumar(5, 3);
System.out.println("Resultado: " + resultado);
miCalculadora.mostrarMensaje("Operación completada");

Acceso a atributos y métodos

Para acceder a los atributos y métodos de un objeto, se utiliza la notación de punto (.):

Persona persona1 = new Persona();
persona1.nombre = "Laura";  // Acceso a un atributo
persona1.saludar();        // Llamada a un método

Variables de referencia

Cuando creamos un objeto con new, se devuelve una referencia a ese objeto. Esta referencia se almacena en una variable y nos permite interactuar con el objeto:

Coche coche1 = new Coche();  // coche1 es una variable de referencia

Es importante entender que la variable no contiene el objeto en sí, sino una referencia (o dirección de memoria) donde se encuentra el objeto.

Referencias múltiples a un mismo objeto

Varias variables pueden referirse al mismo objeto:

Coche coche1 = new Coche();
coche1.marca = "Toyota";

Coche coche2 = coche1;  // coche2 y coche1 apuntan al mismo objeto
coche2.marca = "Honda";  // Cambia el atributo tanto para coche1 como para coche2

System.out.println(coche1.marca);  // Imprime "Honda"

La palabra clave this

La palabra clave this se refiere al objeto actual en el que se está ejecutando el código. Es útil para distinguir entre atributos de la clase y parámetros con el mismo nombre:

public class Rectangulo {
    double ancho;
    double alto;
    
    void inicializar(double ancho, double alto) {
        this.ancho = ancho;  // this.ancho se refiere al atributo de la clase
        this.alto = alto;    // alto se refiere al parámetro
    }
    
    double calcularArea() {
        return this.ancho * this.alto;
    }
}

Ejercicio práctico

Vamos a crear una clase CuentaBancaria con sus atributos y métodos, y luego utilizarla en un programa principal:

public class CuentaBancaria {
    // Atributos
    String titular;
    String numeroCuenta;
    double saldo;
    
    // Métodos
    void depositar(double cantidad) {
        if (cantidad > 0) {
            saldo += cantidad;
            System.out.println("Se han depositado " + cantidad + " euros. Saldo actual: " + saldo);
        } else {
            System.out.println("La cantidad a depositar debe ser positiva");
        }
    }
    
    void retirar(double cantidad) {
        if (cantidad > 0) {
            if (saldo >= cantidad) {
                saldo -= cantidad;
                System.out.println("Se han retirado " + cantidad + " euros. Saldo actual: " + saldo);
            } else {
                System.out.println("Saldo insuficiente. Operación cancelada");
            }
        } else {
            System.out.println("La cantidad a retirar debe ser positiva");
        }
    }
    
    void consultarSaldo() {
        System.out.println("Titular: " + titular);
        System.out.println("Número de cuenta: " + numeroCuenta);
        System.out.println("Saldo disponible: " + saldo + " euros");
    }
}

Ahora, vamos a utilizar esta clase en un programa principal:

public class GestionBancaria {
    public static void main(String[] args) {
        // Crear una cuenta bancaria
        CuentaBancaria cuenta1 = new CuentaBancaria();
        cuenta1.titular = "Carlos Rodríguez";
        cuenta1.numeroCuenta = "ES1234567890";
        cuenta1.saldo = 1000.0;
        
        // Realizar operaciones
        cuenta1.consultarSaldo();
        cuenta1.depositar(500.0);
        cuenta1.retirar(200.0);
        cuenta1.retirar(2000.0);  // Intentar retirar más de lo disponible
        cuenta1.consultarSaldo();
        
        // Crear otra cuenta
        CuentaBancaria cuenta2 = new CuentaBancaria();
        cuenta2.titular = "Ana López";
        cuenta2.numeroCuenta = "ES0987654321";
        cuenta2.saldo = 2500.0;
        
        cuenta2.consultarSaldo();
        cuenta2.retirar(1000.0);
        cuenta2.consultarSaldo();
    }
}

Resumen

En este artículo, hemos explorado los conceptos fundamentales de clases y objetos en Java. Una clase es una plantilla que define atributos (características) y métodos (comportamientos), mientras que un objeto es una instancia concreta de una clase. Hemos aprendido a definir clases, crear objetos, acceder a atributos y métodos, y utilizar la palabra clave this. Estos conceptos son la base de la programación orientada a objetos y serán esenciales en tu camino como desarrollador Java. En el próximo artículo, profundizaremos en los métodos, sus parámetros y valores de retorno, lo que te permitirá crear funcionalidades más complejas en tus programas.

Volver arriba