Esta página describe los estándares usados para el código de Apache Geronimo (java, xml, etc.). Código es leído por un humano con más frecuencia de lo que es escrito por un ser humano, haz el código placentero para ser leído.

------------------------> Falta traducción

...

Identación

Java

Lets follow Sun's coding standard rules which are pretty common in Sigamos las reglas estándar de código de Sun, las cuales son muy usuales en Java.

http://java.sun.com/docs/codeconv/

http://java.sun.com/docs/codeconv/html/CodeConvTOC.doc.html

• 4 characters indentationcaracteres de identación
• ¡Por favor no usar tabsNo tabs please!

Correct brace style:

public class Foo {
    public void foo(boolean a, int x, int y, int z) {
        do {
            try {
                if (x > 0) {
                    int someVariable = a ?  x : y;
                } else if (x < 0) {
                    int someVariable = (y + z);
                    someVariable = x = x + y;
                } else {
                    for (int i = 0; i < 5; i++) {
                        doSomething(i);
                    }
                }

                switch (a) {
                    case 0:
                        doCase0();
                        break;
                    default:
                        doDefault();
                }
            } catch (Exception e) {
                processException(e.getMessage(), x + y, z, a);
            } finally {
                processFinally();
            }
        } while (true);

        if (2 < 3) {
            return;
        }

        if (3 < 4) {
            return;
        }

        do {
            x++
        } while (x < 10000);

        while (x < 50000) {
            x++;
        }

        for (int i = 0; i < 5; i++) {
            System.out.println(i);
        }
    }

    private class InnerClass implements I1, I2 {
        public void bar() throws E1, E2 {
        }
    }
}

XML

• Use Usa 4 characters. This is to allow IDEs such as Eclipse to use a unified formatting convention
• No tabs please!

Interfaces

All methods of an interface are public abstract, therefore it is not necessary to specify public abstract modifiers. Similarly all fields are public static final.

• caracteres. Lo anterior es para permitir a IDEs como Eclipse, el usar una convención unificada de formato.
• ¡Por favor no usar tabs!

Interfaces

Todo método de una interfaz es público abstracto (public abstract), por lo que no es necesario el especificar modificadores públicos abstractos (public abstract modifiers). De manera similar, todo campo es público estático final (public static final).

Sin embargo, el siguiente comportamiento funciona mejor con la mayoría de herramientas e IDEs y parece ser una práctica común, por lo que no observamos razón para negar dicha práctica, por ejemploHowever this behavior works best with most tools and IDEs and seems to be common practice so we see no reason to disallow this practice. e.g:

public interface MyInterface {
    public static final int MY_INTEGER = 0;

    public abstract void doSomething();
}

This has the added advantage that the interface can be converted into an abstract class (and copy and paste individual definitions) without changing anything.

Lo anterior tiene la ventaja adicional de que la interfaz puede ser convertida en una clase abstracta (y copiar y pegar definiciones individuales) sin aplicar cambio alguno.

Preferentemente agrega Preferably add public/static/final to constantsa constantes, and y public/abstract to methods, but it's not mandatory. However, if it's there, don't take it out.a métodos, pero no es obligatorio. Sin embargo, si esta ahí, no lo quites.

------------------------> Falta traducción

Exceptions

• A situation is only exceptional, if the program can not handle it with reasonably effort. Wrong input data should be an expected situation of the regular code, that could be handled gracefully.
• The intention of exception-handling is to separate real error-handling from the regular part of the code, so don't force the caller to mix it with unnecessary exceptions.
• Only if your code really has a problem to continue e.g., when a parameter is invalid, feel free to throw an exception!
• Do NOT throw an exception, if you only suppose the caller of your code could have a problem with a special result. Try to return a special result value instead e.g., null, and let the caller decide with a regular if-else-statement. If the caller really has a problem, HE WILL throw an exception on his own.
• But if your code throws an exception, even though it has no real problem and it could continue without an exception and return a special result value, you forestall the decision of the caller, whether the special result is really an error or not.
• If you throw an exception, where the caller would decide that it is no error in the context of the caller, you force the caller to write an exception handler in his regular part or to abort i.e., you force the caller to mix regular code with exception handling. That is the opposite of the intentention of exception handling.
• Bad example:
  java.lang.Class.forName(String) throws ClassNotFoundException
  In most programs/situations it is an error if this method does not find the class, therefore it throws an exception and forestalls the decision of the caller.
  But maybe there is a program that should check a list of class names, whether the classes are present or not. Such a program is forced to mix its regular code with error handling of an exception, that is no error at all in that context.
  The method should return a special result value instead: null. Many callers of that method have expected that situation and therefore are not in an unexpected situation/exceptional state. They could decide the situation on their own.
• Only throw checked exceptions (not derived from RuntimeException), if the caller has a chance to handle it.
• Exceptions that signal programming errors or system failures usually cannot be handled/repaired at runtime -> unchecked exception.
• If your code really has a problem to continue e.g., when a parameter is invalid, throw an unchecked exception (derived from RuntimeException) and do NOT throw a checked exception, because if not even your code can handle the problem, in the very most cases the caller has no chance to handle the problem, too. Instead there maybe somebody somewhere in the highest layers who catches all RuntimeException's, logs them and continues the regular service.
• Only if it is not possible to return special result values cleanly, use checked exceptions to force the caller to decide the situation. The caller should deescalate the situation by catching and handling one or more checked exceptions, e.g. with special result values(?) or by escalating with an unchecked exception, because the situation is an error, that can not be handled.
• Checked exceptions are an official part of the interface, therefore do not propagate checked exceptions from one abstraction layer to another, because usually this would break the lower abstraction. E.g. do not propagate SQLException to another layer, because SQLExceptions are an implementation detail, that may change in the future and such changes should not affect the interfaces and their callers.
• Never throw NullPointerException or RuntimeException. Use either IllegalArgumentException, or NullArgumentException (which is a subclass of IllegalArgumentException anyway). If there isn't a suitable subclass available for representing an exception, create your own.

...