Introducción a la Programación Orientada a Objetos en Java

La programación orientada a objetos (POO) es una innovadora forma de programar, que facilita las tareas a los programadores, ya que se trata de hacer código expresándolo de una manera mas parecida a la vida real. Algunas ventajas de la POO son que facilita la creación de software de calidad, potencia el mantenimiento y la extensión, y permite la reutilización de código. Dentro de este tipo de programación resuenan muchos conceptos, entre los mas populares son: clase, métodos, herencia, superclase y objetos, entre otros. Para entender mejor el panorama de la programación orientada a objetos, prestemos atención al siguiente ejemplo.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

EJEMPLO:

Estoy en mi oficina y envió chocolates a mi novia. Para esto tengo las siguientes alternativas:

1. Lo hago directamente enviando un mensaje a Roberto (el señor de la tienda de chocolates).
2. Usando un objeto intermedio; se pido a María la secretaria.

El objeto Roberto y el objeto María tienen métodos que entienden mi mensaje.

El objeto Roberto tiene métodos que le permiten realizar la acción que pido.

Si le pido a mi jefe Gabriel que mande los chocolates, seguramente no va a hacerlo porque no tiene el método.

Si hubiese ido a otra tienda de chocolates donde atienda la Sra. Alejandra habría sido el mismo resultado, porque Roberto y Alejandra pertenecen a la misma clase. A esta clase la podríamos llamar Chocolatero.

Probablemente Roberto me pedirá dinero y me entregara un ticket, porque ese método lo usan todos los comerciantes, osea que la clase Chocolatero pertenece a una clase mayor (superclase) llamada Comerciante. Y por esto la clase Chocolatero hereda los métodos de la clase Comerciante.

El hecho de que yo no conozca con exactitud los métodos que usara Roberto, se conoce como ocultamiento de la información.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

En general todas las propiedades y métodos de un objeto se conjuntan en una clase. La clase es un prototipo para crear un objeto (sin clase, no hay objeto), por ello se dice que un objeto es una instancia de clases.

Las partes básicas de un objeto son: el nombre del objeto, sus atributos y sus métodos. En la composición de un objeto el tiempo de vida es la duración de dicho objeto en el programa, el estado de un objeto esta definido por sus atributos y su comportamiento se define por sus métodos. Cuando se crea un objeto se ha de especificar de que clase es, para que el compilador comprenda sus características.


Entonces debemos crear una clase con los atributos y métodos que tenga nuestro objeto, y de esa clase podemos crear mas objetos iguales, pero con diferentes nombres. Los métodos realizan acciones o mensajes que podría llevar a cabo ese objeto, en base a sus atributos y a los parámetros que reciba. Gráficamente es conveniente representar a un objeto o clase así:

Nombre del Objeto

Atributos

Métodos()

Para dar un ejemplo practico del panorama de trabajo de la Programación Orientada a Objetos en java, les presento ahora la abstracción de los datos del mundo real hacia un mundo de código. Se creara la clase Persona, y después crearemos objetos de esa clase; primeramente lo representaremos con el esquema gráfico anterior y posteriormente lo llevaremos a código.

Persona

- Nombre - Edad

+ setNombre() + getNombre() + setEdad() + getEdad() + saludar() + dormir()

El esquema de arriba representa la clase Persona con sus atributos y sus métodos; A lo que en la vida real diríamos "Es una persona con sus características y las cosas que puede realizar". Los atributos de nuestra clase Persona son sus características tales como el nombre y la edad (todas las personas tienen un nombre y una edad), para este sencillo ejemplo solo elegimos 2 atributos, pero se pueden incluir cuantos atributos necesites para realizar tu tarea, así como: color de piel, color de cabello, peso, talla, altura, sexo, teléfono, domicilio, etc. Y solo se contemplan 6 métodos para este ejemplo, pero de igual manera se pueden agregar más métodos si así lo necesita.

Como los atributos son características del objeto, por tanto datos que contienen esa información, debemos pensar en los atributos como variables de tipo primitivas donde almacenaremos esos datos que le pediremos al usuario. Por otra parte los métodos son acciones a realizarse cuando nuestro objeto lo solicite. Algunos métodos requerirán (solicitaran) de alguna información que tendrá que ser introducida por el programa o por el usuario para que ese método lleve a cabo su tarea a esto se refiere comúnmente diciendo "el método solicita un parámetro", algunos otros métodos no necesitan recibir parámetros, ya que no los necesitan para realizar su tarea.

