Este artículo describe los diez mandamientos principales que los desarrolladores de Java deben conocer. Compártelo con todos para tu referencia, los detalles son los siguientes:
Como desarrollador de Java, mejorar la calidad y la capacidad de mantenimiento de su propio código es un tema constante. Vi este artículo en línea y lo usé para animarme.
Existen muchos estándares y mejores prácticas para los desarrolladores de Java. Este artículo enumera las diez reglas básicas que todo desarrollador debe seguir; si hay reglas que se pueden seguir pero no, conducirá a un final muy trágico.
1. Añade comentarios a tu código
Todo el mundo lo sabe pero de alguna manera se olvida de seguirlo. Cuente cuántas veces se le ha "olvidado" agregar una anotación. Es cierto: los comentarios no contribuyen sustancialmente a la funcionalidad del programa. Sin embargo, debe volver al código que escribió hace dos semanas una y otra vez, tal vez durante toda la vida, y no debe recordar por qué el código se comporta así. Si estos códigos son tuyos, estás de suerte. Porque podría traer recuerdos. Pero desafortunadamente, muchas veces el código pertenece a otra persona y es muy probable que haya abandonado la empresa.
2. No compliques las cosas
Lo he hecho antes y estoy seguro de que todos lo han hecho. Los desarrolladores suelen encontrar una solución a un problema simple. Introdujimos EJB para una aplicación con solo 5 usuarios. Usamos un marco para una aplicación que ni siquiera lo necesita. Agregamos archivos de propiedades, soluciones orientadas a objetos e hilos a la aplicación, pero no los necesitaba en absoluto. ¿Por qué hacemos esto? Algunos de nosotros lo hacemos porque no sabemos cómo hacerlo mejor, pero otros lo hacemos para aprender nuevos conocimientos y hacer que la aplicación sea más interesante para nosotros.
3． Recuerde: "menos es más" no siempre es bueno
La eficiencia del código es una gran cosa, pero en muchos casos, escribir menos líneas de código no hace que el código sea más eficiente. Por favor déjame mostrarte un ejemplo simple.
if(newStatusCode.equals("SD") && (sellOffDate == null || todayDate.compareTo(sellOffDate)<0 || (lastUsedDate!= null && todayDate.compareTo(lastUsedDate)>0)) || (newStatusCode.equals ("OBS") && (OBSDate == nulo || todayDate.compareTo(OBSDate)<0))){ newStatusCode = "NYP";} Quiero preguntar: ¿Es fácil saber qué quiere hacer la condición if del código anterior? Ahora, supongamos que quien escribió este código no siguió la regla número uno: agregar comentarios a su código.
¿No sería más sencillo si dividiéramos esta condición en dos declaraciones if separadas? Ahora, considere el siguiente código corregido:
if(newStatusCode.equals("SD") && (sellOffDate == null || todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null && todayDate.compareTo(lastUsedDate)>0))){ newStatusCode = "NYP ";}si no(newStatusCode.equals("OBS") && (OBSDate == null || todayDate.compareTo(OBSDate)<0)){ newStatusCode = "NYP";}¿No sería mejor legible? Sí, repetimos la condición de la declaración. Sí, tenemos un "SI" adicional y dos pares de paréntesis adicionales. Pero el código es mejor legible y comprensible.
4. Por favor, sin código duro
Los desarrolladores a menudo olvidan o ignoran conscientemente esta regla porque, como siempre, tenemos prisa. Si seguimos esta regla, podemos retrasarnos. Es posible que no podamos poner fin a nuestro estado actual. Pero, ¿cuánto tiempo nos costaría escribir una línea adicional de código que defina constantes estáticas?
He aquí un ejemplo.
clase pública A {cadena final estática pública S_CONSTANT_ABC = "ABC"; método booleano público A (String sParam1) {if (A.S_CONSTANT_ABC.equalsIgnoreCase (sParam1)) {devuelve verdadero};Ahora, cada vez que necesitamos comparar la cadena "ABC" con alguna variable, solo necesitamos hacer referencia a S_CONSTANT_ABC en lugar de recordar cuál es el código real. También tiene la ventaja de hacer que sea más fácil modificar una constante en un lugar, en lugar de buscarla en todo el código.
5. No inventes tus propios marcos
Se han lanzado miles de marcos y la mayoría de ellos son de código abierto. Muchos de estos marcos son soluciones excelentes y se utilizan en miles de aplicaciones. Es necesario mantenerse al día con estos nuevos marcos, al menos superficialmente. Entre estos marcos excelentes y ampliamente utilizados, uno de los mejores y más directos ejemplos es Struts. De todos los marcos que puedas imaginar, este marco web de código abierto es un candidato perfecto para aplicaciones basadas en web. Pero debes recordar la segunda regla: no complicar las cosas. Si desarrolla una aplicación con sólo tres páginas, no utilice Struts. Para dicha aplicación, no hay nada que "controle" las solicitudes.
6. No imprima líneas ni agregue cadenas
Sé que para fines de depuración, a los desarrolladores les gusta agregar System.out.println donde mejor les parezca y nos decimos a nosotros mismos que eliminaremos este código más adelante. Pero a menudo nos olvidamos de eliminar estas líneas de código o simplemente no queremos eliminarlas. Usamos System.out.println para realizar pruebas. Después de completar la prueba, ¿por qué todavía podemos acceder a ellos? Es posible que eliminemos una línea de código que realmente necesitamos simplemente porque subestimó el daño causado por System.out.println. Considere el siguiente código:
clase pública BadCode { cálculo de vacío estático públicoWithPrint(){ double someValue = 0D; for (int i = 0; i < 10000; i++) { System.out.println(someValue = someValue + i); ){ doble algúnValor = 0D para (int i = 0; i < 10000; i++) { algúnValor = algúnValor + i; } } public static void main(String [] n) { BadCode.calculationWithPrint();En la siguiente tabla, puede ver que el método cálculoWithOutPrint() tardó 0,001204 segundos en ejecutarse. En comparación, ejecutar el métodocalculWithPrint() tomó unos sorprendentes 10,52 segundos.
(Si no sabe cómo obtener una tabla como esta, consulte mi artículo "Java Profiling with WSAD" Java Profiling with WSAD)
La mejor manera de evitar este tipo de desperdicio de CPU es introducir un método contenedor, como el siguiente
clase pública BadCode { int final estático público DEBUG_MODE = 1; int final estático público PRODUCTION_MODE = 2; cálculo vacío estático público WithPrint (int logMode) { double someValue = 0D; algúnValor + i; myPrintMethod(logMode, algúnValor); myPrintMethod(int logMode, valor doble) { if (logMode > BadCode.DEBUG_MODE) { return } System.out.println(value } public static void main(String [] n) { BadCode.calculationWithPrint(BadCode.PRODUCTION_MODE) ; }}En la siguiente figura, verá que el método que usa StringBuffer solo tardó 0,01 segundos en ejecutarse, mientras que el método que usa la adición de cadenas tardó 0,08 segundos en ejecutarse. La elección es obvia.
7. Sigue la GUI
No importa lo ridículo que parezca, lo diré una y otra vez: la GUI es tan importante para los clientes empresariales como la funcionalidad y el rendimiento. La GUI es una parte esencial de un sistema exitoso. (Sin embargo, las revistas de TI a menudo tienden a ignorar la importancia de las GUI. Muchas organizaciones ahorran dinero al no contratar diseñadores que tengan amplia experiencia en el diseño de GUI "fáciles de usar". Los desarrolladores de Java tienen que confiar en sus propios conocimientos de HTML, pero sus conocimientos en esta área son muy limitados. He visto muchas aplicaciones como esta: son "compatibles con la computadora", no "fáciles de usar". Rara vez veo desarrolladores que sean competentes tanto en el desarrollo de software como en el desarrollo de GUI. Si usted es el desafortunado desarrollador asignado a desarrollar una interfaz de usuario, debe seguir estos tres principios:
1. No reinventes la rueda. Busque sistemas existentes con requisitos de interfaz de usuario similares.
2. Primero crea un prototipo. Este es un paso muy importante. A los clientes les gusta ver lo que van a obtener. También es genial para ti porque obtienes sus comentarios antes de hacer todo lo posible y crear una interfaz de usuario que los enoje.
3. Use el sombrero del usuario. En otras palabras, examine los requisitos de la aplicación desde la perspectiva del usuario. Por ejemplo, si se debe paginar una página de resumen. Como desarrollador de software, tiende a ignorar la paginación en un sistema porque le deja menos complejidad de desarrollo. Sin embargo, esta no es la mejor solución desde la perspectiva del usuario porque los datos resumidos tendrán cientos o miles de filas.
8. Prepare siempre los requisitos documentados
Cada requisito comercial debe estar documentado. Esto puede ser cierto en algunos cuentos de hadas, pero no es posible en el mundo real. No importa lo ajustado que sea el tiempo para su desarrollo o si la fecha de entrega está próxima, siempre debe saber que todos los requisitos comerciales están documentados.
9. Pruebas unitarias, pruebas unitarias, pruebas unitarias
No entraré en detalles sobre cuál es la mejor manera de realizar una prueba unitaria de su código. Lo que voy a decir es que hay que realizar pruebas unitarias. Esta es la regla más básica de programación. Esta es la más importante de todas las leyes anteriores que no se puede ignorar. Es mejor si tiene colegas que puedan crear y probar pruebas unitarias para su código. Pero si nadie lo hace por ti, entonces tendrás que hacerlo tú mismo. Al crear su plan de prueba unitaria, siga estas reglas:
1. Escriba pruebas unitarias antes de escribir código.
2. Escriba comentarios en pruebas unitarias.
3. Pruebe todos los métodos públicos que realicen funciones "interesantes" ("interesantes" significa métodos que no son establecedores o captadores, a menos que realicen métodos set y get de una manera especial).
10． Recuerde: calidad, no cantidad.
No te quedes demasiado tarde en la oficina (cuando no es necesario). Entiendo que, a veces, los problemas con los productos, los plazos ajustados y los eventos inesperados pueden impedirnos salir del trabajo a tiempo. Sin embargo, en circunstancias normales, el gerente no apreciará ni recompensará a los empleados que dejan el trabajo demasiado tarde. Los aprecia por la calidad de los productos que producen. Si sigue las reglas que le proporcioné anteriormente, encontrará que su código tiene menos errores y es más fácil de mantener. Y esa es la parte más importante de tu trabajo.
Resumir
En este artículo, doy diez reglas importantes para los desarrolladores de Java. Es importante no sólo conocer estas reglas, sino también seguirlas durante el proceso de codificación. Esperemos que estas reglas nos ayuden a convertirnos en mejores programadores y profesionales.
Espero que este artículo sea útil para todos los que están en la programación Java.