Lenguajes de Programación

Qué es la Programación Orientada a Objetos

La Programación Orientada a Objetos (POO) es un enfoque de programación que se basa en la creación y manipulación de “objetos”. Estos objetos son entidades que combinan datos y comportamientos en un solo paquete.

En la POO, los objetos tienen atributos que representan sus características o propiedades, y métodos que definen las acciones que pueden realizar. Las clases se utilizan para definir la estructura y el comportamiento de los objetos. Una clase actúa como una plantilla o un modelo a partir del cual se crean objetos individuales con características únicas.

Por ejemplo, considera una aplicación que gestiona vehículos. Podríamos definir una clase “Coche” que tenga atributos como “marca”, “modelo” y “color”, y métodos como “arrancar” y “parar”. Luego, podemos crear múltiples objetos de la clase “Coche”, cada uno con sus propias características y la capacidad de realizar las mismas acciones.

La POO organiza el código de manera modular al combinar datos y comportamientos en objetos, lo que facilita la creación, mantenimiento y reutilización de código en el desarrollo de software. Muchos lenguajes de programación populares son orientados a objetos, como es el caso de Java, C++, Python y C#. A través de este enfoque, los programadores pueden diseñar y construir sistemas de software más organizados, modulares y fáciles de mantener. Pero, ¿qué son realmente las clases en Java y cómo funcionan? Esta pregunta es nuestro punto de partida.

Qué son las clases en Java

En Java, las clases son una parte fundamental de la POO y son la base para la creación de objetos, que son instancias de esas clases. Una clase en Java es un plano o un modelo que define la estructura y el comportamiento de los objetos que se pueden crear a partir de ella.

Imagina que estás desarrollando un videojuego de carreras de coches. En este juego, tienes diferentes tipos de coches, como deportivos, todoterrenos y coches de rally. Cada coche tiene ciertas características y habilidades únicas. En Java, puedes utilizar clases para representar estos coches.

Una clase en Java sería como el plano para crear un coche en tu juego. La clase define qué características tiene el coche (como su modelo, velocidad máxima, potencia del motor, etc.) y qué puede hacer (como acelerar, frenar, girar, etc.).

Conceptos fundamentales de las clases

A continuación, te presentamos algunos de los conceptos fundamentales de las clases en Java:

• Atributos: Las clases pueden tener atributos, también conocidos como variables de instancia, que representan las características o propiedades del objeto. En el ejemplo del coche los atributos serian el modelo, la velocidad máxima, etc.
• Métodos: Las clases contienen métodos que representan el comportamiento del objeto. Los métodos son funciones que pueden realizar acciones y manipular los atributos de la clase. En nuestro caso sería acelerar frenar, girar, etc.
• Constructores: Las clases pueden tener constructores, que son métodos especiales utilizados para inicializar objetos cuando se crean. Los constructores tienen el mismo nombre que la clase y pueden tener diferentes parámetros para configurar el estado inicial del objeto.
• Encapsulación: La encapsulación es un principio de la POO que se refiere a la ocultación de los detalles de implementación de una clase y la exposición controlada de sus atributos y métodos. En Java, puedes utilizar modificadores de acceso como private, protected, public, etc., para controlar el acceso a los miembros de una clase.
• Herencia: Las clases pueden heredar atributos y métodos de otras clases. La herencia permite la creación de jerarquías de clases, donde una clase (subclase o clase derivada) puede extender o heredar características de otra clase (superclase o clase base).
• Instanciación: Para utilizar una clase, primero debes crear una instancia u objeto de esa clase. Puedes hacerlo utilizando el operador new, seguido del nombre de la clase y los argumentos necesarios para el constructor si lo tiene.

Ejemplos prácticos con clases

El siguiente es un ejemplo de una clase sencilla en Java:

public class Persona {
    // Atributos
    private String nombre;
    private int edad;

    // Constructor
    public Persona(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }

    // Método
    public void saludar() {
        System.out.println("Hola, soy " + nombre + " y tengo " + edad + " años.");
    }
}