De nuestra clase persona el método setNombre() obtiene (pide) el nombre de la persona; el método getNombre() devuelve (retorna, regresa, da como resultado) el nombre de la persona; setEdad() obtiene la edad de la persona y getEdad() retorna la edad de la persona; el método saludar() muestra un mensaje de saludo y el método dormir() muestra un mensaje para indicar que esta durmiendo.

Como los métodos setNombre() y setEdad() necesitan un saber un nombre y una edad para obtener dicho nombre y dicha edad, se dice que estos métodos reciben o necesitan parámetros, y estos parámetro se indican dentro de los paréntesis de cada método, indicando el tipo de dato y el nombre de la variable del datos que solicitan. Para el resto de los métodos no se necesitan parámetros porque las tareas que realizaran no exigen de ningún dato que pueda requerirse del usuario.

Así que actualizando nuestro esquema de la clase Persona, agregando estos datos, quedaría de la siguiente manera:

Persona

- String nombre - int edad

+ setNombre(String nombre) + getNombre() + setEdad(int edad) + getEdad() + saludar() + dormir()

Ahora para llevar esto a código en nuestro IDE favorito tendremos que crear 2 clases (dos archivos .java). Uno para guardar la clase Persona: sus atributos y métodos; Y otro para guardar nuestra clase principal: el main, el cuerpo donde se ejecutan todas las instrucciones de nuestro programa. (También se puede realizar todo esto en un solo archivo, pero se explicara más adelante como hacerlo). Así que... ¡Hagamos código!

//Archivo: Persona.java

public class Persona{
    
    private String nombre;
    private int edad;
    
    Persona(){
        
    }
    
    Persona(String n, int e){
        nombre=n;
        edad=e;
    }
    
    public void setNombre(String n){
        nombre=n;
    }
    
    public void setEdad(int e){
        edad=e;
    }
    
    public String getNombre(){
        return nombre;
    }
    
    public int getEdad(){
        return edad;
    }
    
    public void saludar(){
        System.out.println("Hola");
    }
    
    public void dormir(){
        System.out.println("zzZzZZzZ");
    }
}

La anterior es la clase Persona con sus respectivos atributos y métodos convertidos a código. Ahora analizaremos nuestra clase persona de 2 atributos, 6 métodos y 2 constructores.

En la linea 3 se declaro el nombre de la clase, en este caso: Persona. En la linea 5 y 6 se declaran los atributos de nuestra clase u objeto (sus características), estos atributos se declaran escribiendo su modificador de acceso, private en nuestro caso, posteriormente el tipo de datos de la variable de nuestro atributo, para el nombre elegimos tipo String ya que utilizamos una cadena de caracteres y para la edad elegimos int ya que la edad es un tipo de dato entero; después de establecer el tipo de dato de las variables o atributos se escribe un nombre para estos, tal como se hiciera en una declaración normal de alguna variable de cualquier tipo.

En la linea 8 se crea un constructor por default, un constructor que esta vació, es como si fuese un método con el mismo nombre de la clase, pero que esta vació, no recibe parámetros, ni retorna algún dato.

En la linea 12 construimos otro constructor con nuevamente el mismo nombre de la clase, pero lo que diferencia a este constructor que al de la linea 8, es que este constructor recibe parámetros. Esto es para inicializar nuestros atributos mediante nuestro constructor, es decir inicializar las variables String nombre y int edad directamente desde el objeto (en la clase main).

Se debe crear un constructor por default cuando cuando hagamos uso de otros constructores. Esto es porque si el compilador observa un método con el mismo nombre de la clase con argumentos (Constructor), deberá existir un método vacío por el mismo nombre, esto de cierta manera salvaguarda a un programador al momento de definir métodos que no vayan a ser definidos erróneamente como Constructores.

