Your SlideShare is downloading. ×
Best Practices
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Best Practices

16,204

Published on

Esta presentación contiene un conjunto de buenas practicas y algunos consejos para mejorar nuestro código.

Esta presentación contiene un conjunto de buenas practicas y algunos consejos para mejorar nuestro código.

Published in: Technology, Business
3 Comments
12 Likes
Statistics
Notes
No Downloads
Views
Total Views
16,204
On Slideshare
0
From Embeds
0
Number of Embeds
26
Actions
Shares
0
Downloads
20
Comments
3
Likes
12
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. By Java Curiosities
  • 2. Prologo
    • Por medio de esta simple presentación intentare ir exponiendo las diversas practicas de programación Java que fui adquiriendo durante este tiempo, espero sus comentarios y mas practicas para poder hacer crecer esta presentación como una pequeña referencia para toda la gente que quiera ir mejorando cada día.
  • 3. Comparación
    • Normal Practices
    • private static final String COMPARE_VALUE = "VALUE";
    • public boolean compareIt(String input) {
    • if (input.equals( COMPARE_VALUE)) {
    • return true;
    • } else {
    • return false;
    • }
    • }
    • Best Practices
    • private static final String COMPARE_VALUE = "VALUE";
    • public boolean compareIt(String input) {
    • if ( COMPARE_VALUE.equals(input)) {
    • return true;
    • } else {
    • return false;
    • }
    • }
    Best Practices – Java Curiosities Como vemos es recomendable usar primero las constantes en las comparaciones y de esta forma nos evitamos un posible NullPointerException.
  • 4. Instanciación
    • Normal Practices
    • new Boolean(true);
    • new Long(1);
    • Best Practices
    • Boolean.valueOf(true);
    • Long.valueOf(1);
    Best Practices – Java Curiosities Usando los métodos valueOf de las clases Wrapper, se gana en performance ya que muchas veces se usan diversas técnicas de optimización.
  • 5. Concatenación
    • Normal Practices
    • public class Main {
    • public static void main(String[] args) {
    • String text = "Hello" + " World";
    • }
    • }
    • Best Practices
    • Not Thread-safe
    • StringBuilder sb = new StringBuilder();
    • sb.append("Hello ");
    • sb.append("World");
    • Thread-safe
    • StringBuffer sb = new StringBuffer();
    • sb.append("Hello ");
    • sb.append("World");
    Best Practices – Java Curiosities Cuando pensamos concatenar varios String es recomendable usar la clase StringBuilder o StringBuffer que hacen esta tarea con mayor performance.
  • 6. Comparación
    • Normal Practices
    • if (text.equals("")){
    • // Actions.
    • }
    • Best Practices
    • if (text.length() == 0){
    • // Actions.
    • }
    Best Practices – Java Curiosities Si queremos saber si un String es igual a “” es recomendable usar el método length() ya que se nota una leve mejora de performance en este.
  • 7. Exceptions
    • Normal Practices
    • try {
    • // Code
    • } catch (Exception e) {
    • e.printStackTrace();
    • }
    • Best Practices
    • try {
    • // Code
    • } catch (Exception e) {
    • logger.info(e);
    • throw new BusinessLogicException(e);
    • } finally {
    • // Si tenemos recursos utilizados hay que
    • // asegurarse de cerrarlos.
    • }
    Best Practices – Java Curiosities Cuando capturamos excepciones debemos considerar como mínimo loquear la información y arrojar la misma excepción o arrojar alguna otra excepción mas relacionada con las lógica de negocio. “Si tenemos varios bloques catch habría que tenerlos acomodados de formas de mas especifica hacia menos especifico.”
  • 8. Check Null
    • Normal Practices
    • Map<String, String> data= new HashMap<String,String>();
    • // Load data with some values
    • String result = data.get(&quot;Key&quot;);
    • result = result.toUpperCase();
    • Best Practices
    • Map<String, String> data= new HashMap<String, String>();
    • // Load data with some values
    • String result = data.get(&quot;Key&quot;);
    • if (result!=null){
    • result = result.toUpperCase();
    • }
    Best Practices – Java Curiosities Debemos chequear los objetos que nos retorna un método para ver si no han vuelto en Null así de esta manera evitamos un posible NullPointerException.
  • 9. Program to an interface, not an implementations
    • Normal Practices
    • ArrayList<String> list = new ArrayList<String>();
    • Best Practices
    • List<String> list = new ArrayList<String>();
    Best Practices – Java Curiosities Es mejor referirse a interfaces ya que es mucho mas genérico y además nos permite cambiar la implementación, si a esto le sumamos DI (Inyección de Dependencia) logramos un código mucho mas desacoplado.
  • 10. Iterate Map with Entry
    • Normal Practices
    • Map<String, String> table=new HashMap<String,String>();
    • table.put(&quot;FirstKey&quot;, &quot;FirstValue&quot;);
    • table.put(&quot;SecondKey&quot;, &quot;SecondValue&quot;);
    • for (String key : table.keySet()) {
    • table.get(key);
    • }
    • Best Practices
    • Map<String, String> table = new HashMap<String, String>();
    • table.put(&quot;FirstKey&quot;, &quot;FirstValue&quot;);
    • table.put(&quot;SecondKey&quot;, &quot;SecondValue&quot;);
    • for (Entry<String, String> entry : table.entrySet()) {
    • entry.getKey();
    • entry.getValue();
    • }
    Best Practices – Java Curiosities Cuando iteramos un Map es mejor iterar sobre los Entry del mismo y de este modo ya poseemos la key y el value encapsulado en ese objeto de manera que ahorramos algunas operaciones y ganamos performance.
  • 11. Try – Catch Performance
    • Normal Practices
    • for (int i = 0; i < args.length; i++) {
    • try {
    • // Code
    • } catch (Exception e) {
    • }
    • }
    • Best Practices
    • try {
    • for (int i = 0; i < args.length; i++) {
    • // Code
    • }
    • } catch (Exception e) {
    • }
    Best Practices – Java Curiosities Siempre que se pueda evitar los try – catch dentro de un loop es recomendable hacerlo ya que así ganaremos un poco mas de performance del código.
  • 12. A Method – An Action
    • Normal Practices
    • public void example(String[] args) {
    • prepareAndSendEmail(args);
    • }
    • private void prepareAndSendEmail(String[] args) {
    • // Code
    • }
    • Best Practices
    • public void example (String[] args) {
    • ObjectEmail objectEmail = prepareEmail(args);
    • sendEmail(objectEmail);
    • }
    • private ObjectEmail prepareEmail(String[] args) {
    • // Code
    • }
    • private void sendEmail(ObjectEmail email) {
    • // Code
    • }
    Best Practices – Java Curiosities Como veremos en las convecciones de Sun es recomendable que el nombre de un método sea un verbo + sustantivo para representar su acción, aquí vemos un ejemplo donde un método cumple dos acciones las cuales podrían ser separadas para su mayor compresión.
  • 13. Restrict Arguments - Enums
    • Normal Practices
    • public void checkData(Object data, int status){
    • // Code
    • }
    • Best Practices
    • public void checkData(Object data, Status status){
    • // Code
    • }
    Best Practices – Java Curiosities De esta manera conseguimos restringir nuestros métodos para que solo reciban la información que pueden manejar si recibimos un int este podría ser cualquier valor en cambio al recibir el Enum solo podremos manejar los que estén definidos.
  • 14. Compile Regular Expressions Once
    • Normal Practices
    • public static void main(String[] args) {
    • String target = &quot;Hello World&quot;;
    • for (int i = 0; i < 10000; i++) {
    • target.matches(&quot;Hello World&quot;);
    • }
    • }
    • Best Practices
    • public static void main(String[] args) {
    • String target = &quot;Hello World&quot;;
    • Pattern pattern = Pattern. compile(target);
    • Matcher matcher = pattern.matcher(&quot;Hello World&quot;);
    • for (int i = 0; i < 10000; i++) {
    • matcher.reset();
    • if (matcher.find()){
    • }
    • }
    • }
    Best Practices – Java Curiosities Si utilizamos la clase Matcher notaremos una gran diferencia de performance al momento de chequear las coincidencias de los textos.
  • 15. Self - encapsulation
    • Normal Practices
    • public class Example {
    • private String firstName;
    • public Example(String firstName) {
    • super();
    • this.firstName = firstName;
    • }
    • public String toString() {
    • StringBuilder result = new StringBuilder() result.append( firstName );
    • return result.toString();
    • }
    • }
    • Best Practices
    • public class Example {
    • private String firstName;
    • public Example(String firstName) {
    • super();
    • this.firstName = firstName;
    • }
    • public String toString() {
    • StringBuilder result = new StringBuilder() result.append( getFirstName() );
    • return result.toString();
    • }
    • }
    Best Practices – Java Curiosities Algunas veces puede ser útil usar la auto - encapsulación para poder sincronizar los atributos, hacer inicializaciones perezosas, permitir a los subclases que sobreescriban cierto comportamiento.
  • 16. Avoid Raw Types
    • Normal Practices
    • List data = new ArrayList();
    • Best Practices
    • List<String> data = new ArrayList<String>();
    Best Practices – Java Curiosities Es recomendable usar Parameterezid Type ya que no necesitan casteo y también brindan auto documentación además de brindar un tipado seguro. Los Raw Types fueron conservados por un tema de compatibilidad pero esto no quiere decir que debamos usarlos.
  • 17. Use final liberally
    • Normal Practices
    • public String toString() {
    • StringBuilder result = new StringBuilder();
    • String newLine = System. getProperty(&quot;line.separator&quot;);
    • result.append(&quot;Object {&quot;);
    • result.append(this.getClass().getName());
    • result.append(newLine);
    • result.append(&quot;}&quot;);
    • return result.toString();
    • }
    • Best Practices
    • public String toString() {
    • final StringBuilder result = new StringBuilder();
    • final String newLine = System. getProperty(&quot;line.separator&quot;);
    • result.append(&quot;Object {&quot;);
    • result.append(this.getClass().getName());
    • result.append(newLine);
    • result.append(&quot;}&quot;);
    • return result.toString();
    • }
    Best Practices – Java Curiosities Al usar el keyword final estamos asegurando que esta referencia nunca se cambiaria durante ese bloque de código y esto genera menos trabajo de chequeo para el compilador.
  • 18. Use static imports rarely
    • Normal Practices
    • import static java.util.Collections.*;
    • List<String> things = new ArrayList<String>();
    • things.add(&quot;blah&quot;);
    • List<String> syncThings = synchronizedList(things);
    • Best Practices
    • import java.util.Collections;
    • List<String> things = new ArrayList<String>();
    • things.add(&quot;blah&quot;);
    • List<String> syncThings =
    • Collections.synchronizedList(things);
    Best Practices – Java Curiosities Los static import muchas veces son útil pero puede restar legibilidad al código, son recomendables para el que los usamos con constantes, que ahí facilitan la lectura pero en el caso de ejecución de métodos pasa al contrario porque puede llevar a suponer cosas incorrectas.
  • 19. Validate methods argument
    • Normal Practices
    • public Example(Integer defaultValue) {
    • this. defaultValue = defaultValue;
    • }
    • Best Practices
    • public Example(Integer defaultValue) {
    • // Throws NullPointerException
    • Args.checkForNull(defaultValue);
    • // Throws IllegalArgumentException
    • Args.checkForPositive(defaultValue);
    • this.defaultValue = defaultValue;
    • }
    Best Practices – Java Curiosities Se recomienda validar los argumentos de los métodos públicos en base a NullPointerException, IllegalArgumentException o IllegalStateException que son subclases de RuntimeException, en cambio para los métodos privados se puede usar assert ya que estos al ser llamados desde dentro de la clase deberían llegar con los parámetros correctos.
  • 20. Stop threads
    • Normal Practices
    • public void run() {
    • // Perform the work
    • // Use stop Or suspend
    • stop();
    • suspend();
    • }
    • Best Practices
    • private boolean fIsStopRequested;
    • public void run() {
    • boolean isDone = false;
    • while (!isStopRequested() && !isDone){
    • // Perform the work, set isDone to true
    • }
    • }
    • public synchronized void requestStop(){
    • fIsStopRequested = true;
    • }
    • private synchronized boolean isStopRequested() {
    • return fIsStopRequested;
    • }
    Best Practices – Java Curiosities Cuando queremos frenar un Thread poseemos los metodos stop o suspend pero estos estan deprecados y no deben usarse, en cambio hay que usar una variable privada con sus metodos sincronizados para poder saber si debemos detener el Thread.
  • 21. Class for constants
    • Normal Practices
    • public class Consts {
    • public static final String NEW_LINE = System.getProperty(&quot;line.separator&quot;);
    • public static final String FILE_SEPARATOR = System.getProperty(&quot;file.separator&quot;);
    • }
    • public interface Consts {
    • public static final String NEW_LINE = System.getProperty(&quot;line.separator&quot;);
    • public static final String FILE_SEPARATOR = System.getProperty(&quot;file.separator&quot;);
    • }
    • Best Practices
    • public final class Consts {
    • private Consts() { }
    • public static final String NEW_LINE = System.getProperty(&quot;line.separator&quot;);
    • public static final String FILE_SEPARATOR = System.getProperty(&quot;file.separator&quot;);
    • }
    Best Practices – Java Curiosities Usualmente creamos nuestras constantes en una interface o una clase, pero para poder realizar bien esta practica deberíamos usar una clase que sea final y tenga su constructor privado además de esta manera es una muy buena candidata para el uso de static import.
  • 22. Collections
    • Normal Practices
    • Muchas veces por costumbre o por puro copy/paste
    • usamos un ArrayList para guardar ciertos elementos
    • de los cuales ya conocemos su cantidad y sabremos que
    • son todos del mismo tipo.
    • Best Practices
    • Cuando nos encontramos en un contexto donde
    • de antemano conocemos la cantidad de elementos
    • a guardar y no necesitamos que sea Thread Safe
    • pensemos en utilizar un array, ya que tiene mayor
    • velocidad que cualquier tipo de colección.
    Best Practices – Java Curiosities
  • 23. Package by feature, not layer
    • Normal Practices
    • Solemos definir paquetes pensando a nivel de capas:
    • com.javacuriosities.executives
    • com.javacuriosities.managers
    • com.javacuriosities.employees
    • Best Practices
    • Podríamos dividir nuestros paquetes en características
    • para una mayor rapidez de búsqueda y compresión:
    • com.javacuriosities.frontoffice
    • com.javacuriosities.backoffice
    • com.javacuriosities.accounting
    • com.javacuriosities.personnel
    • com.javacuriosities.mailroom
    Best Practices – Java Curiosities
  • 24. BigDecimal + Precision
    • Normal Practices
    • Por falta de conocimiento se suele utilizar objetos del
    • tipo Double para almacenar cantidades monetarias, y
    • luego intentamos realizar diversas operaciones y al
    • consolidar los valores encontramos error de precisión.
    • Esto se debe a que la clase Double almacena los
    • números en representación binaria y hay números que
    • no pueden ser almacenados de esta forma, generando
    • redondeos que no son correctos.
    • Best Practices
    • Para lograr almacenar cantidad con una precisión casi
    • infinita existe la clase BigDecimal la cual posee métodos
    • para realizar las operaciones que necesitemos y
    • podemos brindarle el formato de redondeo que
    • deseamos usar.
    Best Practices – Java Curiosities RoundingMode
  • 25. Equals y HashCode
    • Normal Practices
    • Equals:
    • Muchas veces sobreescribimos el método equals para
    • determinar las condiciones de igualdad entre ellos dos.
    • HashCode:
    • Otro caso común es sobreescribir el método hashCode y
    • Usar objetos mutables para obtener su valor.
    • Best Practices
    • Equals:
    • Si estamos pensando en sobreescribir el método equals
    • es recomendable también sobreescribir el método
    • hashCode ya que si solo sobreescribiéramos el primero
    • nuestro código se ejecutaría de manera perfecta hasta
    • el momento que quisiéramos guardar nuestros objetos
    • en una collection del tipo Set o Map.
    • HashCode:
    • Si pensamos sobreescribir el método hashCode es
    • recomendable utilizar objetos inmutables para su
    • calculo ya que si usáramos objetos mutables como clave
    • estos quedarían almacenados en lugares incorrectos.
    Best Practices – Java Curiosities
  • 26. Clean Code
    • Estos son mas una serie de consejos que buenas practicas pero van bastante ligados.
    • Intentemos escribir código legible y mantenible por todos.
    • Estar en continuo aprendizaje e intentar mejorarnos cada día, que siempre se pueden aprender cosas, muchas veces
    • pensamos que conocemos todo sobre un lenguaje y estamos equivocados.
    • Usemos patrones de diseños siempre que nos ayude a hacer nuestro trabajo y que nuestro problema encaje con
    • alguno.
    • Evitemos duplicar código y antes de hacer copy paste pensemos o debatamos con alguien las diferentes opciones que
    • tenemos.
    • Ayudemos a los demás a mejorarse ya que esto también nos lleva a crecer profesionalmente y posiblemente nos abra
    • las puertas para aprender nuevas cosas.
    Best Practices – Java Curiosities
  • 27. Do not break portability
    • No usar hard coded para paths o nombre de archivo, usar la clase File y configurar los paths durante el deploy.
    • Recordar que algunos sistemas son case sensitive para los nombres de archivos.
    • Cuidado al utilizar Runtime .exec() y Method. invoke ().
    • No definir la lógica del programa en base a Thread programados ni sus propiedades.
    • No usar métodos nativos.
    • No usar hard coded para tamaño y posición de la GUI – Usar LayoutManager,
    • No basar la resolución de pantalla en una especifica - Usar java.awt.Toolkit. getScreenResolution .
    • No usar hard coded numérico para los valores de los colores - Usar constantes de java.awt. Color and java.awt. SystemColor .
    • No usar hard coded para el tamaño de los textos.
    • Usar System. getProperty(String) para referirse a los temas que dependen del sistema como los saltos de línea y separadores de paths.
    Best Practices – Java Curiosities
  • 28. Convenciones Java Sun I
    • Clases e interfaces
    • La primer letra debe ser mayúscula.
    • Utiliza nomenclatura camelCase.
    • Para las clases, los nombres deben de ser sustantivos.
    • Para las interfaces, los nombres deben de ser adjetivos.
    • Métodos
    • La primer letra debe ser minúscula.
    • Utiliza nomenclatura camelCase.
    • Los nombres deben conformarse por el par verbo + sustantivo.
    • Variables
    • La primer letra debe ser minúscula.
    • Utiliza nomenclatura camelCase.
    • Es recomendable utilizar nombres con un significado explícito, y en lo posible, cortos.
    • Constantes
    • Todas las letras de cada palabra deben estar en mayúsculas.
    • Se separa cada palabra con un _.
    Best Practices – Java Curiosities
  • 29. Convenciones Java Sun II
    • Atributos
    • Ambos (getters y setters) se conforman del prefijo especificado + el nombre del atributo con su primer letra en mayúscula.
    • Getters:
    • Si la propiedad no es de tipo boolean el prefijo debe ser get.
    • Si la propiedad es de tipo boolean el prefijo debe ser is.
    • Deben de ser public, no recibir ningún argumento, y devolver un valor del mismo tipo que el setter para la propiedad.
    • Setters:
    • El prefijo debe ser set.
    • Deben de ser public, recibir un parámetro del mismo tipo que la propiedad, y devolver void.
    • Listeners
    • Los métodos que agreguen un listener deben de comenzar con el prefijo add.
    • Los métodos que quiten un listener deben de comenzar con el prefijo remove.
    • El tipo del listener a agregar/quitar debe de ser pasado como argumento.
    • Deben de terminar con el sufijo Listener.
    Best Practices – Java Curiosities
  • 30. Convenciones Java Sun III
    • Archivos de código fuente
    • Solo puede haber una clase public por cada archivo.
    • Los comentarios pueden aparecer en cualquier línea.
    • Si existe una clase public, el nombre de la misma debe corresponderse con el nombre del archivo.
    • Si la clase pertenece a un package, esta sentencia debe ser incluida como primera línea.
    • Si hay import, estos deben de ser incluidos entre la declaración del package y de la clase (class).
    • Los import y package aplican a todas las clases dentro del archivo.
    • Un archivo puede tener más de una clase, siempre que esta no sea public.
    • Los archivos que no tengan una clase public pueden contener cualquier nombre.
    Best Practices – Java Curiosities
  • 31. Fin
    • Espero este documento sea de utilidad
    • para todo la gente interesada y por ultimo
    • me queda remarcas que todas estas
    • cosas son convenciones, consejos y
    • buenas practicas que suelen ser buenas
    • ideas para aplicar pero no debemos tomar
    • esto como verdad absoluta y siempre
    • pensar si estamos en el camino correcto.

×