En este ejemplo, la clase Persona tiene atributos (nombre y edad), un constructor para inicializar los atributos y un método saludar que muestra un mensaje por pantalla. Puedes crear objetos Persona a partir de esta clase utilizando el constructor y luego llamar al método saludar en esos objetos.

Vamos a ver un ejemplo algo más complejo, en esta ocasión crearemos la clase que comentábamos en el ejemplo del videojuego de coches:

public class Coche {
    // Atributos
    private String modelo;
    private int velocidadMaxima;
    private int potenciaMotor;
    private boolean enMarcha;

    // Constructor
    public Coche(String modelo, int velocidadMaxima, int potenciaMotor) {
        this.modelo = modelo;
        this.velocidadMaxima = velocidadMaxima;
        this.potenciaMotor = potenciaMotor;
        this.enMarcha = false; // El coche comienza apagado
    }

    // Métodos
    public void acelerar() {
        if (enMarcha) {
            System.out.println("El coche " + modelo + " está acelerando.");
        } else {
            System.out.println("Primero enciende el coche.");
        }
    }

    public void frenar() {
        if (enMarcha) {
            System.out.println("El coche " + modelo + " está frenando.");
        } else {
            System.out.println("El coche está apagado, no se puede frenar.");
        }
    }

    public void encender() {
        enMarcha = true;
        System.out.println("El coche " + modelo + " se ha encendido.");
    }

    public void apagar() {
        enMarcha = false;
        System.out.println("El coche " + modelo + " se ha apagado.");
    }
}

La clase Coche que se muestra en el código es una representación simplificada de un coche en Java. modelo, velocidadMaxima, potenciaMotor son los atributos o propiedades del coche.

El constructor es un método especial que se llama al crear un objeto de la clase. En este caso, el constructor public Coche(String modelo, int velocidadMaxima, int potenciaMotor) toma tres parámetros (modelo, velocidad máxima y potencia del motor) para inicializar los atributos del coche cuando se crea una instancia de la clase Coche.

También tenemos los métodos acelerar, frenar, encender, apagar encargados de mostrar las diferentes acciones que puede realizar una instancia de esta clase. Los objetos creados a partir de esta clase representarán coches individuales con sus propias propiedades y estados.

Por último, crearemos una clase con varios constructores y métodos más avanzados, la más compleja de las que veremos en este artículo:

public class Coche {
    // Atributos
    /**
     * Marca del coche
     */
    private String marca;
    /**
     * Modelo del coche
     */
    private String modelo;
    /**
     * Año de fabricación del coche
     */
    private int añoFabricacion;
    /**
     * Precio del coche
     */
    private double precio;

    // Métodos
    /**
     * Aplica un descuento al precio del coche si es un modelo antiguo
     * @param descuento
     *
     */
    public boolean aplicarDescuento(double descuento){
        boolean descuentoAplicado = false;
        if (añoFabricacion < 2010){
            precio -= descuento;
            descuentoAplicado = true;
        }
        return descuentoAplicado;
    }

    // Constructores
    /**
     * Constructor por defecto
     */
    public Coche(){
        this.marca = "";
        this.modelo = "";
        this.añoFabricacion = 0;
        this.precio = 0.0;
    }

    /**
     * Constructor con 4 parámetros
     * @param marca Marca del coche
     * @param modelo Modelo del coche
     * @param añoFabricacion Año de fabricación del coche
     * @param precio Precio del coche
     */
    public Coche(String marca, String modelo, int añoFabricacion, double precio){
        this.marca = marca;
        this.modelo = modelo;
        this.añoFabricacion = añoFabricacion;
        this.precio = precio;
    }
}

En este ejemplo, hemos creado una clase llamada “Coche” que representa información sobre diferentes coches. Cada coche tiene atributos como “marca”, “modelo”, “añoFabricacion” y “precio”.

También hemos definido un método llamado “aplicarDescuento” que aplica un descuento al precio del coche si es un modelo antiguo (fabricado antes de 2010).