Después de ya haber creado nuestros 2 constructores, ahora en la linea 17 creamos nuestro método setNombre(), iniciando con escribir un modificador de acceso, posteriormente una palabra reservada o tipo de dato y después el nombre de nuestro método (el que queramos asignar), siguiente al nombre del método, entre los paréntesis se escriben los parámetros (tipo de dato y nombre), si es que los utilizan. Se abre una llave para indicar que inicia el cuerpo del método y dentro de las llaves se escribe lo que dicho método va a realizar. En este caso, habíamos dicho que setNombre() obtiene el nombre de la persona por tanto si recibe parámetro de tipo String. Y lo que recibe de parámetro se lo asigna a la variable o atributo String nombre. Es lo único que hace este método, establecer el nombre de la persona.

En la linea 21 se realiza una operación similar a la del método anterior, este método solo obtendrá la edad de la persona y lo guardara en int edad.

Los métodos getNombre() y getEdad de las lineas 25 y 29 respectivamente, solo devuelven el el dato que se indica. En el cuerpo de estos métodos, la instrucción return retorna, regresa, devuelve el dato que se especifica delante de esa instrucción; en este caso return nombre; retorna al programa principal (al main) lo que contiene la variable nombre. Y lo mismo hace el método getEdad() con return edad;.

En la linea 33 el método saludar() solo muestra un mensaje en pantalla: "Hola". Y en la linea 37 el método dormir() imprime en pantalla el mensaje: "zzZzZzzZZ" simulando que alguien duerme. Estos dos métodos no solicitan parámetros ya que no requieren saber datos para mostrar dichos mensajes.

Ahora que ya hemos creado nuestra clase Persona, crearemos nuestra clase principal, nuestro main, que va a ser donde se van a ejecutar las instrucciones de nuestro programa, y en donde se van a crear los objetos de la clase Persona, y esos harán llamadas a sus métodos.

//Archivo: EjemploPersona.java

import javax.swing.JOptionPane;

public class EjemploPersona{
    
    public static void main(String args[]){
        
        String nom=JOptionPane.showInputDialog("¿Como te llamas?");
        int años=Integer.parseInt(JOptionPane.showInputDialog("¿Cuantos años tienes?"));
        
        Persona amigo = new Persona();
        
        amigo.setNombre(nom);
        amigo.setEdad(años);
        amigo.saludar();
        
        System.out.println("Me llamo: "+amigo.getNombre()+" y tengo: "+amigo.getEdad()+" años.");
        amigo.dormir();
    }
}

En esta clase principal (comunmente llamado 'main'), se trabajara de igual manera como hemos programado anteriormente, solo que ahora añadiremos la creación de los objetos. En las linea 9 y 10 pedimos los datos correspondientes al usuario y las guardamos en dichas variables. En la linea 12 creamos el objeto amigo de la clase Persona asi como se muestra en dicha linea. De la linea 14 a la 16 se estan usando los métodos que creamos en nuestra clase Persona, esto se lee: "El objeto amigo manda a llamar al metodo setNombre(), setEdad, etc". Y para que un objeto pueda hacer uso de los métodos de su clase, solo basta con escribir el nombre del objeto ya creado, seguido de un punto y el nombre (solo el nombre) del método que desea usar.

Como el método setNombre() requiere parámetros para realizar su tarea y anteriormente definimos que los parámetros que aceptará este método son de tipo String, el usuario o programador deberá introducir ese parámetro que el método solicita dentro de los paréntesis para que se lleve a cabo su función; lo mismo sucede con el método setEdad() que necesita un parámetro de tipo int.

Para los métodos saludar(), dormir(), getNombre() y getEdad() se invocan de igual manera: primero el nombre del objeto seguido de un punto y el nombre del método, solo que estos métodos no llevaran nada dentro de los paréntesis porque no necesitan de que les pasen parámetros para que estos métodos realicen sus tareas.

Hay que diferenciar también en lo que hace de diferente cada método, un comparativa sencilla sería que: el método getNombre() retorna una cadena de caracteres y el método saludar() muestra un mensaje en pantalla (son cosas totalmente diferentes). Por esto si usted usa amigo.saludar(); se imprimirá en pantalla un mensaje: "Hola"; pero si usted usa: amigo.getNombre(); marcara un error, porque esa función le retorna una cadena de caracteres, así que necesita de una variable para guardar lo que le retorna ese método, o necesita que esa llamada a ese método vaya dentro de una instrucción de impresión para que se imprima esa cadena de caracteres en pantalla, como se hace en la linea 18.

Como final, para correr nuestro programa, corremos desde la clase principal, el main.