01 Primeros Pasos Con Java
01 Primeros Pasos Con Java
01 Primeros Pasos Con Java
Como vemos, el programa está formado por una clase HolaMundo, que a su vez contiene un método main. Este
método contiene una única instrucción, que invoca el método println del objeto out, que a su vez pertenece a la
clase System. La clase System es una clase del sistema, que está siempre disponible para ser usada sin
necesidad de declarar o crear nada.
En este primer ejemplo, debemos destacar 3 cosas:
1. El nombre de la clase que contiene el fichero debe ser el mismo2 que el nombre del fichero (sin la
extensión .java).
2. En Java, los identificadores distinguen entre mayúsculas y minúsculas (por ejemplo, escribir ‘string’ en
lugar de ‘String’ provocará un error de compilación, al no saber a qué se refiere el identificador ‘string’).
3. Para que una clase se pueda ejecutar, debe contener un método main con un parámetro de tipo String[]
(un array de cadenas, como veremos más adelante).
1
Nunca emplee un procesador de textos (como Microsoft Word), ya que pueden introducir caracteres de formato ocultos
que el compilador interpreta como errores, y que a veces resultan difíciles de detectar.
2
Esto no siempre tiene por qué ser así, pero, por ahora, respetaremos este convenio.
En la asignatura Programación II vamos a usar la versión Java 11.
El JDK se instala en una ruta determinada del sistema de ficheros, que dependerá del sistema operativo, y que
podemos elegir o modificar. Normalmente, la variable de entorno JAVA_HOME apunta a esa ruta, que en los
ordenadores del laboratorio es:
JAVA_HOME = /usr/lib/jvm/java-11-openjdk-amd64
Los comandos que usaremos habitualmente durante el desarrollo y la ejecución de programas Java (por
ejemplo, el compilador javac) están en el directorio bin del JDK, es decir, en el directorio JAVA_HOME/bin, que
en el laboratorio es:
/usr/lib/jvm/java-11-openjdk-amd64/bin
3.1 El compilador
Como hemos dicho, el compilador del lenguaje Java se llama javac. Se trata de un programa que toma como
entrada un fichero .java (el fichero fuente), lo compila, y genera un fichero .class, que recibe el nombre de
bytecode. El bytecode es un código intermedio entre el código fuente y el código objeto. Por tanto, no es algo
directamente ejecutable, como en C, sino que necesita ser leído, interpretado y ejecutado por otro programa,
como veremos más adelante.
Por tanto, para compilar, ejecutaremos en un terminal el comando del siguiente cuadro.
• -d (para indicar que los ficheros .class deben generarse en otro directorio)
El siguiente comando crea HelloWorld.class en el subdirectorio classes del directorio src:
2. Indicar esos directorios o ficheros .jar al programa javac con el argumento -classpath (o también -cp). Por
ejemplo, y suponiendo que queremos compilar en Linux el fichero OtroProgramaJava.java que SI
depende de clases externas:
El uso de -classpath o -cp es prioritario respecto a la variable CLASSPATH. Si se usa -classpath o -cp en el
comando javac, no se hará caso al contenido de la variable CLASSPATH.
• Si no se encuentra el comando javac, posiblemente se debe a que la ruta donde está el programa javac
(JAVA_HOME/bin) no está entre las rutas donde se buscan los ejecutables. Esas rutas se indican en la
variable de entorno PATH, por lo que hay que añadir la ruta del directorio donde está el programa javac a
esa variable (si hay rutas a distintos JDKs en esa variable, se ejecutará el primero de ellos, por lo que éste
debe ser el del Java 11).
Para añadir rutas al valor de esa variable, podemos usar los siguientes comandos en el terminal:
o Linux: export PATH=/usr/lib/jvm/java-11-openjdk-amd64/bin:$PATH
o Windows: set PATH=C:\jdkX.Y\bin;%PATH%;
En ambos casos se cogerá el valor actual de PATH y se le añadirá al principio la ruta indicada a la carpeta bin
del JDK. Recordar que el separador en Linux es el carácter ‘:’, mientras que en Windows es ‘;’.
También es posible realizar esa modificación de forma permanente a través de ficheros de configuración. Por
ejemplo, en el caso de Linux, suponiendo que se use el shell bash:
o Crear el fichero .bashrc, que contenga la línea:
export PATH=/usr/lib/jvm/java-11-openjdk-amd64/bin:$PATH
o Crear el fichero .bash_profile, que contenga la línea:
source ~/.bashrc
• Si el compilador indica que no se encuentra alguna clase auxiliar, comprobad que la ruta a esa clase (o su
fichero .jar) está en la variable CLASSPATH o en el parámetro -cp/-classpath, si se usa.
4 Ejecutando el programa
¡IMPORTANTE! En este caso, lo que se le pasa al programa java no es el nombre del fichero .class, sino el
nombre de la clase a ejecutar (la clase que contiene el método main).
Por defecto, el programa java busca la clase a ejecutar en el directorio actual (debemos asegurarnos de que el
fichero HolaMundo.class está en el directorio actual).
2. Proporcionar esos directorios al programa java con el argumento -classpath (o -cp). Por ejemplo, volviendo
a suponer que HolaMundo.class está en src/classes:
Recordad que el uso de -classpath o -cp es prioritario respecto a la variable CLASSPATH. Si se usa -classpath o -
cp en el comando, no se hará caso al contenido de la variable CLASSPATH.
Hay que tener en cuenta que cada parámetro es una cadena de caracteres. Si el parámetro recibido representa,
por ejemplo, un entero, en realidad se lee la cadena con los dígitos de ese entero. Si queremos realizar
operaciones matemáticas con él, antes debemos convertirlo de String a int, por ejemplo, mediante la
llamada Integer.parseInt(s) que veremos más adelante.
5.2 Métodos
Los nombres de los métodos suelen ser verbos donde la primera letra se escribe en minúscula. En caso de
contener varias palabras, las restantes empezarán por mayúscula. Por ejemplo:
void acelerar(int incr);
void cambiarMarcha(int marcha);
5.3 Variables
Los nombres de las variables deben ser cortos pero significativos, siguiendo las mismas pautas descritas para los
métodos. Deben ser intuitivos y permitir deducir fácilmente su uso dentro del programa.
Se deberían evitar variables de una sola letra, excepto en el caso de variables temporales (p.e. índices de
bucles). Los nombres comúnmente adoptados para este tipo de variables temporales incluyen i, j, k, m y n
para enteros, y c, d, e para caracteres. Por ejemplo:
int velocidad = 0;
int maxAltura, maxAncho;
for (int i = 0; i < lim; i++)
5.4 Constantes
Las constantes en Java se identifican con el modificador final. Se escriben en letras mayúsculas, separando sus
posibles palabras internas mediante el símbolo de guion bajo (‘_’). Al igual que las variables, deben tener
nombres cortos y autoexplicativos. Por ejemplo:
final int CAPACIDAD = 30;
final float MAX_VAL = 29.3;
final String NOMBRE_FICHERO_DEF = “fichero.txt”;
5.5 Paquetes
Los nombres de los paquetes se escriben en letras minúsculas. En el caso de nombres de paquetes únicos,
deben comenzar con un nombre de dominio de nivel superior (e.g., com, edu, gov, mil, net, org...) y los
componentes posteriores del nombre del paquete dependerá de los criterios de denominación de cada
organización. Todos los paquetes oficiales de Java comienzan con la palabra java o utilizan la palabra java
como prefijo (e.g. javax). Por ejemplo:
java.lang
javax.swing
com.sun.eng
pkg1
6.1 Comentarios
Además de la forma tradicional de C (/* comentario */), en Java se puede comentar el resto de una línea
mediante la cadena “//”.
int cantidad; // variable para almacenar una cantidad
El JDK proporciona una serie de clases envoltorio (wrapper) que sirven para envolver un tipo básico. Estas clases
son: Integer, Long, Double…
Estas clases tienen una serie de métodos estáticos (static) para procesar tipos básicos, por ejemplo:
int num = Integer.parseInt(“3”); // convertir de cadena a número, algo muy habitual
String binaryRepresentation = Integer.toBinaryString(453);
E incluso mezclar tipos uniéndolos con el operador ‘+’ (sólo para generar una cadena o imprimir):
System.out.print(“El valor de la variable int x es ”+x);
6.4 Sentencia switch
Además de enteros y booleanos, como en C, un switch en Java también permite emplear cadenas en los case:
switch (var) {
case “uno”: break;
case “dos”: break;
default: break;
}
6.6 Excepciones
Para proteger a un programa frente a errores inesperados que suelen causar una terminación abrupta del
mismo, Java introduce el concepto de excepción, gestionado con el constructor try-catch.
Básicamente, se trata de encerrar el código que queremos proteger mediante el constructor try, y de declarar
uno o varios catch para tratar las correspondientes excepciones que se pueden producir (o una general que
capture cualquier excepción, que entraría en acción si no entra otra antes).
try {
// sentencias que conforman el comportamiento normal del programa
int dividendo=3, divisor=0;
int resultado = dividendo / divisor; // levantaría una excepción ArithmeticException
}
catch (ArithmeticException e) {
// sentencias para tratar la excepción ArithmeticException
System.out.println(“No se pudo dividir: ”+e.toString());
}
catch (Exception e) {
// sentencias para tratar la excepción general
System.out.println(“No se pudo dividir: motivo desconocido”);
}