Podríamos definir la Programación Orientada a Objetos (POO u OOP en inglés) como una forma de programar en la que se plantean las cosas intentando realizar una asociación con objetos de la vida real, y expresándolas mediante un conjunto determinado de técnicas de programación.
Por ejemplo, si pensamos en un coche nos daremos cuenta de que todos tienen en común determinadas características (marca, modelo, color, cilindrada, etc.) y realizan las mismas acciones (arrancar, acelerar, frenar, apagar, etc.).
El uso de una buena POO facilita enormemente la modularidad de un programa informático permitiendo dividirlo en partes más pequeñas e independientes, así como la detección y depuración de errores, su posterior mantenimiento, y la reutilización del código fuente en otros programas informáticos.
Dentro de este tipo de lenguajes de programación, los más conocidos son C++ y Java, y cabe destacar que no todos ellos implementan las mismas características definidas en dicha metología.
Si nunca has estudiado sobre POO y tras leer lo referente a dicha técnica de programación en el presente te curso te da la impresión de ser algo demasiado complicado no te preocupes... no serás el primero ni el último a quien le sucede al principio (incluso teniendo experiencia en otros tipos de lenguajes de preogramación).
Para comprenderlo todo mejor, consulta los enlaces en los que explicamos cómo hacer las cosas en determinados lenguajes de programación.
La ventaja de utilizar Objetos en lugar de simples Funciones (usadas en la programación estructurada) es que si bien éstas también pueden ser reutilizadas, en caso de tener que realizar un cambio en su comportamiento no sería necesario volver a repetir el código fuente (bastaría con crear otra Clase que herede de la ya existente, y redefinir los métodos existentes o añadir otros nuevos).
Vea también: [ Programación orientada a objetos ] - [ Programación estructurada ]
Podemos entender un Objeto como la representación de una entidad de la vida real con la cual podremos interactuar en el programa.
Antes de poder crear un Objeto es necesario crear una definición del mismo, por lo que primeramente deberemos crear una Clase, la cual contendrá como Miembros:
- Propiedades / Atributos: variables que describen características del Objeto o estados del mismo.
- Métodos: los Métodos se crean de forma parecida a las funciones, y son usados tanto para asignar o devolver el valor de las Propiedades, como para describir la forma en que se comporta el Objeto.
Según el caso, no todos los Miembros de una Clase deben poder ser accesibles desde fuera de ella: para ocultarlos usaremos lo que se conoce como encapsulamiento, pudiendo ser:
- public: se puede acceder a ellos desde cualquier lugar en el que sea posible acceder a la Clase, y también desde las que hereden de ella.
- private: sólo es posible acceder a ellos usando los método proporcionados por la propia Clase (tampoco pueden acceder directamente las clases que hereden de ella).
- protected: accesibles desde las clases que hereden de ella, y desde otras que estén en el mismo package o paquete.
En este punto, un término que debes conocer es el de polimorfismo, que se refiere al hecho de que usando un mismo nombre podemos obtener comportamientos (formas) diferentes, lo que se consigue por medio de la sobrescritura y sobrecarga de métodos y el uso de interfaces. A continuación explicamos el primero de ellos y algo más adelante las otras dos formas de implementarlo.
Las clases deben tener un método denominado constructor, a partir del cuál se crearán Instancias / Objetos.
Es posible que una clase tenga más de un constructor (con el mismo nombre) siempre y cuando tengan parámetros de entrada diferentes. Ello se denomina sobrecarga de métodos (también es aplicable a sus otros métodos).
Una vez explicado todo esto veamos ahora un ejemplo de una clase creada en lenguaje Java.
// Nombre del package o paquete en el que se encuentra
package EjemplosPOO.ejemplo01;
public class Main
{
public static void main(String[] args)
{
// Creamos un objeto de tipo Coche
Coche c1 = new Coche();
/*
* Según hemos creado la clase Coche, al haber sido declarado como 'public' el
* atributo 'codigo' es posible acceder a él desde fuera de la clase del siguiente
* modo.
*
* Normalmente no es recomendable permitirlo para crear lo que se denomina 'encapsulación'.
*/
c1.puertas = 2;
System.out.println( "Puertas: [" + c1.puertas + "]" );
// También se puede acceder directamente a propiedades declaradas como 'protected'
c1.marchas = 3;
System.out.println( "Marchas: [" + c1.marchas + "]" );
System.out.println("---------------");
// Llamamos a algunos de sus métodos 'set' para asignar valores a sus propiedades
c1.setPuertas( 4 );
c1.setMarchas( 5 );
c1.setBastidor( "WAUZZZ8EZ1A000000" );
c1.setTraccion( "DELANTERA" );
// Llamamos a métodos 'get' para obtener los valores de sus propiedades
System.out.println( "Puertas: [" + c1.getPuertas() + "]" );
System.out.println( "Marchas: [" + c1.getMarchas() + "]" );
System.out.println( "Bastidor: [" + c1.getBastidor() + "]" );
System.out.println( "Tracción: [" + c1.getTraccion() + "]" );
System.out.println("===============");
// Creamos otro objeto usando el otro constructor
Coche c2 = new Coche( 2, 6, "VSSZZZ5PZ4R000000", "TRASERA" );
// Llamamos a métodos 'get' para obtener los valores de sus propiedades
System.out.println( "Puertas: [" + c2.getPuertas() + "]" );
System.out.println( "Marchas: [" + c2.getMarchas() + "]" );
System.out.println( "Bastidor: [" + c2.getBastidor() + "]" );
System.out.println( "Tracción: [" + c2.getTraccion() + "]" );
}
}
Coche.java:
// Nombre del package o paquete en el que se encuentra
package EjemplosPOO.ejemplo01;
public class Coche
{
// ---------------------------- PROPIEDADES O ATRIBUTOS
// Normalmente no es recomendado usar 'public' al definir propiedades, ya
// que se podría acceder a ellas desde cualquier lugar fuera de la clase.
public int puertas;
// Las propiedades y métodos 'protected' sólo pueden ser accedidos desde la
// propia clase y desde otras clases que hereden de ella, además desde
// aquellas que estén en el mismo paquete.
protected int marchas;
// Al ser 'private' las siguientes propiedades no se podrá acceder directamente
// a ellas desde fuera de la clase, sino sólo a través de sus métodos.
private String bastidor;
private String traccion;
// ---------------------------- CONSTRUCTOR(ES)
// Constructor vacío
public Coche() {
}
// Otro constructor, con parámetros de entrada diferentes (sobrecarga)
public Coche( int puertas, int marchas, String bastidor, String traccion) {
this.setPuertas(puertas);
this.setMarchas(marchas);
this.setBastidor(bastidor);
this.setTraccion(traccion);
}
// ---------------------------- MÉTODOS
public int getPuertas() {
return this.puertas;
}
// ----------------------------
public void setPuertas(int puertas) {
this.puertas = puertas;
}
// ----------------------------
public int getMarchas() {
return this.marchas;
}
// ----------------------------
public void setMarchas(int marchas) {
this.marchas = marchas;
}
// ----------------------------
public String getBastidor() {
return this.bastidor;
}
// ----------------------------
public void setBastidor(String bastidor) {
this.bastidor = bastidor;
}
// ----------------------------
public String getTraccion() {
return this.traccion;
}
// ----------------------------
public void setTraccion(String traccion) {
this.traccion = traccion;
}
}
Al ejecutar el programa veríamos lo siguiente:
Como habrás podido observar en el ejemplo anterior, se utiliza this para hacer referencia a Miembros de la propia clase.
Vea también: [ Clases en POO ] - [ Objetos en POO ] - [ Encapsulamiento ]
Dependiendo de si es necesario hacerse de otro modo, lo recomendable es que las Propiedades o Atributos de una Clase sean declarados como private o protected (según el caso) de forma que no puedan ser accedidos desde fuera de ellas, debiéndose usar métodos tanto para asignarles un valor como para obtenerlo.
Existen algunas convenciones para escribir los nombres> de las Clases y sus Miembros, que aunque no son obligatorias sí es recomendable usarlas: así pues el nombre de una Clase comienza en mayúscula, mientras que los de sus propiedades y métodos empiezan con minúscula.
