Java

Clases Y Objetos

Clases y Objetos

En Java, clases y objetos son los dos pilares fundamentales de la programación orientada a objetos (POO). Estos conceptos te permiten modelar y organizar datos de manera eficiente, encapsulando tanto el estado (atributos) como el comportamiento (métodos) en una entidad cohesionada. A continuación, te explico ambos en detalle.

1. ¿Qué es una clase?

Una clase es una plantilla o un modelo que define las propiedades (atributos) y comportamientos (métodos) de los objetos que serán creados a partir de ella. En otras palabras, una clase es una estructura que describe cómo será un objeto.

Definición de clase:

  • Atributos: Son las variables que representan el estado o las características del objeto.
  • Métodos: Son las funciones que definen los comportamientos o acciones que los objetos de esa clase pueden realizar.

En Java, una clase se define con la palabra clave class, seguida del nombre de la clase. Dentro de la clase, se definen los atributos y métodos.

Sintaxis básica de una clase:

public class NombreDeLaClase {
    // Atributos (variables de instancia)
    tipo nombreAtributo;

    // Métodos (funciones)
    public void nombreMetodo() {
        // Código del método
    }
}

Ejemplo de una clase simple:

public class Coche {
    // Atributos
    String marca;
    String modelo;
    int año;

    // Constructor
    public Coche(String marca, String modelo, int año) {
        this.marca = marca;
        this.modelo = modelo;
        this.año = año;
    }

    // Método
    public void arrancar() {
        System.out.println("El coche está arrancando...");
    }

    public void frenar() {
        System.out.println("El coche está frenando...");
    }
}

En este ejemplo:

  • La clase Coche tiene tres atributos: marca, modelo, y año.
  • El método arrancar() describe el comportamiento de arrancar el coche.
  • El método frenar() describe el comportamiento de frenar el coche.
  • El constructor se usa para inicializar los atributos de la clase cuando se crea un objeto.

2. ¿Qué es un objeto?

Un objeto es una instancia de una clase. Es una entidad que tiene su propio estado (valores en los atributos) y puede ejecutar métodos definidos en la clase. En términos sencillos, un objeto es una “copia” de una clase, pero con valores específicos.

Cuando declaras una clase, no se crea un objeto de manera automática. Los objetos deben ser instanciados explícitamente usando la palabra clave new.

Sintaxis para crear un objeto:

NombreDeLaClase nombreDelObjeto = new NombreDeLaClase()

Ejemplo de creación de objetos:

public class Main {
    public static void main(String[] args) {
        // Crear un objeto de tipo Coche
        Coche miCoche = new Coche("Toyota", "Corolla", 2020);

        // Acceder a los atributos y métodos del objeto
        System.out.println("Marca del coche: " + miCoche.marca);
        System.out.println("Modelo del coche: " + miCoche.modelo);
        System.out.println("Año del coche: " + miCoche.año);

        // Llamar a los métodos del objeto
        miCoche.arrancar();
        miCoche.frenar();
    }
}

Salida esperada:

Marca del coche: Toyota
Modelo del coche: Corolla
Año del coche: 2020
El coche está arrancando...
El coche está frenando...

En este ejemplo:

  • miCoche es un objeto de la clase Coche.
  • Al crear el objeto, pasamos los valores “Toyota”, “Corolla” y 2020 al constructor de la clase.
  • Accedemos a los atributos del objeto (miCoche.marca) y llamamos a sus métodos (miCoche.arrancar() y miCoche.frenar()).

3. Atributos y Métodos

Los atributos de una clase definen el estado del objeto, mientras que los métodos definen sus comportamientos o acciones. Estos se pueden clasificar en diferentes tipos de acuerdo a su visibilidad y accesibilidad:

Atributos

  • Atributos de instancia: Son variables que pertenecen a una instancia de la clase. Cada objeto tiene sus propios valores para estos atributos.
  • Atributos estáticos: Son variables compartidas entre todas las instancias de la clase. Se definen con la palabra clave static.

Métodos

  • Métodos de instancia: Son métodos que pertenecen a una instancia del objeto. Para llamarlos, necesitas tener una referencia a un objeto.
  • Métodos estáticos: Son métodos que pertenecen a la clase y pueden ser llamados sin necesidad de crear un objeto. Se definen con la palabra clave static.

Ejemplo de atributos y métodos estáticos y de instancia:

public class Coche {
    // Atributos de instancia
    String marca;
    String modelo;

    // Atributo estático
    static int cantidadDeCoches = 0;  // Atributo compartido por todos los coches

    // Constructor
    public Coche(String marca, String modelo) {
        this.marca = marca;
        this.modelo = modelo;
        cantidadDeCoches++;  // Cada vez que se crea un coche, incrementa la cantidad
    }

    // Método de instancia
    public void mostrarInfo() {
        System.out.println("Marca: " + marca + ", Modelo: " + modelo);
    }

    // Método estático
    public static void mostrarCantidadDeCoches() {
        System.out.println("Cantidad de coches creados: " + cantidadDeCoches);
    }
}

En este caso:

  • El atributo cantidadDeCoches es estático, por lo que es compartido por todas las instancias de Coche.
  • El método mostrarInfo() es un método de instancia que muestra la información específica de un coche.
  • El método mostrarCantidadDeCoches() es un método estático que muestra el número total de coches creados.

Uso de atributos y métodos estáticos:

public class Main {
    public static void main(String[] args) {
        Coche coche1 = new Coche("Toyota", "Corolla");
        Coche coche2 = new Coche("Honda", "Civic");

        coche1.mostrarInfo();
        coche2.mostrarInfo();

        // Llamada al método estático
        Coche.mostrarCantidadDeCoches();
    }
}

Salida esperada:

Marca: Toyota, Modelo: Corolla
Marca: Honda, Modelo: Civic
Cantidad de coches creados: 2

4. Encapsulamiento

El encapsulamiento es un principio fundamental de la programación orientada a objetos que se refiere a la ocultación de los detalles internos de una clase y a la exposición de solo lo necesario. Esto se logra usando modificadores de acceso y proporcionando métodos getter y setter para acceder y modificar los atributos de una clase.

  • private: Hace que los atributos no sean accesibles directamente desde fuera de la clase.
  • public: Permite el acceso a atributos y métodos desde cualquier parte del programa.
  • protected: Permite el acceso dentro de la misma clase, las clases en el mismo paquete y las subclases.
  • default (sin modificador): Permite el acceso solo dentro del mismo paquete.

Ejemplo de encapsulamiento con getters y setters:

public class Coche {
    private String marca;  // Atributo privado
    private String modelo; // Atributo privado

    // Getter para obtener la marca
    public String getMarca() {
        return marca;
    }

    // Setter para modificar la marca
    public void setMarca(String marca) {
        this.marca = marca;
    }

    // Getter para obtener el modelo
    public String getModelo() {
        return modelo;
    }

    // Setter para modificar el modelo
    public void setModelo(String modelo) {
        this.modelo = modelo;
    }
}

De esta manera, los atributos marca y modelo están ocultos, y el acceso a ellos se realiza a través de métodos públicos (getMarca(), setMarca(), etc.), lo que asegura que solo se modifiquen de manera controlada.

5. Herencia y Polimorfismo

En Java, las clases pueden heredar atributos y métodos de otras clases. Esto permite crear una jerarquía de clases y reutilizar código. El polimorfismo permite que las clases hijas proporcionen implementaciones específicas de los métodos heredados de las clases padres.

  • Herencia: Se logra usando la palabra clave extends.
  • Polimorfismo: Se logra mediante la sobrecarga y sobrescritura de métodos.

Ejemplo de herencia y polimorfismo:

public class Vehiculo {
    public void mover() {
        System.out.println("El vehículo se mueve");
    }
}

public class Coche extends Vehiculo {
    @Override
    public void mover() {
        System.out.println("El coche se mueve a 100 km/h");
    }
}

Uso de polimorfismo:

public class Main {
    public static void main(String[] args) {
        Vehiculo vehiculo = new Coche();
        vehiculo.mover(); // Llama al método mover() de Coche, no de Vehiculo
    }
}

Salida esperada:

El coche se mueve a 100 km/h