1

CONSULTORÍA PARA

“ELABORAR EL DISEÑO E IMPLEMENTACIÓN DE LOS PROCESOS DE ASEGURAMIENTO Y

CONTROL DE CALIDAD DEL SOFTWARE PARA LA SENPLADES”.

No. SP-BSCC-BID-SENPLADES- 02-2012.

1.3.1. ESTÁNDARES DE PROGRAMACIÓN DE APLICACIONES EN JAVA SENPLADES.

Julio de 2013

2

Tabla de Contenido.

Propósito . ………………………………………………………………………………………………5

Estándares de Código. ................................................................................................................ 5

Alcance ………………………………………………………………………………………………..5

Objetivos. ………………………………………………………………………………………………..5

EPS-001. Normas Generales. .................................................................................................... 7

EPS-002. Documentación Javadoc. ......................................................................................... 8

EPS-003. Formato de la Cabecera. ........................................................................................... 9

EPS-004. Sentencias de Importación..................................................................................... 11

EPS-005. Paquetes. .................................................................................................................. 11

EPS-006. Comentarios de Implementación........................................................................... 12

EPS-007. Clases e Interfaces. ................................................................................................. 12

EPS-008. Identación. ................................................................................................................ 14

EPS-009. Longitud de Línea. ................................................................................................... 15

EPS-010. División de Líneas. .................................................................................................. 15

EPS-011. Inicialización. ........................................................................................................... 15

EPS-012. Localización. ............................................................................................................ 16

EPS-013. Métodos. ................................................................................................................... 16

EPS-014. Sentencias. ............................................................................................................... 17

EPS-015. Paréntesis. ................................................................................................................ 20

EPS-016. Organización de los Ficheros. ............................................................................... 21

EPS-017. Valores de Retorno.................................................................................................. 21

EPS-018. Variables de Referencia. ......................................................................................... 22

EPS-019. Declaraciones. ......................................................................................................... 23

EPS-020. Asignación sobre Variables. .................................................................................. 29

3

EPS-021. Visibilidad de Atributos de Instancia y de Clase. ................................................ 29

EPS-022. Constantes. .............................................................................................................. 31

EPS-023. Expresiones en el Operador Condicional Ternario. ............................................ 32

EPS-024. Excepciones. ............................................................................................................ 32

EPS-025. Documentar las excepciones. ................................................................................ 32

EPS-026. Reglas Generales de los Beans en Java. ............................................................. 35

EPS-027. Creación de Nombres Usando Beans. .................................................................. 36

EPS-028. Creación de los Listener para JavaBean. ............................................................. 39

EPS-029. Declaración de una Enumeración. ........................................................................ 39

EPS-030. Declaración de Constructores en un Enumerado. .............................................. 40

Glosario .………………………………………………………………………………………………41

Bibliografía y Webgrafía............................................................................................................ 41

Anexo A. Palabras Reservadas. ............................................................................................... 42

4

Historial de versiones.

Versión Elaborado por Revisado por Fecha Cambios

1.0 Fernanda López.

Maricela Maldonado.

INNOVASYS.

Andrés Solórzano.

Programador Sénior.

SENPLADES.

27 - 02 – 2013.

Versión Inicial.

1.1 Fernanda López.

Maricela Maldonado.

INNOVASYS.

Andrés Solórzano.

Programador Sénior.

SENPLADES.

20 – 03 – 2013.

Ajustes de acuerdo a revisión del día 19 de febrero del 2013.

1.2 Fernanda López.

Maricela Maldonado.

INNOVASYS.

Andrés Solórzano.

Programador Sénior.

SENPLADES.

21 - 02 – 2013.

Ajustes de acuerdo a revisión del 19 de febrero del 2013.

1.3 Fernanda López.

Maricela Maldonado.

INNOVASYS.

Andrés Solórzano.

Programador Sénior.

SENPLADES.

27 – 02 – 2013.

Ajustes de acuerdo al acta de reunión número 11 correspondiente a los acuerdos alcanzados el 22 de febrero del 2013.

1.4 Jorge Villarreal.

INNOVASYS.

Andrés Solórzano.

Programador Sénior.

SENPLADES.

12 – 03 – 2013.