Por último, hemos agregado dos constructores, uno por defecto que inicializa todos los atributos a valores predeterminados y otro constructor que permite establecer los valores de los atributos al crear un nuevo objeto Coche.

Así es como las clases en Java permiten crear objetos con sus propias características y comportamientos, lo que facilita la creación de programas más organizados y orientados a objetos.

Qué son los objetos en Java

En lo que llevamos de articulo hemos mencionado en varias ocasiones las palabras objeto o instancia, pero, ¿qué es exactamente un objeto en Java?

En Java, un objeto es una instancia específica de una clase que encapsula datos y comportamientos relacionados. Los objetos se crean a partir de clases, que como hemos comentado definen la estructura y el comportamiento de dichos objetos. Cada objeto tiene atributos que almacenan datos y métodos que definen las operaciones que puede realizar.

En el contexto del videojuego de carreras de coches, los objetos son las representaciones concretas de los coches que existen en el juego. Cada objeto coche corresponde a un tipo específico de coche, como un deportivo, un todoterreno o un coche de rally.

Conceptos fundamentales de los objetos

Los objetos tienen atributos y métodos accesibles, para acceder a los métodos y atributos de un objeto, utilizamos el nombre del objeto seguido de un punto (.) y el nombre del método o atributo.

MiClase miObjeto = new MiClase(); // Crear un objeto
miObjeto.miMetodo(); // Acceder a un método
int valor = miObjeto.miAtributo; // Acceder a un atributo

Los atributos son variables que almacenan datos en una clase u objeto. Pueden ser públicos, privados o protegidos, y se pueden acceder utilizando métodos públicos conocidos como getters y setters. Para acceder a un atributo, puedes utilizar estos métodos o, si el atributo es público, acceder directamente al atributo.

// Acceso a un atributo privado a través de métodos getters y setters
public void setNombre(String nombre) {
    this.nombre = nombre;
}
public String getNombre() {
    return nombre;
}

// Acceso a un atributo público
public int edad;

Se pueden acceder a los métodos llamándolos directamente en un objeto o utilizando una referencia al objeto seguida de un punto y el nombre del método.

// Llamar a un método
miObjeto.miMetodo();

Ejemplos prácticos con objetos

Veamos ahora un par de ejemplos. Vamos a comenzar suponiendo que queremos crear objetos coche para poder utilizarlos en nuestro juego, para ello nos basaremos en la segunda clase mostrada en los ejemplos anteriores:

public class JuegoDeCarreras {
    public static void main(String[] args) {
        // Crear objetos coche
        Coche cocheDeportivo = new Coche("Deportivo A", 250, 400);
        Coche cocheTodoTerreno = new Coche("Todoterreno B", 180, 350);

        // Encender los coches
        cocheDeportivo.encender();
        cocheTodoTerreno.encender();

        // Acelerar y frenar los coches
        cocheDeportivo.acelerar();
        cocheTodoTerreno.acelerar();

        cocheDeportivo.frenar();
        cocheTodoTerreno.frenar();

        // Apagar los coches
        cocheDeportivo.apagar();
        cocheTodoTerreno.apagar();
    }
}

En este ejemplo, hemos creado dos objetos coche: cocheDeportivo y cocheTodoTerreno. Cada uno de ellos tiene sus propias características y métodos. Al interactuar con estos objetos, podemos encenderlos, acelerarlos, frenarlos y apagarlos.

A continuacioó, vamos a mostrar cómo podríamos trabajar con la última de las clases mostrada en los ejemplos anteriores:

