Definir estándares de codificación de acuerdo a plataforma de desarrollo elegida

GA7-220501096-AA1-EV02

FICHA: 2626977

TECNOLOGIA: ANALISIS Y DESARROLLO DE SOFTWARE

ALUMNOS:

CRISTIAN JOSE GOMEZ HORTA

EQUER DAVID ALVAREZ VILLAMIL
GUILLERMO HIDALGO

NOVIEMBRE DE 2023
SENA
 TABLA DE CONTENIDO

INTRODUCCION.............................................................................................................................2
Objetivo...........................................................................................................................................3
ESTÁNDARES DE CODIFICACIÓN............................................................................................4
Identificadores...........................................................................................................................4
Archivos fuente..........................................................................................................................4
Clases...........................................................................................................................................5
Métodos.......................................................................................................................................5
Variables y Constantes............................................................................................................5
Alineación y espacios en blanco...........................................................................................7
Estándares de codificación Java más utilizados..............................................................8
 INTRODUCCION

Este documento brinda las convenciones de escritura de código JAVA abarcando

la librería estándar en la principal distribución de Java.

La Programación Orientada a Objetos (POO) es un paradigma de

programación, es decir, un modelo o un estilo de programación que nos da
unas guías sobre cómo trabajar con él. Se basa en el concepto de clases y
objetos. Este tipo de programación se utiliza para estructurar un programa
de software en piezas simples y reutilizables de planos de código (clases)
para crear instancias individuales de objetos.

Un programador diseña un programa de software organizando piezas de

información y comportamientos relacionados en una plantilla llamada clase.
Luego, se crean objetos individuales a partir de la plantilla de clase. Todo el
programa de software se ejecuta haciendo que varios objetos interactúen
entre sí para crear un programa más grande.
 Objetivo

Con el paradigma de Programación Orientado a Objetos lo que buscamos es

dejar de centrarnos en la lógica pura de los programas, para empezar a
pensar en objetos, lo que constituye la base de este paradigma. Esto nos
ayuda muchísimo en sistemas grandes, ya que, en vez de pensar en
funciones, pensamos en las relaciones o interacciones de los diferentes
componentes del sistema.
 ESTÁNDARES DE CODIFICACIÓN

Una guía de estilo es un conjunto de reglas para dar formato a los programas.
Seguir normas de estilo agiliza encontrar la esencia de los programas.

Para lograr la legibilidad de un programa es importante considerar aspectos tales

como el nombre de los identificadores, escribir el código con cierta alineación y
líneas en blanco en lugares apropiados, así como realizar una buena
documentación.

Identificadores

Los identificadores deben ser elegidos de tal manera que el solo nombre describa
el uso que se dará dentro del programa, por tanto, no es recomendable usar
identificadores de una letra, excepto en el for, ni abreviaturas raras o ambiguas.

Además de eso es recomendable que se escriban:

 Empezando con mayúscula si se trata del nombre de una clase o interfaz, y

empezando cada palabra en identificador con mayúscula. CírculoColoreado
 Sólo con mayúsculas si es el nombre de una constante. DIAS_HABILES
 Empezando con minúscula si es el nombre de cualquier otro identificador.
De preferencia el nombre de cualquier método debe ser un verbo en
infinitivo y el de todo atributo un sustantivo. primerJugador, asignarSueldo().

Archivos fuente

Cada programa en Java es una colección de uno o más archivos. El programa

ejecutable se obtiene compilando estos archivos. En cada archivo especifica su
contenido como sigue:

1. Los paquetes (instrucción package).

2. Los archivos de biblioteca (Instrucciones import).
3. Un comentario explicando el objetivo del archivo.
4. Las clases que defines en ese archivo.
Clases

Cada clase debe ir precedida por un comentario que explique su objetivo. Es

recomendable especificar sus elementos como sigue:

1. Estructura de los objetos. Primero las variables y luego las constantes.

2. Elementos estáticos.
3. Constructores.
4. Métodos públicos y privados.
5. Métodos estáticos.
6. Clases internas.

