Desarrollo

Compilar con javac

Estructura:

javac [options] [/source] 

Ejemplos:

javac -classpath com:. -g Clase1.java Clase2.java

La segunda invocación le pasa dos opciones al compilador, -classpath y –g, y dos archivos, Clase1.java y Clase2.java.
En la estructura de directorios:

C:.
├───classes
│
├───src
│   └───com
│       └───app
│               Clase1.java

Para compilar Clase1.java:

javac com\app\Clase1.java

Compilar con -d

Por defecto, el compilador pone los archivos .class en el mismo directorio de los respectivos archivos .java. La opción –d, directorio, permite indicarle al compilador en que directorio poner los archivos .class.

C:.
│
├───build
│   └───classes
│       └───org
│           └───app
│               └───ws
│
├───src
│   └───org
│       └───app
│           └───ws
│                   CellPhoneTask.java
javac -d ../build/classes org/app/CellPhoneTask.java

Si el directorio classes no existe, el compilador mostrará un mensaje de error.

Ejecutar aplicaciones con java

La estructura:
java [options] class [args]
Sólo especificar un archivo .class:
Java –DmiProp=miValue Clase1 x 1
Se lee “crea una propiedad del sistema llamado miProp cuyo valor es miValue, ejecuta el archivo Clase1.class y envíale dos argumentos de valores x y 1.

Usar las Propiedades del Sistema

La clase java.util.Properties puede ser usada para acceder a información persistente del sistema tal como la versión del SO, el compilador Java, y la maquina virtual Java:
import java.util.*;
public class TestProps {
public static void main(String[] args) {
Properties p = System.getProperties();
p.setProperty(“miProp”, “miValue”);
p.list(System.out);
}
}
Si el archivo es invocado como:
java -DcmdProp=cmdValue TestProps
La salida:

os.name=Windows 2000
miProp=miValue

java.specification.vendor=Sun Microsystems Inc.
user.language=en
java.version=1.6.0_05

cmdProp=cmdValue

cmdProp=cmdValue fue agregado mediante la opción –D de la línea de comandos, si el valor contiene espacios en blanco, se debe encerrar entre comillas dobles.

Argumentos de Línea de Comandos

public class CmdArgs {
public static void main(String[] args) {
int x = 0;
for(String s : args)
System.out.println(x++ + ” elemento = ” + s);
}
}
Invocada como:
java CmdArgs x 1
La salida es:
0 elemento = x
1 elemento = 1

Búsqueda de Clases

El algoritmo que javac y java usan para ubicar las clases es:
1. Ambos comparten la lista de directorios de búsqueda de clases.
2. Ambos buscar en ésta lista en el mismo orden.
3. La búsqueda se detiene en la primera coincidencia.
4. El primer lugar de búsqueda es en los directorios de J2SE.
5. El segundo lugar de búsqueda es en los directorios definidos por los classpaths.
6. El classpath declarado como opción de la línea de comandos sobrescribe el classpath declarado como una variable de entorno, pero sólo existe durante la invocación.

Declarar/Usar Classpaths

En Unix:
-classpath /com/foo/acct:/com/foo
En Windows:
-classpath .\com\foo\acct;.\com\foo
En el comando anterior no se busca en el directorio com. Por defecto la búsqueda no ocurre en el directorio actual, para modificarlo agregar un punto (.) al classpath:
-classpath /com/foo/acct:/com/foo:.
Los classpath se buscan de izquierda a derecha. Si existe coincidencia de archivos Java en diferentes localizaciones los resultados serán diferentes en el siguiente caso:
-classpath /com:/foo:.
versus
-classpath .:/foo:/com
Se puede abreviar –classpath con –cp.

Archivos JAR

C:.
│
├───build
│   └───classes
│       └───org
│           └───app
│               └───ws
│
├───src
│   └───org
│       └───app
│           └───ws
│                   CellPhoneTask.java

Para crear un archivo jar

cd WebService
jar -cf WebService.jar src

Para ver el contenido del jar usar el comando siguiente:

jar -tf WebService.jar

Al incluir un jar en el path, se debe colocar el nombre del jar al final del path.

cd WebService
javac -classpath WebService/WebService.jar Client.java

Si las clases no están incluidas en un archivo jar, entonces se puede usar Client por el siguiente comando:

cd WebService
javac -classpath WebService UsarUtil.java

Como WebService esta en el classpath y es el directorio contenedor de src, las clases en los paquetes contenidos en src son encontradas.

Usar…/jre/lib/ext con archivos JAR

Por fines de desarrollo y pruebas se pueden colocar los JARs en el directorio jre/lib/ext de modo que javac y java puedan encontrar automáticamente los JARs.

import static

Desde Java 5 contamos con: static imports. Sirven para usar los miembros estáticos de una clase.
Antes:

public class TestStatic {
public static void main(String[] args) {
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.toHexString(50));
}
}

Después:

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(50));
}
}

1. Usamos import static para usar el objeto out de la clase System.
2. Necesitamos varios miembros de la clase Integer, usamos un wildcard, que significa: yo necesito todos los miembros estáticos de la clase Integer.
3. El compilador genera error si existe una ambigüedad, ejemplo: Integer.MAX_VALUE y Long.MAX_VALUE.
4. Se puede usar static imports para referencias a objetos, constantes – static y final – y métodos estáticos.

Etiquetas:

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s


A %d blogueros les gusta esto: