SUN CERTIFIED JAVA PROGRAMMER (SCJP) CAPÍTULO 10: DEVELOPMENT

1. SUN CERTIFIED JAVA PROGRAMMER (SCJP)CAPÍTULO 10: DEVELOPMENT

2. Compiling with javac javac [options] [source files] [options] y [source files] son partes opcionales del comando, y ambas permiten multiples entradas. Ej: javac -help javac -classpath com:. -g Foo.java Bar.java argument option option Source files

3. Compiling with -d La opcion -d option permite decirle al compilador en que directory se colocarán lo archivos .class que este genera (d is for destination). Ej: myProject | |--source | | | |-- MyClass.java | |-- classes | |-- cd myProject javac -d classes source/MyClass.java

4. Compilando con -d package com.wickedlysmart; public class MyClass { } javac -d classes source/com/wickedlysmart/MyClass.java

5. Compiling with -d package com.wickedlysmart; public class MyClass { } And the following command (the same as last time): javac -d classes source/com/wickedlysmart/MyClass.java El compilador construye dos directorios llamados com y com/wickedlysmart para colocar el resltado MyClass.class dentro del paquete correcto (com/wickedlysmart/).

6. Launching Applications with java java [options] class [args] Se debe especificar exactamente un archivo a ejecutar, y el comando java asume que se trata de un .class, por ello no se debe especificar la extension en la línea de comando. cd My Project/classes java -DmyProp=myValue MyClass x 1 -D Agregamos una propiedad

7. Using System Properties Java 5 tiene una clase llamada java.util.Properties que puede ser usada para acceder a informacion del sistema como: las versiones actuales del sistema operativo, del compilador java y de la maquina virtual. Además provee información default, y se puede también añadir propiedades. java -DcmdProp=cmdVal TestProps java -DcmdProp="cmdVal take 2" TestProps El método getProperty() es usado para retornar una propiedad. Esté puede ser invocado con un argumento simple (un string que representa el key), o puede ser invocado con dos arguments (un String que representa el key, y un valor String default para ser usado como la propiedad si esta aun no existe). En ambos casos, getProperty() retorna la propiedad como String

8. Handling Command-Line Arguments • Declaraciones legales paa main(): • static public void main(String[] args) • public static void main(String... x) • static public void main(String bang_a_gong[])

9. Searching for Other Classes • El siguiente caso común se da cuando nosotros queremos compilar un archivo o correr una clase que usa otras clases, creadas fuera de lo que la Sun provee. • Recordar que para cualquier clase dada, la máquina virtual necesitará encontrar exactamente las mismas clases que el compilador javac necesitará encontrar en tiempo de compilación. • En otras palabras, si javac necesita acceder a java.util.HashMap entonces el comando java también necesitará acceder a java.util.HashMap.

10. Searching for Other Classes • Java y javac usan el mismo algoritmo básico de búsqueda: • 1. Ambos tienen las mismas listas de lugares (directorios) para buscar clases. • 2. Ambos buscan a través de la listas de directorios en el mismo orden. • 3. Cuando encuentran la clase paran la búsqueda de esa clase. En el caso que sus listas de búsquedas contengan dos o más achivos, el primer archivo encontrado será el usado. • 4. El primer lugar en el que buscan es en los directoros que contienen las clases estandares que vienen con J2SE. • 5. El segundo lugar es en los directorios definidos por los classpaths. • 6. Classpaths “directorios de búsqueda de clases." Son listas de directorios en los cuales las clases pueden ser encontradas. • 7. Estos son lugares donde los classpaths pueden ser encontrados: • Un classpath puede ser declarado como una variable de ambiente del sistema operativo. • El classpath declarado aquí es usado por default, cuandoquiera que java o javac sean invocados. • Un classpath puede ser declarado como una opción en línea de comando para java o javac. • Classpaths declarado como command-line sobreescribe el classpath declarado como vaiable de ambiente, pero ellos persisten solo durante la invocación.

11. Declaring and Using Classpaths • Classpaths consiten en variables de locaciones de directorios, separados por delimitadores. • For Unix: -classpath /com/foo/acct:/com/foo • For Windows: -classpath com\foo\acct;com\foo • Específica dos directorios en los cuales las clases pueden ser encontradas: /com/foo/acct y /com/foo. • En ambos casos, estos directorios son absolutamente ligados a la raíz del sistemas de archivos. • La mayor parte del examen usará convenciones Unix.