Ajustes de acuerdo al acta de reunión número 11 correspondiente a los acuerdos alcanzados el 22 de febrero del 2013.

5

EPS ESTÁNDARES DE PROGRAMACIÓN SENPLADES.

Propósito.

Este documento tiene como propósito establecer los lineamientos necesarios que deben cumplir los desarrolladores al momento de crear aplicaciones de software con lenguaje JAVA.

Estándares de Código.

Los estándares de código que van a ser utilizados en el presente documento están basados en las convenciones de programación Java:

“Adaptado con el permiso de las convenciones de código JAVA. Derechos de autor Sun Microsysytems, Inc. Todos los derechos reservados”.

Alcance.

Los lineamientos emitidos a través de este documento serán de suma obligatoriedad para la elaboración de aplicaciones de software.

Toda aplicación de software desarrollada en lenguaje JAVA, debe ajustarse a este estándar, de lo contrario no se aceptará como parte de la documentación oficial de un proyecto.

Objetivos.

Los objetivos de aplicar estándares para el desarrollo de software en lenguaje JAVA para la SENPLADES son:

Elaborar aplicaciones que sean fácilmente reutilizadas mediante una buena

documentación.

Promover el mantenimiento de aplicaciones.

Facilitar la integración de nuevos programadores a un proyecto en desarrollo.

6

Garantizar que las aplicaciones sean de alta calidad.

Definir la estructura del código fuente de una aplicación.

Describir los derechos de autor que deben tener los archivos de un proyecto.

Documentar los cambios realizados al código fuente en sus diferentes versiones.

7

EPS-001. Normas Generales1.

1. Toda sentencia debe terminar con un punto y coma “;”.

2. Un archivo de programación java constará de los siguientes ítems:

2.1. Definición de paquetes de aplicación en la cual se usa la palabra

reservada package.

2.2. Definición de Librerías requeridas para el funcionamiento a través de la

palabra reservada import.

2.3. Definición de la estructura de la clase. en la cual se usa la palabra

reservada class.

2.3.1. Dentro de la clase se definen las variables.

2.3.2. Dentro de las clases se definen los métodos.

3. Utilice el siguiente orden para declarar miembros de una clase:

3.1. Las variables de clase (declaradas como static).

3.2. Las variables de instancia.

3.3. Constructores (al menos uno).

3.4. Método finalize (destructor) si es necesario.

1 Estándar de Codificación Java

8

3.5. Los métodos de clase (declaradas como static).

3.6. Métodos con visibilidad distinta a la static que posean mayor nivel de

importancia que los métodos SET y GET.

3.7. Métodos de acceso Set / Get.

3.8. Declarar siempre los miembros que poseen un mayor nivel de

visibilidad. Es decir, comenzar con los miembros del público, continuar

con los de visibilidad de paquete, seguir con los miembros protegidos, y

terminar con los de tipo privado.

4. Existe una serie de palabras reservadas2 que el programador no debe utilizar

como identificadores en el código fuente para otros usos.

Ejemplo:

double, que se utiliza para definir un tipo de dato real

for, que se emplea para construir un tipo determinado de bucle.

5. El nombrado de los identificadores no debe empezar con un número o caracteres

especiales.

Ejemplo:

NOTA: Todos los temas tratados en este estándar de Normas Generales serán abordados con mayor nivel de detalle en los puntos posteriores.

EPS-002. Documentación Javadoc3.

Se debe incluir en la entrega de la aplicación la documentación de los ficheros fuente de todas

las clases. Dicha documentación será generada por la herramienta "javadoc".

La herramienta "javadoc" construirá la documentación a partir de los comentarios (incluidos en

las clases) encerrados entre los caracteres "/**" y "*/".

2 En el Anexo A se muestran las palabras reservadas en Java 3 Estándar de Codificación Java

9

Ejemplo:

EPS-003. Formato de la Cabecera4.

Este estándar define cómo debe estar conformada la cabecera de todas las clases, para lo cual se deben seguir las siguientes reglas.

Todo fichero fuente debe comenzar con un comentario que incluyan los derechos de autor y la fecha de su elaboración.

4 Estándar de Codificación Java

10

Ejemplo:

