Programación Orientada a Objetos en Java

Programación Orientada a Objetos en
Java
En nuestro post de hoy vamos a tratar el tema la programación orientada a
objetos en Java, ¡no todo va a ser .NET!
En si la POO es bastante amplia y muy necesario para el desarrollo de
software pero ahora nos concentraremos en hacer un ejemplo básico con el
cual se pueda entender la forma en que funciona esto.
Lo que incluye la POO es la Herencia, Polimorfismo, Encapsulamiento, etc.
claro que los 3 mencionados es la parte clave de esto, aunque también
podríamos hablar de cohesión, abstracción, ocultamiento y otros.
Primero veremos un poco de teoría para entenderlo de mejor forma.
Abstracción:
Abstracción en la POO se refiere a poder identificar el posible
comportamiento de un objeto para posteriormente convertirlo en sus métodos
y funciones dentro de una clase.
Encapsulamiento:
Consiste en reunir todos los elementos de un posible objeto el cual se
verán como atributos del mismo para luego realizar el tratado de sus datos
de mejor forma.
Imaginen la clase Persona y un objeto de esta, por ejemplo “Carlos” el
encapsulamiento respectivo a este debería ser sus atributos como nombre,
apellidoPaterno, apellidoMaterno, Edad, etc.
Modularidad:
Es la separación de un software por módulos, en si es una característica
muy importante de la POO. Esta es una forma de realizar software con
módulos independientes pero escalables y que se puedan extender y realizar
el mantenimiento previo de una forma muy sencilla.
Ocultación:
Esto consiste en separar el acceso directo a un objeto, entonces diríamos
que se puede acceder a tales objetos sólo mediante una capa especificada
por este mismo.
Polimorfismo:
Es la acción de poder usar un múltiples posibilidades en una misma
propiedad. También podríamos decir que a nivel de programación sería usar
un método, función, entre otros llamados de la misma forma pero con
diferentes propósitos.
Herencia:
En la POO las clases no se encuentran aisladas, si no que pueden
interactuar con otras clases así compartiendo sus atributos y métodos que
puedan existir entre estas. Un ejemplo sería una clase Persona la cual es
heredada a la clase PersonaNatural y PersonaJurídica. Persona tendría los
datos comunes entre ambos.
Ejemplo
Para este ejemplo sólo veremos un poco de Encapsulamiento, Polimorfismo y
Herencia, también se podrá ver algo de ocultamiento con la capa de negocio
implementada.
– Creamos el proyecto con sus respectivas clases y formularios.
– Ahora diseñamos los formularios “frmPersona”, “frmPersonaNatural” y
“frmPersonaJuridica” respectivamente las cuales se verán de la siguiente
forma.
El primer formulario “frmPersona” es el que se heredará a los otros dos
formularios por lo que tiene los datos en común de ambos. Recordar que
cuando se crea una clase superior que se quiere heredar a otras, se debe
cambiar a todos sus métodos y componentes que se quiere acceder desde la
clase que lo hereda a protected para que esta pueda manipular sus
componentes y métodos o public para que puedan ser accedidos desde
cualquier clase. Por lo tanto tenemos que cambiar los dos componentes
JTextField y el JTable de private a protected en el menu
de propiedades->Code->Variable Modifiers ya que sólo queremos que estos
componentes puedan ser accedidos sólo desde su clase que lo hereda.
–
Ahora
veamos
que
para
heredar
por
ejemplo
en
el formulario “frmPersonaNatural” elformulario “frmPersona” sólo se agrega
en la creación de la clase “extends frmPersona” donde “frmPersona” es el
nombre de la clase de donde heredamos. En este caso extends ya existe
heredando de Swing el cual borramos y cambiamos por nuestroformulario. La
línea donde se crea la clase debería quedar de la siguiente forma.
public class frmPersonaNatural extends frmPersona {
.
.
.
Para el otro formularios sería de la misma forma.
– Realizado esto, al compilar nuestro formulario “frmPersonaNatural”
debería verse de la siguiente forma.
El formulario “frmPersonaJuridica” se verá de la misma forma con la
diferencia de que DNI será RUC.
– Código de la clase de encapsulado TPersona
package Encapsulamiento;
/**
*
* @author kaaf
*/
public abstract class TPersona {
protected String nombreCompleto;
protected int edad;
public void NombreCompleto(String nombreCompleto)
{
this.nombreCompleto=nombreCompleto;
}
public String NombreCompleto()
{
return this.nombreCompleto;
}
public void Edad(int edad)
{
this.edad=edad;
}
public int Edad()
{
return this.edad;
}
}
Este es nuestro encapsulado que se hereda a los otros dos. Como se puede
ver la clase conlleva un método “abstract” el cual hace que la clase sólo
pueda heredarse a otras clases mas no pueda invocarse (No se puede invocar
en clases que no lo heredan). También vemos atributos de tipo protected,
esto hace que dichas variables puedan ser accedidos solamente desde la
clase que lo hereda.
– Código de la clase de encapsulamiento TPersonaNatural.
package Encapsulamiento;
/**
*
* @author kaaf
*/
public class TPersonaNatural extends TPersona{
private String dNI;
public TPersonaNatural(){}
public TPersonaNatural(String nombreCompleto, int edad, String dNI)
{
this.nombreCompleto=nombreCompleto;
this.edad=edad;
this.dNI=dNI;
}
public void DNI(String dNI)
{
this.dNI=dNI;
}
public String DNI()
{
return this.dNI;
}
}
Aquí vemos que es algo más cotidiano, con la diferencia de que heredamos de
TPersona y así podemos acceder a sus atributos “nombreCompleto” y “edad” ya
que estos son protected y están siendo accedidos mediante la herencia.
– Código de la clase de encapsulamiento TPersonaJuridica.
package Encapsulamiento;
/**
*
* @author kaaf
*/
public class TPersonaJuridica extends TPersona {
private String rUC;
public TPersonaJuridica(){}
public TPersonaJuridica(String nombreCompleto, int edad, String rUC)
{
this.nombreCompleto=nombreCompleto;
this.edad=edad;
this.rUC=rUC;
}
public void RUC(String rUC)
{
this.rUC=rUC;
}
public String RUC()
{
return this.rUC;
}
}
Se hace lo mismo que en TPersonaNatural.
Como podemos ver en ambos casos tenemos constructores que cumplen
diferentes funciones. El primer constructor de ambos casos sólo sirve para
instanciar a la clase de encapsulado y el segundo constructor instancia con
el paso de atributos para su almacén dentro del encapsulado. A este acto se
le puede considerar “polimorfismo”.
– Código de la clase NegocioPrincipal
package Negocio;
import Encapsulamiento.TPersonaJuridica;
import Encapsulamiento.TPersonaNatural;
/**
*
* @author kaaf
*/
public class NegocioPrincipal {
public static TPersonaNatural CargarEncapsuladoPN(String
nombreCompleto, int edad, String dNI)
{
return new TPersonaNatural(nombreCompleto, edad, dNI);
}
public static TPersonaJuridica CargarEncapsuladoPJ(String
nombreCompleto, int edad, String rUC)
{
TPersonaJuridica tPersonaJuridica=new TPersonaJuridica();
tPersonaJuridica.NombreCompleto(nombreCompleto);
tPersonaJuridica.Edad(edad);
tPersonaJuridica.RUC(rUC);
return tPersonaJuridica;
}
}
Como podemos ver tenemos dos métodos de tipo public lo que permite acceder
desde cualquier lado y static que libera memoria después de usar dicho
método.
En el primer método vemos el funcionamiento de uno de los constructores de
la clase y en el segundo se muestra el otro constructor de sólo
instanciación.
– Código del botón Registrar de TPersonaNatural
private void btnRegistrarActionPerformed(java.awt.event.ActionEvent evt) {
TPersonaNatural
tPersonaNatural=NegocioPrincipal.CargarEncapsuladoPN(txtNombreCompleto.get
Text(), Integer.parseInt(txtEdad.getText()), txtDNI.getText());
Object[] filaNueva=
{
tPersonaNatural.NombreCompleto(),
tPersonaNatural.Edad(),
tPersonaNatural.DNI()
};
DefaultTableModel
modeloTabla=(DefaultTableModel)TablaPersona.getModel();
modeloTabla.addRow(filaNueva);
TablaPersona.setModel(modeloTabla);
}
– Código del botón Registrar de TPersonaJuridica
private void btnRegistrarActionPerformed(java.awt.event.ActionEvent evt) {
TPersonaJuridica
tPersonaJuridica=NegocioPrincipal.CargarEncapsuladoPJ(txtNombreCompleto.ge
tText(), Integer.parseInt(txtEdad.getText()), txtRUC.getText());
Object[] filaNueva=
{
tPersonaJuridica.NombreCompleto(),
tPersonaJuridica.Edad(),
tPersonaJuridica.RUC()
};
DefaultTableModel
modeloTabla=(DefaultTableModel)TablaPersona.getModel();
modeloTabla.addRow(filaNueva);
TablaPersona.setModel(modeloTabla);
}
Realizado todos estos pasos, nuestra aplicación debería correr de la
siguiente forma.
Ojo: No olviden cambiar los componentes y métodos de las clases superiores
de private a protected o public según lo requiera, caso contrario al
heredar no se podrá tener acceso a los componentes de la clase superior.
Pudimos ver que la POO no es nada complejo sólo que es un poco trabajoso y
aún más si lo implementamos junto a la Programación en Capas, pero tener en
cuenta que si se usan estas tecnologías el desarrollo podrá ser más
trabajoso pero el mantenimiento y la extensión del software es mucho más
sencillo y escalable.
www.asociacionaepi.es