12. Declaring and Using Classpaths • Por default los comandos javac y java no buscan los archivos .class en el directorio actual. Se debe especificar que busque ahí. • El modo para decirle a java o javac que busuqe en el directorio actual es añadir un (.) al classpath: • -classpath /com/foo/acct:/com/foo:.

13. Declaring and Using Classpaths • Classpaths son búscados de izquierda a derecha. Por lo tanto habrá diferentes resultados en una situación donde existen nombres de clases duplicados en diferentes directorios definidos por el classpath. • -classpath /com:/foo:. • No es lo mismo que: • -classpath .:/foo:/com • Finalmente el comando java permite abreviar classpath con -cp. La documentación de java es inconsistente en si javac permite la abreviación –cp. En la mayoría de máquinas virtuales si lo es, pero esto no está garantizado.

14. Packages and Searching • Una vez que una clase está dentro de un paquete, el paquete es parte de su nombre completo — este nunca puede ser dividido. No se puede dividir en una línea de comandos, ni se puede dividir en un import.

15. Packages and Searching • El import statement es como un alias para el nombre completo. Se define el nombre completo para la clase con un import statement (o con un wildcard en un import statement del paquete). • Una vez definido el nombre completo, se puede usar el alias en el código ------ pero el alias se refiere siempre al nombre completo. • javac -classpath classes -d classes source/Another.java • Cuando se usa un classpath, el último directorio en le path debe ser el super-directory del directorio raiz del paquete. En el ejemplo anterior, classes es el directorio raiz para el paquete com.foo

16. Relative and Absolute Paths • Cada path en un classpath es absoluto o relativo. • Un path absoluto en Unix inicia con un slash (/) (en windows c:\). • El slash al inicio indica que este path esta iniciando desde el directorio raiz del sistema. • Un path relativo es lo que no inicia desde la raiz

17. Relative and Absolute Paths

18. Relative and Absolute Paths

19. JAR Files and Searching • JAR son usados para comprimir datos y archivar. • Crear un jar • jar -cf MyJar.jar myApp • Ver el contenido de un jar • jar -tf MyJar.jar

20. JAR Files and Searching • Encontrar un archivo jar usando un classpath es similar a encontrar un archivo de un paquete. • La diferencia es que cuando se especifica un path para un jar, se debe incluir el nombre del jar al final del path.

21. javac -classpath ws/myApp.jar UseStuff.java • javac -classpath ws UseStuff.java

23. Using .../jre/lib/ext with JAR files • Buried deep inside of your Java directory tree is a subdirectory tree named jre/lib/ext. If you put JAR files into the ext subdirectory, java and javac can find them, and use the class files they contain. • Sun recommends, however, that you use this feature only for your own internal testing and development, and not for software that you intend to distribute.

24. Using Static Imports • En Java 5, el import statement fue mejorao para proveer mayor capacidad de reduccion de escritura. • Esta nueva caractrísitica es conocida como static imports. • Static imports pueden ser usados cuando se desee usar miembros de una clase estática.

25. Using Static Imports Antes de static imports: public class TestStatic { public static void main(String[] args) { System.out.println(Integer.MAX_VALUE); System.out.println(Integer.toHexString(42)); }} Después de static imports: import static java.lang.System.out; // 1 import static java.lang.Integer.*; // 2 public class TestStaticImport { public static void main(String[] args) { out.println(MAX_VALUE); // 3 out.println(toHexString(42)); // 4 }}

26. Using Static Imports • 1. La sintaxis debe ser import static, seguido del nombre completo del miembro estático que se quiera importar o un wildcard(*). • 2. En este caso se podría querer usar muchos de los miembros de la clase java.lang.Integer class. El static import statement usa el wildcard para decir “Yo quiero hacer un static imports de todos los miembros estáticoas de esta clase." • 3. Podemos ver las ventajas de static import! No debemos tipear el System en System.out.println. • 4. No tipeamos el Integer en Integer.MAX_VALUE. • Así en está lineas de código somos capaces de usar un shortcut para un método y una constante estática.

27. Using Static Imports • Algunas reglas para import estáticos: • Se debe decir import static; no se debe decir static import. • Tener cuidado con las ambiguedades. Si tu haces un import estático para la clase Integer y para la clase Long, y se realiza una referencia a MAX_VALUE, esto causará un error de compilación, porque Integer y Long tienen una constante MAX_VALUE, y Java no sabrá a cual de las dos referirse. • Se puede hacer un import estático sobre referencias a objetos estáticos, constantes (final y static) y métodos estáticos.