Deja una línea en blanco después de cada método.

Todos los elementos deben estar precedidos por public, private o protected. Las
variables deben ser privadas. Los métodos y las constantes pueden ser privados o
públicos, según se requiera.

Métodos

Todo método excepto main debe empezar con un comentario en formato javadoc

El cuerpo de un método no debe exceder 30 líneas de código. Esto te obligará a

dividir un método complejo en varios más sencillos.

Variables y Constantes

Variables

Las variables se escribirán siempre en minúsculas. Las variables compuestas

tendrán la primera letra de cada palabra componente en mayúsculas.

Las variables nunca podrán comenzar con el carácter "_" o "$". Los nombres de
variables deben ser cortos y sus significados tienen que expresar con suficiente
claridad la función que desempeñan en el código. Debe evitarse el uso de
nombres de variables con un sólo carácter, excepto para variables temporales.

Unidad unidad;
Agenda agenda;
Tramite tramite;
NO definas más de una variable por línea:
int horas = 0, minutos = 0; //Mal
es mejor:
int horas = 0,
minutos = 0;
No uses números mágicos. Excepto -1, 0, 1 y 2 todas las literales numéricas
dentro del código se consideran números mágicos.
if (p.horas() > 40) ... // MAL
es mejor usar constantes definidas;
final int HORAS = 40;
....
if (p.horas() > HORAS) ... //Bien

Constantes

Todos los nombres de constantes tendrán que escribirse en mayúsculas. Cuando

los nombres de constantes sean compuestos las palabras se separarán entre sí
mediante el carácter de subrayado "_".

int LONGITUD_MAXIMA;
int LONGITUD_MINIMA;
Alineación y espacios en blanco

La alineación de instrucciones se puede hacer de manera automática si se emplea

el editor emacs (es recomendable modificar los tabuladores para que dejen sólo
tres espacios en blanco).

En cualquier caso, los elementos más importantes de ésta son:

 Todos los bloques deben estar alineados de tal manera que sean
fácilmente distinguibles. Dentro de un bloque todas las instrucciones van a
la misma altura.

if (condición) {
proposición_1;
proposición_compuesta {
proposición_2.1;
proposición_2.2;
}
..
proposición_n;
}

 En proposiciones compuestas el paréntesis que abre debe ir en la misma

línea que empieza tal proposición. El paréntesis que cierra debe estar sólo
en la última línea de la proposición y a la misma altura que la línea de inicio:

while(hay_datos()) {
proposiciones
}

 Usa líneas en blanco para separar partes de un método que son

lógicamente distintas.
Estándares de codificación Java más utilizados
Estos son algunos de los estándares de codificación de Java más
utilizados que se pueden encontrar en las convenciones de codificación
mencionadas anteriormente de Oracle y Google, así como en otros
documentos de este tipo.

 Siga la convención de nomenclatura adecuada;

 Añadir comentarios;
 Identificador significa un nombre simbólico que se refiere al nombre
de clases, paquetes, métodos y variables en un programa Java;
 El nombre de la variable debe estar relacionado con su propósito;
 El nombre del método debe relacionarse con la funcionalidad del
método;
 El método no debe contener más de 50 líneas;
 No debe haber código duplicado en la misma clase o en otra clase;
 Declare variables globales solo si es necesario usar en los otros
métodos;
 Vuelva a verificar la creación de variables estáticas dentro de una
clase;
 Evite acceder a las variables directamente desde otras clases; en
su lugar, utilice métodos getter y setter;
 Toda la lógica comercial debe manejarse solo en la clase de
servicio;
 Todo el código relacionado con DB debe estar solo en las clases
DAO;
 Use getters y setters;
 Declarar la variable de instancia como privada;
 Mantenga el alcance de las variables mínimo;
 Asigne nombres significativos a las variables;
 Evite las fugas de memoria liberando las conexiones de la base de
datos cuando finalice la consulta;
 Trate de usar el bloque Finalmente con la mayor frecuencia
posible;
 Utilice el marco Executor para la programación multiproceso.