Existe un estándar del software que ha establecido una serie de normas que permiten que, tanto la creación de clases, interfaces, enumeraciones, el código en general, etc., respondan a una serie de recomendaciones de modo tal de mantener uniforme los estándares. Resulta beneficioso trabajar bajo un patrón o estándar de recomendaciones. Por ejemplo, en un grupo multidisciplinario de producción de desarrollo de soluciones de software, resulta muy conveniente considerar una serie de conveciones de manera de hacer que el trabajo resulte lo más claro y directo posible, además claro está de ser uniforme para cada miembro del equipo. Desde la documentación del software hasta las reglas operativas y funcionales se desempeñan de forma organizada y libre de distorsiones o desviaciones que podrían ser negativas en un ambiente de producción y desarrollo.
En la siguiente figura se muestra un sencillo ejemplo donde se han creado una serie de clases e interfaces. En una clase se implementan las interfaces y una clase más. Veamos el siguiente mapa visual de este escenario.
Como podrá observar en el diagrama de clases e interfaces, existe el uso de una herencia simple de dos clases, resultando ser la clase base la llamada Geometria que en su interior contiene un atributo como constante que hace referencia a la constante PI. Aparte, se implementan dos interfaces más. Una interfaz llamada ICirculo posee las funciones que se utilizaran para luego ser implmentadas en la clase heredada con fines de cálculos. No existe polimorfismo en este contexto, pues las interfaces son abstractas y no implementan su cuerpo sino tan solo sus firmas. Bien, como le decía, entonces se implementan estas funciones para luego ser sobrescritas en la clase derivada. Por último, la interfaz ICoordenadas es utilizada para implementar dos Getters & Setters, que como sabrá, no es más que un conjunto de métodos y funciones que se utilizan para insertar o leer datos, siendo estos Getters & Setters encapsulados en las clases como se muestra aquí en este ejemplo.
Convenciones del Estándar del Software
A continuación enumero rápidamente algunas convenciones que sugiere el estándar del software. La convención recomienda que las clases deben empezar sus nombres con la primera letra capitalizada. En el caso de las interfaces sucede lo mismo excepto que se recomienda colocar la letra I "i mayúscula" seguido del nombre de la interfaz y también con la primera letra capitalizada.
En el caso de las variables, se colocan en minúsculas y en caso de tratarse de constante, todo en mayúsculas. Si las variables poseen un nombre con dos palabras unidas, se debe capitalizar la primera letra de la segunda palabra. Este efecto curioso de nombramiento es conocido con el nombre de "camel case". Por último, la misma convención para las variables se aplican al nombramiento tanto de métodos como de funciones.
Implemntaciones Según el Lenguaje de Uso
Cada lenguaje posee su semántica y sus recomendaciones para su correcta escritura de los mismos. Sin embargo, si los lenguajes están debidamente normalizados, tal como le comentaba respecto a las sugerencias de las normalizaciones de los lenguajes, en el fondo, la codificación del software, no debería asumir inconveniente alguno. Se supone que las diferencias funcionales serían muy pocas aunque quizá si estas mismas podrían estar presentes en el modo semántico. De todos modos, en la mayoría de los casos, esto podrá ser omitido. En los siguientes ejemplos, veremos cómo se implementa este mapa de clases e interfaces en el código para tres lenguajes conocidos; el lenguaje C#, el lenguaje PHP y el lenguaje Java respectivamente.
Implementación con C#
namespace MisClasesInterfaces
{
public interface ICoordenadas
{
decimal X { get; set; }
decimal Y { get; set; }
}
public interface ICirculo
{
decimal getDiametro(decimal radio);
decimal getRadio(decimal diametro);
decimal getSuperficie(decimal radio);
}
public class Geometria
{
public const double PI = 3.1415926535897932384626433832795D;
}
public class Circulo : Geometria, ICirculo, ICoordenadas
{
decimal ICirculo.getDiametro(decimal radio)
{
// Poner el código aquí deseado...
throw new NotImplementedException();
}
decimal ICirculo.getRadio(decimal diametro)
{
// Poner el código aquí deseado...
throw new NotImplementedException();
}
decimal ICirculo.getSuperficie(decimal radio)
{
// Aquí se calcula la superficie de un círculo y se hace uso de
// la constante que se encuentra en la clase base Geometria,
// la interface ICirculo implementa las funciones para la clase Circulo y la
// interface ICoordenada implementa los puntos de coordenadas polares.
return (Convert.ToDecimal(PI) * radio * radio);
}
decimal ICoordenadas.X
{
get
{
// Poner el código aquí deseado...
throw new NotImplementedException();
}
set
{
// Poner el código aquí deseado...
throw new NotImplementedException();
}
}
decimal ICoordenadas.Y
{
get
{
// Poner el código aquí deseado...
throw new NotImplementedException();
}
set
{
// Poner el código aquí deseado...
throw new NotImplementedException();
}
}
}
}
Implementación en PHP
namespace MisClasesInterfaces;
interface ICoordenadas
{
function X($x);
function Y($y);
}
interface ICirculo
{
function getDiametro($radio);
function getRadio($diametro);
function getSuperficie($radio);
}
class Geometria
{
public static $PI = 3.1415926535897932384626433832795;
}
class Circulo extends Geometria implements ICoordenadas, ICirculo
{
// Conjunto de Getters & Setters para X e Y
private function X($x)
{
return $x;
}
private function Y($y)
{
return $y;
}
private function getDiametro($radio)
{
// Implementar los códigos Aquí
return 0;
}
private function getRadio($diametro)
{
// Implementar los códigos Aquí.
return 0;
}
private function getSuperficie($radio)
{
return self::$PI * $radio * $radio;
}
}
Implementado en Java
package MisClasesInterfaces;
public interface ICoordenadas {
double X(double x);
double Y(double y);
}
public interface ICirculo {
double getDiametro(double radio);
double getRadio(double diametro);
double getSuperficie(double radio);
}
public class Geometria {
public final double PI = 3.1415926535897932384626433832795;
}
public class Circulo extends Geometria implements ICoordenadas, ICirculo
{
@Override
public double X(double x) {
// Agregar el resto del código aquí.
return 0;
}
@Override
public double Y(double y) {
// Agregar el resto del código aquí.
return 0;
}
@Override
public double getDiametro(double radio) {
// Agregar el resto del código aquí.
return 0;
}
@Override
public double getRadio(double diametro) {
// Agregar el resto del código aquí.
return 0;
}
@Override
public double getSuperficie(double radio) {
return this.PI * radio * radio;
}
}
Si analiza cada una de las implementaciones para cada uno de los lenguajes de uso, notará que en el fondo y hablando funcionalmente, la idea es la misma. Tan solo notará la diferencia en la semántica de cada uno de los lenguaje.
Autor: Wagner, Ariel Alejandro.
21-02-2014 - (Última actualización)
Muchas gracias por leer.
No hay comentarios:
Publicar un comentario