Todo fichero fuente debe contener un comentario que incluya el nombre de la clase, información sobre la versión del código, incluir adicionalmente comentarios sobre los cambios efectuados sobre dicho fichero (mejora, incidencia, error.

Ejemplo:

11

EPS-004. Sentencias de Importación5.

Tras la declaración del paquete se incluirán las sentencias de importación de los paquetes necesarios. Esta importación de paquetes obligatorios seguirá el siguiente orden.

1. Paquetes del JDK de java.

2. Paquetes utilitarios no pertenecientes al JDK de Java.

3. Paquetes de la aplicación.

Ejemplo:

EPS-005. Paquetes.

Este estándar se refiere a la forma como se deben nombrar a los paquetes, para esto se describen 2 reglas:

1. Los nombres de los paquetes escribirán siempre en letras minúsculas para evitar

que entren en conflicto con los nombres de clases o interfaces.

Ejemplo:

2. El prefijo del paquete siempre corresponderá a un nombre de dominio de primer

nivel.

Ejemplo:

5 Estándar de Codificación Java

12

EPS-006. Comentarios de Implementación6.

Colocar comentarios de bloque o comentarios de línea que permitan la descripción de fases

lógicas de ejecución de un método.

Ejemplo:

EPS-007. Clases e Interfaces7.

Este estándar hace referencia a la forma como deben ser declarados los nombres de las

clases, interfaces y clases anónimas para lo cual se deben tomar en cuenta las siguientes

reglas:

1. Clases.

Los nombres de clases deben ser sustantivos y deben tener la primera letra en

mayúsculas. Si el nombre es compuesto, cada palabra componente deberá

comenzar con mayúsculas.

Ejemplo:

1.1. Los nombres serán simples y descriptivos evitando el uso de acrónimos

o abreviaturas.

Ejemplo:

6 Estándar de Codificación Java

13

2. Interfaces.

Para la creación de interfaces se deben tomar en cuenta los siguientes lineamientos:

2.1. Todos los métodos de una interfaz son implícitamente públicos y

abstractos.

2.2. Todas las variables definidas en una interfaz deben ser públicas,

estáticas y finales, en otras palabras, las interfaces solo pueden declarar

constantes, no instancias de variables.

2.3. Los métodos de una interfaz no deben ser estáticos.

2.4. Debido a que los métodos de una interfaz son abstractos, no pueden ser

marcados como final.

2.5. Una interfaz puede extender de una o más interfaces.

2.6. Una interfaz no puede extender de cualquier cosa excepto de una

interfaz.

2.7. Una interfaz no puede implementar otra interfaz o clase.

2.8. Una interfaz debe ser declarada con la palabra clave "interface".

2.9. Los tipos de interfaz pueden ser usados polimórficamente.

2.10. Usar sustantivos para nombrar interfaces que actúan como

declaraciones de servicio.

Ejemplo:

2.11. Utilizar adjetivos para nombrar interfaces que actúan como

descripciones de las capacidades.

Ejemplos:

14

Ejemplo:

3. Clases anónimas.

3.1. Limitar el uso de las clases anónimas a las clases que son muy

pequeñas (no más que un método o dos) y cuyo uso sea bien conocido

tales como clases adaptador o Enumerator.

Ejemplo:

EPS-008. Identación.

Establecer 4 caracteres o espacios como unidad de identación.

15

EPS-009. Longitud de Línea.

La longitud de línea no debe superar los 80 caracteres por motivos de visualización e impresión.

EPS-010. División de Líneas.

Cuando una expresión ocupe más de una línea, esta se podrá romper o dividir en función de

los siguientes criterios:

1. Tras una coma.

2. Antes de un operador.

3. Las rupturas de nivel superior a las de nivel inferior.

4. Alinear la nueva línea con ocho espacios con respecto a la línea anterior.

5. Si las reglas anteriores generan código poco comprensible, entonces estableceremos tabulaciones de 8 espacios.

Ejemplo:

EPS-011. Inicialización.

Toda variable local tendrá que ser inicializada en el momento de su declaración, salvo que su valor inicial dependa de algún valor que tenga que ser calculado previamente, o al usar los Beans de java.

Ejemplo:

16

EPS-012. Localización.

Las declaraciones deben situarse al principio de cada bloque principal en el que se utilicen, y nunca al momento de su uso.

Ejemplo:

La única excepción a esta regla son los índices de los bucles for, ya que en Java; pueden

incluirse dentro de la propia sentencia for.

Ejemplo:

EPS-013. Métodos.

Los métodos deben ser verbos escritos en minúsculas. Cuando el método esté compuesto por

varias palabras cada una de ellas tendrá la primera letra en mayúsculas.

17

Ejemplo:

EPS-014. Sentencias.

Este estándar indica cómo deben estar estructuradas las sentencias, para lo cual se describen

las reglas siguientes:

1. Las sentencias pertenecientes a un bloque de código estarán tabuladas un nivel

más a la derecha con respecto a la sentencia que las contiene.

18

Ejemplo:

2. Todas la sentencias de un bloque deberán encerrarse entre llaves "{ .. }", aunque el

bloque conste de una única sentencia.

Ejemplo:

3. Para la utilización del if-else se seguirá el siguiente formato:

19

4. Multi- condicional.

La identación de las sentencias if con una clausula else y de múltiples sentencias

condicionales if-else deben colocarse en una línea separada para aumentar la

legibilidad de toda la estructura.

Ejemplo:

5. Para las sentencias switch se utilizará el siguiente formato:

20

5.1. Los casos sin una sentencia break debe incluir un comentario * / falls

troughs * / para indicar explícitamente que caen hasta el próximo caso.

5.2. Todas las sentencias switch deberán incluir un caso por defecto.

5.3. En el último caso en la sentencia switch también debe terminar con una

sentencia break.

6. Para las sentencias try-cath se utilizará el siguiente formato:

Ejemplo:

7. En el bloque catch siempre se debe imprimir una traza de error indicando el tipo

de excepción generada.

Ejemplo:

EPS-015. Paréntesis.

Usar paréntesis en expresiones que incluyan distintos tipos de operadores para evitar problemas de precedencia de operadores.

21

Ejemplo:

EPS-016. Organización de los Ficheros8.

Cada fichero fuente Java debe contener una única clase o interface pública.

Ejemplo:

EPS-017. Valores de Retorno.

Los valores de retorno tendrán que ser simples y comprensibles, de acuerdo al propósito y comportamiento del objeto en el que se utilicen.

8 Convenciones de código para Java

TM

22

Ejemplo:

EPS-018. Variables de Referencia9.

El presente estándar indica la forma y modelo que pueden tener las variables ya sean Primitivas o de Referencia. A continuación el detalle:

1. Las variables se escribirán siempre en minúsculas, y las variables compuestas

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

Ejemplo:

2. 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, no declarar

nombres de variables con un sólo carácter, excepto para variables temporales.

Ejemplo:

3. Los variables pueden empezar con letra, un caracter de tipo currency "$" o un

caracter de tipo conector, como la línea baja (_). Los identificadores no pueden

empezar con un número.

9 Estándar de Codificación Java

23

Ejemplo:

4. Después del primer carácter, las variables pueden contener cualquier combinación

de letras, caracteres conectadores o números.

Ejemplo:

EPS-019. Declaraciones.

El presente estándar describe la forma como se deben realizar las declaraciones, a continuación el detalle:

1. Nombres de variables no deben incluir guiones bajos o números entre sus

nombres.

Ejemplo:

2. Una declaración por línea: Debe existir una sola declaración por línea,

promoviendo así el uso de comentarios.

Ejemplo:

24

3. Para declarar una variable, no omitir el modificador de acceso (public, private,

protected).

Ejemplo:

4. Variables de instancia: Ubicar primero las variables protegidas (protected), y

finalmente las variables privadas (private).

Ejemplo:

Ç

5. Métodos: Deben agruparse por funcionalidad en lugar de agruparse por ámbito o

accesibilidad. Colocando lo métodos de mayor importancia en la parte superior, y

los métodos de menor importancia en la parte inferior.

5.1. Ubicar espacios en blanco entre una palabra reservada y un paréntesis.

Para permitir que se distingan las llamadas a métodos de las palabras

reservadas.

25

Ejemplo:

5.2. Ubicar espacios en blanco tras cada coma en un listado de argumentos.

Ejemplo:

5.3. Ubicar espacios en blanco para separar un operador binario de sus

operandos, excepto en el caso del operador (".").

26

Ejemplo:

5.4. Ubicar espacios en blanco para separar las expresiones incluidas en la

sentencia for.

Ejemplo:

5.5. Ubicar espacios en blanco al realizar el "casting" de clases.

Ejemplo:

6. Estructura de la Declaración dentro de las clases Durante el desarrollo de

clases se deben seguir las siguientes reglas de formateo:

27

6.1. No incluir ningún espacio entre el nombre del método y el paréntesis

inicial del listado de parámetros.

Ejemplo:

6.2. El caracter de inicio de bloque (" { ") debe aparecer al final de la línea

que contiene la sentencia de declaración.

Ejemplo:

6.3. El caracter fin de bloque (" } ") se situará en una nueva línea tabulada al

mismo nivel que su correspondiente sentencia de inicio de bloque,

excepto cuando la sentencia sea nula, en tal caso se situará detrás de

"{".

28

Ejemplo:

6.4. Los métodos se separarán entre sí mediante una línea en blanco.

Ejemplo:

6.5. Cada línea contendrá como máximo una sentencia.

Ejemplo:

29

EPS-020. Asignación sobre Variables.

El presente estándar trata de las reglas a seguir para la asignación de datos sobre variables, a continuación el detalle:

1. No hacer uso de asignaciones de un mismo valor sobre múltiples variables en una

misma sentencia, ya que dichas sentencias suelen ser difíciles de leer.

Ejemplo:

2. No utilizar asignaciones embebidas o anidadas.

Ejemplo:

EPS-021. Visibilidad de Atributos de Instancia y de Clase.

El presente estándar trata de la visibilidad que van a tener los atributos de instancia y clases, a continuación el detalle.

1. Los atributos de instancia y de clase serán siempre privados (private), excepto

cuando tengan que ser visibles en subclases herederas, en tales casos serán

declarados como protegidos (protected).

30

Ejemplo:

2. El acceso a los atributos de una clase se realizará por medio de los métodos "get"

y "set" correspondientes, incluso cuando el acceso a dichos atributos se realice en

los métodos miembros de la clase.

Ejemplo:

31

EPS-022. Constantes.

El siguiente estándar describe la forma que se debe seguir para la declaración de las constantes, a continuación el detalle:

1. 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 "_".

Ejemplo:

2. Los valores constantes nunca aparecerán directamente en el código, para designar

dichos valores se utilizarán constantes escritas en mayúsculas y se declararán,

según su ámbito de uso, en la cabecera de la clase (métodos estáticos), o en una

enumeración propia de Java.

Ejemplo:

32

EPS-023. Expresiones en el Operador Condicional Ternario10.

Toda expresión compuesta, por uno o más operadores binarios, situada en la parte condicional del operador ternario deberá ir entre paréntesis.

Ejemplo:

EPS-024. Excepciones.

Las excepciones deben ser chequeadas sólo si el cliente puede tomar alguna acción alternativa para recuperarse cuando la excepción ocurra, caso contrario la excepción debe ser no chequeada.

EPS-025. Documentar las excepciones.

Documentar todas las excepciones de tipo “checked” que lance un método, para lo cual se

debe usar el elemento de Javadoc: @throws, para permitir mayor entendimiento de la

excepción.

Ejemplo:

1. Utilizar excepciones sin control.

Este estándar define el uso de las excepciones sin control, cuando una aplicación no

puede hacer nada para manejar adecuadamente algunas excepciones, y por lo tanto,

no vale la pena hacer que la lógica del programa sea más compleja a causa de ellos, lo

que sería el caso si se utilizarán excepciones comprobadas.

10 Convenciones de código para Java

TM

33

Estas excepciones deben ser utilizadas para manejar situaciones tales como:

Un error de aserción (la sentencia “assert” automáticamente lanza una

excepción).

Un índice fuera de límites.

Una división por cero.

Un intento de eliminar la referencia una referencia nula.

Una entrada no valida o fuera de formato.

Un fallo en el sistema operativo.

Ejemplo:

2. Excepciones de uso controlado.

Este estándar define el uso de las excepciones comprobadas, en situaciones

problemáticas que pueden ocurrir durante la operación normal del programa. En

muchos casos, estos problemas pueden ser manejados apropiadamente por el

llamador del método que lanza la excepción.

La excepción comprobada puede ser utilizada para manejar situaciones tales como:

Ingreso de información no válida.

La información tiene un formato incorrecto.

Ejemplo:

34

3. No ignorar los mensajes de error.

El incumplimiento de este estándar hace que el código sea difícil de depurar, porque la

información valiosa se ha perdido. Incluso si ha codificado un bloque catch,

simplemente para detectar una excepción que no se espera que se produzca, imprimir

al menos un seguimiento de pila.

Ejemplo:

35

4. Siempre que sea posible, utilice bloques finally para liberar recursos.

Ejemplo:

EPS-026. Reglas Generales de los Beans en Java11.

Un bean obedecerá las reglas:

Un bean debe tener un constructor por defecto (sin argumentos), para los casos de inicialización de variables.

Un bean debe tener persistencia12, es decir, implementar la interface Serializable.

11

Convenciones de código para Java TM

12 Un Bean persiste cuando tiene sus propiedades, campos e información de estado almacenadas y restauradas desde un fichero

36

Ejemplo:

EPS-027. Creación de Nombres Usando Beans.

1. Si la propiedad no es de tipo booleana, el nombre del método que lee el valor debe

estar precedido por get., por ejemplo: getSize() es un nombre válido que usa las

especificaciones de JavaBeans para leer el tamaño, no se necesita tener una

variable llamada size. Los nombres de la propiedad se deducen de

los getters y setters, no a través de cualquier variable de la clase. Lo que

devuelva getSize() depende del programador.

37

Ejemplo:

2. Si la propiedad es un booleano, el prefijo es get o is, por

ejemplo, getStopped() o isStopped() son nombres válidos para una propiedad

booleana de JavaBeans. Sin embargo se recomienda siempre el uso del prefijo

get.

38

Ejemplo:

3. El método para los seteadores (setters) deben tener el prefijo set, Si la propiedad

es un booleano, el prefijo es get o is. Por ejemplo, getStopped() o isStopped() son

nombres válidos para una propiedad booleana de JavaBeans. Sin embargo se

recomienda siempre el uso del prefijo set.

Ejemplo:

4. Para completar el nombre de un método getter o setter, solo hay que poner la

primera letra que los une en mayúsculas.

39

Ejemplo:

EPS-028. Creación de los Listener para JavaBean13.

1. Los nombres de los métodos de tipo listener usados para registrar un escuchador con la fuente de un evento debe de llevar el tipo de escuchador, por ejemplo actionListener() es un nombre valido para un método donde la fuente del evento permitirán a otros registrar la acción del evento.

Ejemplo:

EPS-029. Declaración de una Enumeración.

1. Las enumeraciones serán declarados solo con los modificadores public o default,

según sea la necesidad del programador.

2. Al final de la declaración de las variables de un enumerado colocar el punto y coma

(;)

13 Convenciones de código para Java

TM

40

Ejemplo:

EPS-030. Declaración de Constructores en un Enumerado.

1. Dado que un enumerado realmente es un tipo especial de clase, se puede añadir

constructores, variables de instancia, métodos.

2. Nunca invocar directamente el constructor de un enumerado. El desarrollador debe

definir el valor de la constante. Se recomienda declarar el constructor del

Enumerado como private para evitar cometer este error.

Ejemplo:

41

Glosario.

EPS: Estándares de Programación SENPLADES.

Persistencia en el contexto de java beans: Un Bean es persistente cuando tiene sus propiedades, campos e información de estado almacenada y restaurada desde un fichero.

Bibliografía y Webgrafía.

http://www.oracle.com/technetwork/java/javase/documentation/codeconvtoc-

136057.html. Convenciones de código para Java TM Lenguaje de Programación

Revisado el 20 de abril 1999

ftp://ftp.estec.esa.nl/pub/wm/anonymous/wme/bssc/Java-Coding-Standards-20050303-

releaseA.pdf Java Coding Standards Normas de Codificación Java BSSC 2005(2)

Issue 1.0.

42

Anexo A. Palabras Reservadas.

abstract Do Implements protected Throw

boolean double Import public Throws

break Else Instanceof rest Transient

byte extends Int return True

case false Interface short try

catch final Long static void

char finally Native strictfp volatile

class float New super while

const For Null switch

continue goto* Package synchronized

default If Private this