public class EjemploCoche {
    public static void main(String[] args) {
        // Crear un objeto de la clase Coche usando el constructor con parámetros
        Coche miCoche = new Coche("Toyota", "Camry", 2015, 15000.0);

        // Comentando el objeto creado
        System.out.println("Información de mi coche:");
        System.out.println("Marca: " + miCoche.getMarca());
        System.out.println("Modelo: " + miCoche.getModelo());
        System.out.println("Año de Fabricación: " + miCoche.getAñoFabricacion());
        System.out.println("Precio: $" + miCoche.getPrecio());

        // Aplicar un descuento si es un modelo antiguo
        double descuento = 2000.0;
        boolean descuentoAplicado = miCoche.aplicarDescuento(descuento);

        // Comentando si se aplicó el descuento
        if (descuentoAplicado) {
            System.out.println("Se aplicó un descuento de $" + descuento);
            System.out.println("Nuevo precio: $" + miCoche.getPrecio());
        } else {
            System.out.println("No se aplicó ningún descuento.");
        }
    }
}

En este ejemplo, hemos creado un objeto miCoche de la clase Coche utilizando el constructor con parámetros. Luego, hemos comentado la información del coche, incluyendo la marca, el modelo, el año de fabricación y el precio. Después, hemos intentado aplicar un descuento al precio del coche si es un modelo antiguo y hemos comentado si se aplicó o no el descuento.

Ventajas y desventajas de la POO

La POO es un paradigma de programación ampliamente elogiado, pero como cualquier enfoque, tiene sus luces y sombras. Vamos a examinar las ventajas y desventajas de la POO para obtener una visión más balanceada de esta metodología.

• Ventajas:

  • La principal ventaja de la POO radica en la reutilización de código. Esto significa que puedes aprovechar y modificar clases y objetos existentes en lugar de crear todo desde cero. Esto ahorra tiempo y esfuerzo, además de reducir la posibilidad de errores.
  • Por otro lado, permite agregar nuevas funcionalidades y mejorar el rendimiento de un programa de manera eficiente. Puedes modificar o extender clases existentes sin afectar negativamente el código ya implementado, lo que facilita las actualizaciones y la adaptación a nuevas necesidades.
  • Promueve la división de un programa en módulos más pequeños y manejables. Esto facilita el desarrollo, la depuración y el mantenimiento del código, ya que cada componente se puede abordar de manera independiente.

• Desventajas:

  • La POO puede resultar en un tiempo de ejecución más lento en comparación con otros enfoques de programación, debido a la creación y manipulación de objetos adicionales. Paradigmas como la programación funcional pueden ser más eficientes en este sentido.
  • Los objetos requieren más memoria para almacenar datos y métodos, lo que puede afectar el rendimiento en programas de mediana o gran complejidad. Este mayor consumo de memoria es una consideración importante en sistemas con recursos limitados.
  • Al principio puede resultar compleja, especialmente para programadores novatos. La necesidad de comprender conceptos como herencia, polimorfismo y encapsulación puede aumentar el tiempo de aprendizaje y desarrollo. Sin embargo, con recursos adecuados de aprendizaje, esta barrera se puede superar.

Conclusiones

En conclusión, en este artículo hemos explorado los conceptos fundamentales de la Programación Orientada a Objetos (POO) en Java, un paradigma de programación esencial en el desarrollo de software moderno.

La POO se basa en la creación y manipulación de objetos, que combinan datos (atributos) y comportamientos (métodos) en una sola entidad. Las clases actúan como plantillas para crear objetos, definiendo su estructura y comportamiento. En este artículo hemos explorado conceptos clave de estas, como atributos, métodos, constructores, encapsulación, herencia y instanciación. Además, hemos visto cómo podemos crear objetos y acceder a sus métodos y atributos de forma sencilla, todo esto acompañado con ejemplos prácticos.

Por último, hemos examinado las ventajas y desventajas de la POO, destacando su reutilización de código y modularidad como ventajas, pero también señalando posibles desventajas en términos de consumo de memoria y complejidad inicial.

Si te ha gustado el artículo, te recordamos que esta introducción práctica a Java comenzó con otros artículos previos, que te recomendamos visitar para tener una mejor comprensión de las bases de este lenguaje: Introducción y primeros pasos con Java, Datos y variables en Java, Estructuras de datos en Java, Operadores en Java, Sentencias en Java y Métodos, parámetros y argumentos en Java.