Java – Un paseo por Eclipse

lasecreObjetivo: presentar Eclipse, un Entorno de Desarrollo Integrado (IDE) para programar en Java.

En los primeros artículos de la serie mostramos el flujo de trabajo típico para desarrollar una aplicación en Java: empleando un editor de texto escribimos el código fuente de las clases, que almacenamos en ficheros con extensión .java. A continuación, desde la línea de comandos, compilamos esos ficheros, obteniendo otros con extensión .class que, finalmente, en una tercera fase, podemos ya ejecutar invocando a la máquina virtual Java.

Este flujo de trabajo constituye, en efecto, parte esencial de la programación en Java. Sin embargo, a medida que nuestros proyectos se vuelven más complejos, este sistema se muestra ineficiente, pues perdemos mucho tiempo en pormenores que nos distraen de la labor en sí de programar.

Un Entorno de Desarrollo Integrado (IDE, Integrated Development Environment), es una aplicación que, como su nombre sugiere, integra en un único programa todas las herramientas para el desarrollo completo de una aplicación en sus diferentes etapas, desde la edición del código fuente inicial hasta la obtención del producto final.

Cada IDE suele estar especializado en un lenguaje de programación determinado (o en varios), de modo que las herramientas que integran están perfectamente adaptadas y dirigidas hacia ellos. El editor de texto que ofrece un IDE no es un editor cualquiera, sino que, además de cumplir las funciones típicas de todo editor, incluye características especiales que facilitan sobremanera la programación en ese lenguaje particular. Además, dentro del mismo IDE podemos ocuparnos de las tareas comunes de compilar, depurar y ejecutar el proyecto sin necesidad de abandonar en ningún momento el entorno.

Existen diversos IDE para Java, de todos los precios y colores. Dos de los más populares, gratuitos y de código abierto, son Eclipse y NetBeans. En este artículo instalaremos el primero y realizaremos el bautizo “Hola mundo” en él. En otro momento introduciremos también NetBeans , a la par que descubriremos las virtudes que nos ofrecen ambos entornos.

La instalación de Eclipse es muy sencilla y comienza dirigiéndonos a la página de descarga del producto, desde la cual podemos obtener la última versión disponible para nuestra plataforma.En el momento de escribir estas líneas tenemos a nuestra disposición la versión de Eclipse 4.5, con nombre de batalla Mars.

Tradicionalmente, la instalación de Eclipse ha sido siempre tan simple como descomprimir un fichero .zip en una carpeta de nuestra elección, sin ningún instalador propio. Es decir, resultando en lo que en un entorno Windows denominamos una aplicación portable. Un resultado limpio, sin ficheros en otras carpetas ajenas a esa estructura ni misteriosas entradas en el registro. No obstante, para todos aquellos a los que descomprimir un .zip les pueda resultar una tarea complicada, Eclipse facilita, desde hace poco, un instalador en toda ley que se ocupa de la creación automática de iconos, entradas en el menú Inicio y todas esas cosas. Puedes encontrarlo en la cabecera de la página de descarga.

Para instalarlo a la vieja usanza, descargamos el .zip con la solución más adecuada a nuestra plataforma y fines.

eclipse1

Observa que entre la lista de paquetes se encuentran incluso distribuciones de Eclipse para otros lenguajes de programación distintos de Java que también pueden beneficiarse de las excelencias de este IDE.

Presta mucha atención a la elección entre 32 y 64 bits. Eclipse es una aplicación escrita en Java y, como tal, necesita que tengas instalada la máquina virtual Java. Si tu sistema operativo es de 64 bits y la versión que tienes de Java también es de 64 bits, entonces podrás usar la versión 64 bits de Eclipse. Pero si la versión que tienes de Java es de 32 bits (algo muy común si, por ejemplo, la has instalado a través del navegador Firefox), entonces deberás utilizar la versión de 32 bits de Eclipse. De lo contrario, no arrancará.

No necesitas tener instalado el kit de desarrollo Java (JDK), pues Eclipse trae incorporado uno. Si en algún momento deseas utilizar uno distinto podrás indicárselo dentro de las opciones de configuración del programa.

Abre el .zip y descomprímelo en la carpeta de tu elección. Instalación concluida.

Si lo deseas, créate un acceso directo al ejecutable (eclipse.exe) arrastrándolo con el botón derecho hasta el escritorio y eligiendo la opción Crear iconos de acceso directo aquí.

Una vez arrancado Eclipse lo primero que nos aparece es un cuadro de diálogo preguntándonos por el workspace, esto es, en qué carpeta deseamos que se almacenen los proyectos que generemos a lo largo de esta sesión. Puedes aceptar la que te ofrece por defecto y, si no prevés cambiar esa ubicación con frecuencia, puedes marcar la casilla de verificación para que no te pregunte más. Cada proyecto de Eclipse se almacenará en una subcarpeta propia dentro de la carpeta que hayas indicado aquí.

eclipse2

Superado este trámite, se nos muestra una ventana de bienvenida que nos ofrece opciones para dar un paseo por Eclipse, conocer las novedades de la última versión o incluso estudiar algunos tutoriales.

eclipse3

Por el momento, puedes cerrarla, apareciendo la vista principal de la aplicación. Si en algún momento deseas recuperar la ventana de bienvenida, puedes hacerlo a través del menú Help | Welcome:

eclipse5

En sucesivos artículos tendremos ocasión de familiarizarnos con más detalle con las posibilidades que nos ofrece Eclipse. Hoy nos centraremos en el primer reto al que debe enfrentarse todo programador al aprender un nuevo lenguaje o, en este caso, un nuevo IDE: saludar al mundo.

Para crear nuestro ambicioso proyecto elegimos File | New | Java Project:

eclipse6

Mostrándose así el asistente para la creación de un nuevo proyecto. Elegimos un nombre y mantenemos, por el momento, las demás opciones tal como aparecen. Observa que se creará una carpeta en tu workspace con el mismo nombre que el del proyecto.

eclipse7

Pulsamos el botón Finish para retornar a Eclipse con la estructura del nuevo proyecto creada.

eclipse8

En Package Explorer, despliega el contenido del proyecto. Observa la aparición de una carpeta, src, que es la que contendrá los ficheros con el código fuente de las clases que escribamos. Por el momento está vacía, de modo que vamos a agregar la única clase necesaria para nuestro proyecto. Haz clic con el botón derecho sobre ella y elige New | Class.

eclipse9

Nos aparece el asistente para la creación de clases. Establecemos el nombre (hay que retirar el espacio blanco entre Hola y Mundo para que sea un identificador válido) y marcamos la casilla para que automáticamente nos cree el esqueleto del método main(), ahorrándonos tener que picarlo a mano.

eclipse10

Hemos creado el fichero HolaMundo.java, que contiene la clase HolaMundo, en cuyo interior observamos, listo para ser completado por nosotros, el método main(), punto de inicio de toda aplicación Java.

eclipse11

En el interior de main() insertamos el código necesario para que muestre un mensaje por consola:

eclipse12

Por defecto, Eclipse intenta compilar el proyecto tan pronto se salva el código fuente en disco. Observa la marca en Project | Build Automatically. De modo que sólo tienes que guardar los cambios con File | Save (o la combinación Ctrl-S) para que se genere el fichero HolaMundo.class con tu aplicación Java.

eclipse13

Desplázate con el Explorador de Windows a la carpeta de tu proyecto. Verás una subcarpeta, bin, destinada a almacenar nuestras clases ya compiladas.

eclipse14

La separación código fuente / resultado en carpetas diferentes es una de las opciones que se nos ofrecían por omisión en el asistente de creación de un nuevo proyecto.

Tan sólo resta ejecutar la aplicación desde Eclipse, para lo cual seleccionamos el menú Run | Run:

eclipse15

Se nos abrirá una consola en la parte inferior de la ventana con el resultado de la ejecución del programa:

eclipse16

Hemos ilustrado, de una manera muy resumida y simple, la utilización de un IDE como Eclipse. Llegar a dominarlo requiere cierto trabajo, pero es un esfuerzo que realmente marcará la diferencia tan pronto comencemos a abordar proyectos de mayor envergadura.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2015/09/java-un-paseo-por-eclipse/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos sobre Java.

Safe Creative #1509225214159

Java – Los ocho magníficos

lasecreObjetivo: presentar los tipos de datos primitivos en Java.

Antes de que empecemos a fabricar objetos como churros es importante que nos tomemos un tiempo para familiarizarnos con la materia prima de que están hechos, los ladrillos con los que construiremos nuestras nuevas estructuras de datos.

Sabemos que los objetos se componen de atributos, que no son más que un conjunto de variables con sus respectivos valores, y de métodos, las funciones que definen el comportamiento del objeto, lo que se puede hacer con él. Estos métodos, por lo general, procesan y devuelven datos también.

De modo que las variables son la sangre que circula internamente por los objetos.

Java requiere que especifiquemos el tipo de una variable en el momento preciso de declararla. Si recuerdas las clases Coche y Persona de los artículos anteriores, verás que aparecían en ellas algunas instrucciones como las siguientes:

String marca;
int velocidad;
boolean arrancado;
char sexo;
Coche coche;

Se trata de declaraciones de variables, en las que se asocia a cada nombre un tipo. Así pues, la variable marca referenciará una cadena de caracteres para indicar la marca del coche; velocidad contendrá un valor entero para expresar su velocidad; arrancado, de tipo booleano (verdadero o falso) nos hará saber si el vehículo está puesto en marcha o no; sexo contendrá un único carácter para indicar si la persona es un hombre o una mujer; coche, finalmente, es una variable de tipo Coche, un tipo que hemos diseñado nosotros al crear la clase Coche. Recuerda que Java diferencia entre mayúsculas y minúsculas, por eso coche y Coche son identificadores diferentes.

Fijémonos en los tipos de estas variables. Algunas de ellas, como coche, tienen por tipo el nombre de una clase. No es tan obvio eso mismo en la variable marca, pero observa que su tipo, String, comienza escrito por mayúsculas. Ya sabes que los nombres de clases, por convenio, empiezan por mayúsculas. Puedes pensar en Coche y String como tipos de datos compuestos, en oposición a los tipos simples restantes.

Los protagonistas de hoy son esos datos simples, atómicos, que luego utilizamos para construir otros tipos compuestos más elaborados. En Java son ocho y reciben el nombre de tipos primitivos.

Veamos cuáles son, agrupados por categorías.

Para declarar variables que contengan números enteros disponemos de cuatro tipos: byte, short, int y long. Se trata de enteros con signo (para valores positivos y negativos) y la diferencia entre ellos no es otra sino el número de bytes que ocupan en memoria y, por lo tanto, el rango numérico que pueden representar.

byte –> 1 byte (8 bits)
Rango: -128 / +127

short –> 2 bytes (16 bits)
Rango: -32768 / +32767

int –> 4 bytes (32 bits)
Rango: –2147483648 / +2147483647

long –> 8 bytes (64 bits)
Rango: –9223372036854775808 / +9223372036854775807

Como veremos cuando tratemos el tema de los literales, int es el tipo favorito de Java para lidiar con enteros. De ahí que a menudo nos planteemos una cuestión: ¿merece la pena la utilización de tipos como byte o short? Para aplicaciones sencillas, en las que la optimización del uso de memoria puede no ser relevante, no habría inconveniente. Pero imagina, por ejemplo, un programa que tuviera que manipular arrays grandes de enteros tipo byte (hablaremos de los arrays a su debido momento, pero por ahora basta con que sepas que son estructuras que permiten almacenar muchos elementos de un mismo tipo). Utilizar 4 bytes por cada elemento en lugar de 1, cuando son muchos, podría implicar un desperdicio de memoria crítico. Además, definir adecuadamente el tipo de los datos, dimensionándolos a lo estrictamente necesario, ayuda a mejorar la legibilidad y la comprensión del programa.

Para trabajar con números decimales disponemos de los tipos float y double. Están basados en el estándar IEEE 754 de representación en coma flotante. Si no has oído hablar de ese estándar hasta ahora y no sabes qué es eso de la mantisa y el exponente, te recomiendo que hagas una sencilla búsqueda en Google y te informes. Es una lectura que todo el mundo que trabaja con ordenadores debe hacer al menos una vez en su vida.

La diferencia entre float y double estriba, al igual que con las distintas opciones para números enteros, en el tamaño que ocupan: 32 bits el tipo float y 64 el tipo double, representando los números decimales con precisión simple o doble, respectivamente. Esto determinará tanto el máximo valor como el mínimo valor que podremos representar.

float –> 4 bytes (32 bits)
Mínimo: ±1.40239846E-45
Máximo: ±3.40282347E+8

double –> 8 bytes (64 bits)
Mínimo: ±4.94065645841246544E-324
Máximo: ±1.79769313486231570E+308

Aprecia la notación exponencial, no sería práctico escribir aquí un chorizo de trescientas cifras.

El tipo double es el favorito de Java al tratar números decimales. No obstante, como sucedía con los enteros, habrá situaciones en las que el ahorro de memoria puede ser un factor determinante que requiera una declaración de variables austera con float.

Para almacenar un carácter simple, Java dispone del tipo primitivo char, que ocupa 16 bits. Con él podemos representar caracteres Unicode (¡toda una bendición!) comprendidos entre ‘\u0000’ (0) y ‘\uFFFF’ (65535).

El octavo magnífico de nuestra serie es el tipo boolean, que admite dos posibles valores: true o false. Sólo se necesita un bit para almacenar dos estados posibles, pero el tamaño real que ocupa una variable boolean depende de la plataforma y de la implementación particular en Java. No es una cuestión importante pues, como hemos dicho, sólo se utiliza un bit, se guarde como se guarde.

Lo que resulta significativo es el hecho de que Java defina con exactitud el tamaño de sus tipos primitivos (sin contar boolean). No hay que perder de vista que Java está pensado como lenguaje multiplataforma. Si has programado en otros lenguajes y entornos quizás hayas constatado que el tamaño de un entero está muy relacionado con la arquitectura en particular. ¿Cómo es posible que Java logre esa independencia de la plataforma?

La clave es entender que cuando escribes un programa Java no lo estás haciendo directamente para tu sistema, sino para una una abstracción que es la máquina virtual Java (que, naturalmente, sí que es dependiente de la plataforma). Esa es la magia tras el slogan de Java, “escribe una vez, ejecuta en todas partes”, que permite que el código escrito para una plataforma funcione directamente y sin correcciones (en términos generales, no siempre es así) en cualquier otra en la que exista una máquina virtual Java.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2014/05/java-los-ocho-magnificos/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos sobre Java.

Java: Un programa para probar las clases

lasecreObjetivo: desarrollar un programa completo en Java que permita poner a prueba las clases que hemos definido en los artículos anteriores.

Hagamos una breve recopilación de lo que llevamos hasta ahora: hemos definido los conceptos de clase y de objeto, pilares sobre los que se edifica la metodología de la programación orientada a objetos. Sabemos que las clases encapsulan atributos, elementos que indican las características de los objetos, y métodos, conjunto de funciones que definen su comportamiento. Aprendimos a crear objetos nuevos con new y mostramos cómo acceder a los atributos y métodos mediante la notación punto.

Definimos varias clases; entre ellas, Persona y Coche. Cada una reside en su propio fichero de código fuente .java y ha sido compilada en su respectivo fichero .class.

Va a entrar en escena una nueva clase que contendrá el programa principal desde el que probaremos la operatividad de las anteriores.

// ProbandoClases.java

public class ProbandoClases
{
  public static void main(String[] args)
  {
    // Aquí introduciremos el código para probar nuestras clases
  }
}

Esta nueva clase la mantendremos en el mismo directorio en el que se encuentran las restantes y en un fichero independiente denominado ProbandoClases.java. El nombre del fichero debe coincidir con el de la clase, teniendo en cuenta, además, que se diferencian las mayúsculas de las minúsculas.

La razón de ubicar el programa y las clases en el mismo directorio no es otra sino para tener acceso a ellas desde el programa principal. En breve, cuando definamos el concepto de paquete , veremos otros modos de definir las clases y agruparlas de un modo más práctico que facilite la reutilización de código entre programas diferentes. Todo a su momento; vayamos concepto a concepto.

Fíjate en el esqueleto del programa principal: es la misma estructura que presentamos en el Hola Mundo. Con lo que ya sabemos sobre las clases podemos aportar algo más de luz.

public class ProbandoClases

Olvídate por el momento del public. Si te das cuenta, el programa en sí mismo también es una clase, caracterizada por la palabra reservada class. Como tal, podrá tener también sus atributos y métodos.

Fíjate ahora en la siguiente línea:

public static void main(String[] args)

Dejemos el public static para otra ocasión. Lo que vemos después no es más sino la definición de un método, denominado main, que acepta una serie de parámetros entre paréntesis (de los que hablaremos a su debido momento), y que no devuelve ningún valor (void).

Todos los programas en Java han de disponer de un método llamado main, definido del mismo modo que en nuestro ejemplo. Es el punto donde comenzará la ejecución del programa.

Si has programado en C esto no te resultará muy sorprendente, pues en ese lenguaje de programación todo comienza en main también. Lo particular de Java, donde prácticamente todo es un objeto, es que main, en sí mismo, está encapsulado dentro de una clase.

Para que nos sirva de referencia y por comodidad, repito aquí el código de las clases Coche y Persona.

// Coche.java

class Coche
{
  String marca;
  String modelo;
  String color;
  int numeroDePuertas;
  int cuentaKilometros;
  int velocidad;
  boolean arrancado;
  
  void arrancar()
  {
    arrancado = true;
  }
  
  void parar()
  {
    arrancado = false;
  }
  
  void acelerar()
  {
    velocidad = velocidad + 1;
  }
  
  void frenar()
  {
    velocidad = velocidad - 1;
  }
  
  void pitar()
  {
    System.out.println("Piiiiiiiiiiiiiiiiii");
  }
  
  int consultarCuentaKilometros()
  {
    return cuentaKilometros;
  }
}

// Persona.java

class Persona
{
  char sexo;
  String nombre;
  int edad;
  Coche coche;
  
  void saludar()
  {
    System.out.println("Hola, me llamo " + nombre);
  }
  
  void dormir()
  {
    System.out.println("Zzzzzzzzzzz");
  }
  
  int obtenerEdad()
  {
    return edad;
  }
}

He numerado las líneas del código del programa principal para poder referenciarlas después en la explicación. Obviamente, esa numeración no debe aparecer en el fichero real.

1  public class ProbandoClases
2  {
3    public static void main(String[] args)
4    {
5      // Aquí introduciremos el código para probar nuestras clases
6      
7      Coche coche1 = new Coche();
8      Persona persona1 = new Persona();
9      Persona persona2 = new Persona();
10    
11    
12      coche1.marca = "Seat";
13      coche1.modelo = "Panda";
14      coche1.color = "Beige";
15      coche1.numeroDePuertas = 3;
16      coche1.cuentaKilometros = 215000;
17      coche1.velocidad = 0;
18      coche1.arrancado = false;
19    
20      persona1.sexo = 'F';
21      persona1.nombre = "Marta";
22      persona1.edad = 32;
23      persona1.coche = coche1;
24    
25      persona2.nombre = "Raimundo";
26        
27      System.out.println(coche1.marca);
28      System.out.println(coche1.modelo);
29      System.out.println(coche1.color);
30      System.out.println(coche1.numeroDePuertas);
31      System.out.println(coche1.cuentaKilometros);
32      System.out.println(coche1.velocidad);
33      System.out.println(coche1.arrancado);
34    
35      System.out.println(persona1.sexo);
36      System.out.println(persona1.nombre);
37      System.out.println(persona1.edad);
38      System.out.println(persona1.coche);
39      System.out.println(persona1.coche.marca);
40      System.out.println(persona1.coche.modelo);
41    
42      System.out.println(persona2.sexo);
43      System.out.println(persona2.nombre);
44      System.out.println(persona2.edad);
45      System.out.println(persona2.coche);
46    
47      coche1.arrancar();
48      System.out.println(coche1.arrancado);
49      coche1.acelerar();
50      System.out.println(coche1.velocidad);
51      coche1.acelerar();
52      System.out.println(coche1.velocidad);    
53      coche1.acelerar();
54      System.out.println(coche1.velocidad);    
55      coche1.frenar();
56      System.out.println(coche1.velocidad);    
57      coche1.frenar();
58      System.out.println(coche1.velocidad);    
59      coche1.frenar();
60      System.out.println(coche1.velocidad);
61      coche1.parar();
62      System.out.println(coche1.arrancado);
63      coche1.pitar();
64      coche1.consultarCuentaKilometros();
65    
66      persona1.saludar();
67      persona1.obtenerEdad();
68      persona2.saludar();
69      persona2.obtenerEdad();
70      persona1.dormir();
71      persona2.dormir();  
72    
73    }
74  }

Si no has modificado las clases y ya tienes los respectivos ficheros .class generados, sólo necesitarás compilar el nuevo fichero:

javac ProbandoClases.java

En caso contrario, si tienes que compilar todo, puedes proceder así:

javac *.java

Para ejecutar el programa, basta con invocar la máquina virtual Java facilitando el nombre de la clase que contiene al método main():

java ProbandoClases

Esta es la salida generada, numerada por mí también para seguir mejor la explicación:

1  Seat
2  Panda
3  Beige
4  3
5  215000
6  0
7  false
8  F
9  Marta
10  32
11  Coche@8814e9
12  Seat
13  Panda
14
15  Raimundo
16  0
17  null
18  true
19  1
20  2
21  3
22  2
23  1
24  0
25  false
26  Piiiiiiiiiiiiiiiiii
27  Hola, me llamo Marta
28      32
29  Hola, me llamo Raimundo
30      0
31  Zzzzzzzzzzz
32  Zzzzzzzzzzz

En las líneas 7-9 del programa nos ocupamos de la creación de los tres objetos con los que trabajaremos, un coche y dos personas. Observa cómo, en la misma instrucción, declaramos cada objeto y lo creamos.

Establecemos valores para los atributos de estos objetos en las líneas 12-25. Al contrario de lo que sucede con persona1, a quien le hemos definido todos sus atributos, persona2 sólo recibe valor (por nuestra parte) del nombre.

En 27-45 realizamos una impresión de todos los atributos de los tres objetos. Podemos observarlo en las salidas 1-17. Merece la pena prestar atención a algunos detalles:

En un momento dado (línea 38 del programa) tratamos de imprimir el valor de persona1.coche. Ese atributo, si prestas atención a la definición de la clase, es de tipo Coche, es decir, es un objeto en sí mismo. Por eso la respuesta rara que obtenemos en la impresión (línea 11), que en verdad es algo así como una referencia a la ubicación del objeto. Podemos tratar de profundizar en ese objeto si deseamos conocer sus atributos. Es precisamente lo que hacemos en las líneas 39-40, obteniendo la respuesta 12-13 en la salida. Presta mucha atención a la doble notación punto para preguntar por el atributo de un atributo.

Entre las líneas 42-45 preguntamos por los atributos de persona2, a la que sólo hemos facilitado su nombre. Sin embargo, Java ya ha hecho algo por nosotros.

Cada vez que se construye un nuevo objeto se invoca a un método especial que tienen todas las clases que se denomina el constructor que presentaremos formalmente en otro artículo. Entre sus funciones se encuentra la de inicializar todos los atributos del objeto. El constructor, cuando está definido explícitamente, suele incorporar en forma de argumentos valores con los que inicializar los miembros. La cuestión es que, si no hay una inicialización explícita en ese constructor, Java se ocupará de suministrar valores iniciales por su cuenta. Ese valor dependerá del tipo de variable. Por ejemplo, si es numérico le asignará el valor cero; si es un booleano, false, si es de tipo char, el carácter nulo (línea 14 de la salida, devuelta en blanco, en respuesta a la línea 42 del código) y si es un objeto (categoría entre la que se encuentran las cadenas de caracteres también), le asignará el valor null (línea 17 de la salida, en respuesta a la línea 45 del código), que es un modo que tiene Java de decirnos que es un objeto inexistente o indefinido.

A partir de la línea 47 comenzamos a probar los métodos de los objetos.

Arrancamos coche1, lo que ocasiona, si revisas el código de la clase, que la variable arrancado se establezca en true, hecho que comprobamos por medio de la línea 48, obteniendo la salida 18.

En las líneas siguientes jugamos a acelerar y a frenar el coche. Observa las salidas 19-24, en las que, después de acelerar gradualmente (incrementando en uno la velocidad) frenamos para volver a dejar el coche con velocidad cero.

Detenemos el motor del vehículo (línea 61) y hacemos sonar su claxon (línea 63, salida 26).

En las líneas de código 27-30 pedimos a persona1 y persona2 que se presenten y nos digan su nombre y edad. Observa que el método obtenerEdad() devuelve un valor numérico, al contrario de los restantes, que no retornan nada (void), de modo que para poder saber de qué valor se trata, obtenerEdad() ha de formar parte de una expresión imprimible (líneas 67 y 69).

Yo estoy cansado de tanto escribir y Marta y Raimundo de que haga el tonto con ellos. De modo que todo el mundo a dormir (líneas 70-71, salidas 31-32).

Javier Montero Gabarró


Java: Un programa para probar las clases


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos sobre Java.

Java: El concepto de objeto

lasecreObjetivo: comprender el concepto de Objeto, diferenciándolo del de Clase y presentar la notación punto.

Una vez hemos entendido el concepto de Clase en el paradigma de la Programación Orientada a Objetos, es momento de matizar que es un Objeto en su sentido más práctico.

Una Clase, como hemos visto, no es más que una especificación que define las características y el comportamiento de un determinado tipo de objetos. Piensa en ella como si se tratara de una plantilla, molde o esquema a partir del cual podremos construir objetos concretos.

Consideremos la clase Coche que definimos en el artículo anterior:

class Coche
{
  String marca;
  String modelo;
  String color;
  int numeroDePuertas;
  int cuentaKilometros;
  int velocidad;
  boolean arrancado;
  
  void arrancar()
  {
    arrancado = true;
  }
  
  void parar()
  {
    arrancado = false;
  }
  
  void acelerar()
  {
    velocidad = velocidad + 1;
  }
  
  void frenar()
  {
    velocidad = velocidad - 1;
  }
  
  void pitar()
  {
    System.out.println("Piiiiiiiiiiiiiiiiii");
  }

  int consultarCuentaKilometros()
  {
    return cuentaKilometros;
  }
}

Con este esquema en nuestras manos, vamos a crear coches concretos de la marca, modelo y color que nos apetezca. Cada uno que creemos será un objeto, o instancia, de la clase Coche. Fíjate, en esta terminología, en la equivalencia de los términos objeto e instancia para referirnos, ahora sí, a entidades concretas de una determinada clase.

Fabriquemos, entonces, nuestro primer coche…

Cada objeto, como todas las variables en Java, ha de ser declarado antes de ser utilizado:

Coche coche1;

Con esta instrucción declaramos la variable coche1 de tipo Coche. En cuanto creemos, con el comando que escribiremos a continuación, el objeto concreto, coche1 contendrá una referencia a ese objeto, es decir, almacenará la dirección de memoria en la que realmente se halla el objeto propiamente dicho. Esto es muy importante: coche1 no contendrá el objeto en sí, sino una dirección de memoria que apunta a él.

Materialicemos nuestro primer coche del siguiente modo:

coche1 = new Coche();

La palabra reservada new se emplea para crear nuevos objetos, instancias de una determinada clase que indicamos a continuación seguida de un par de paréntesis.

Veremos esto a su debido momento, pero por ahora debe bastarte retener que se está invocando a un método especial que tienen todas las clases que sirve para construir el objeto en cuestión facilitándole sus valores iniciales. A este método se le conoce como constructor de la clase.

Podríamos habernos ocupado de la declaración y la creación en una sola instrucción:

Coche coche1 = new Coche();

Otro trasto más contaminando nuestras ciudades. Hagamos, al menos, que no consuma mucho:

coche1.marca = "Seat";
coche1.modelo = "Panda";

Consulta el cuadro de arriba con la definición de la clase y observa que tanto marca como modelo son dos atributos de tipo String, por lo que referencian cadenas de caracteres que escribimos entre comillas.

Observa con cuidado la notación punto. Separamos el nombre de la variable que referencia al objeto del atributo empleando un punto como separador.

Pintemos de azul nuestro flamante vehículo:

coche1.color = "Azul";

Además tiene tres puertas, el cuenta kilómetros indica 250.000 Km (bueno, algo viejo parece que es) y su velocímetro refleja 0 Km/h. Valores correspondientes a los atributos numeroDePuertas, cuentaKilometros y velocidad, respectivamente, todos de tipo entero.

coche1.numeroDePuertas = 3;
coche1.cuentaKilometros = 250000;
coche1.velocidad = 0;

Su motor está detenido, hecho que representamos a través de la variable booleana arrancado:

coche1.arrancado = false;

Cuando nos cansemos de enredar con los atributos podemos jugar con los métodos. Arranquemos el Panda:

coche1.arrancar();

De nuevo, empleamos también la notación punto para separar la variable del método.

Si observas el código verás que este método se limita a hacer que la variable booleana arrancado valga ahora true. Podrías decir que hubiéramos logrado el mismo resultado actuando sobre el atributo directamente, en lugar de invocar al método:

coche1.arrancado = true;

En efecto, es así; pero, como comprenderás más adelante, no suele ser buena idea dejar que los programas campen a sus anchas y modifiquen arbitrariamente los atributos de un objeto, siendo preferible que sean los métodos los que se ocupen de esa labor. Imagina que el programa intenta hacer que el cuenta kilómetros marque una cantidad negativa, o que el número de puertas sea igual a cincuenta. Un método correctamente diseñado podría gestionar que los valores estuvieran dentro del rango adecuado y asegurarse de que se cumplen las condiciones que permitirían la modificación del atributo.

La Programación Orientada a Objetos implementa un mecanismo, denominado encapsulación, que nos permite ocultar determinadas facetas de nuestro objeto y dejar sólo accesibles aquellas partes que nos interesen. Pero vayamos por orden, todo a su momento…

Sigamos jugando con nuestro viejo cacharro azul:

coche1.acelerar();

Lo que provocará, si consultas el código, que el velocímetro incremente en una unidad su valor.

coche1.pitar();

Lo que ocasionará un estridente pitido.

Puedes crear todos los objetos de la clase Coche que desees:

Coche coche2 = new Coche();

Cada uno con su propia colección de atributos:

coche2.marca = "Ford";
coche2.modelo = "Fiesta";
coche2.color = "Negro";

Incluso podrías crear otros Seat Pandas, por supuesto. Aunque, en un instante dado, compartieran los mismos valores en sus atributos, se trataría de objetos distintos, ubicados en direcciones de memoria diferentes y cada uno podría seguir su propia trayectoria vital.

En el próximo artículo aprenderemos a crear un programa que nos permita probar nuestra clase Coche y en el que veremos en acción las líneas de código que hoy hemos esbozado.

Javier Montero Gabarró


Java: El concepto de objeto


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos sobre Java.

Java: El concepto de clase

lasecreObjetivo: presentar el concepto de clase, pilar sobre el que está construido todo el paradigma de la programación orientada a objetos.

Voy a proponerte un sencillo juego. Sal a la calle, mira a tu alrededor y contempla el mundo de un modo particular.

Veo veo… ¿Qué ves?
Una cosita… ¿Y qué cosita es?

Para empezar, quiero que identifiques qué tipos de objetos ves…

Puedes, por ejemplo, encontrarte coches, bares, semáforos o personas, por citar sólo unos cuantos tipos. Date cuenta de que, cuando digo tipos de objetos, hablo de un modo conceptual y general. Si te resulta chocante referirte a una persona como un objeto, prueba a sustituir la expresión por tipos de entidades, en su lugar.

Tipo y clase son dos términos sinónimos, de modo que vamos a cambiar “tipos de objetos” por “clases de objetos”, aproximándonos un poco más al concepto que da pie al artículo de hoy.

¿Qué clases de objetos vemos? Coches, bares, semáforos, personas…

La siguiente transformación lingüística consiste en simplificar clases de objetos por simplemente clases:

¿Qué clases vemos? Coches, bares, semáforos, personas…

Y ahora sí, nos sumergimos plenamente en la terminología de la programación orientada a objetos:

Tenemos la clase Coche, la clase Bar, la clase Semáforo, la clase Persona

Poco interesan ahora los detalles concretos. No importa si esa persona es Marta, está en el bar “Casa Manolo”, si tiene un Seat Panda o si el semáforo está en rojo. Estamos pensando en términos clasificatorios.

Vamos a adentrarnos ahora en el interior de cada una de estas clases.

¿Cómo son los coches? ¿Qué características pueden diferenciar uno de otro?

Por ejemplo, podríamos indicar la marca, el modelo, el color, la cilindrada, etc.

A las características las vamos a denominar atributos, término muy utilizado en la programación orientada a objetos.

¿Qué atributos tiene la clase Bar?

Todo bar tiene un nombre, una ubicación, un estado (si está abierto o cerrado), una lista de precios,…

Como atributos de la clase Semáforo podríamos indicar su ubicación y estado (rojo, verde o ámbar).

La clase Persona podría definir como atributos el nombre, sexo, edad, estado civil, altura, etc.

A continuación pensemos en el comportamiento de estas clases. Preguntémonos qué cosas hacen, qué tipo de acciones pueden realizar.

Un coche puede arrancar, detenerse, girar a la izquierda, acelerar, frenar, encender sus luces. Un semáforo puede cambiar de estado. Un bar puede abrir, cerrar, servirte una cerveza, cobrarla, modificar la lista de precios. Una persona puede hablar, dormir, conducir un coche, tomarse una cerveza en un bar.

En terminología de la programación orientada a objetos, a estas funciones que determinan el comportamiento de una clase se las conoce como métodos.

Sabemos lo que es una clase y que está compuesta de atributos y métodos. Nuestra labor ahora consistirá en modelar en Java estas clases.

Modelar no es otra cosa sino crear una abstracción que represente de algún modo una determinada realidad.

Para crear en Java la clase Coche procederíamos del siguiente modo:

class Coche
{
}

Entre las llaves introduciremos los atributos y métodos de que consta la clase. Observa el uso de la palabra reservada class.

El nombre Coche lo escribimos con la primera letra en mayúsculas, pues es de común acuerdo entre los programadores en Java que los nombres de clases empiecen así.

Introduzcamos algunos atributos:

class Coche
{
  String marca;
  String modelo;
  String color;
  int numeroDePuertas;
  int cuentaKilometros;
  int velocidad;
  boolean arrancado;
}

Declarar atributos es algo similar a declarar una variable normal. El nombre del atributo se precede por su tipo. Así, en el ejemplo, tenemos tres atributos de tipo String que contendrán cadenas de caracteres; otros tres de tipo int para almacenar valores enteros; finalmente, el atributo arrancado, que utilizaremos para indicar si el coche está en marcha o no, es de tipo boolean, admitiendo como posibles valores true o false.

Los tipos int y boolean forman parte de los tipos básicos de Java, conocidos como tipos primitivos. Los presentaremos formalmente a su debido momento; por ahora es suficiente con que conozcas su existencia y cómo los utilizamos.

El tipo String, que escribimos con la primera letra en mayúsculas (lo que debería darte una pista), no es más que otra clase, como lo son las clases Coche y Persona. Es una clase muy importante en Java que encapsula un buen conjunto de métodos para trabajar con cadenas de caracteres.

El concepto importante que debes entender es que los atributos no necesariamente son siempre de tipos básicos, sino que también pueden ser de cualquier clase, incluso de una propia que nosotros mismos hayamos creado.

Por ejemplo, podríamos definir un nuevo atributo de la clase Coche, llamado conductor, en el que figure la persona (de tipo Persona) que lo conduce:

Persona conductor;

Fíjate también en la convención utilizada para nombres de variables compuestos de varias palabras. Se escriben todas juntas, pero iniciando cada palabra en mayúsculas, a excepción de la primera. Esto forma parte también del estilo de escritura Java. Es opcional, naturalmente.

Eso sí, ten siempre presente que Java distingue mayúsculas de minúsculas. No es lo mismo numeroDePuertas que numerodepuertas.

Definamos ahora los métodos de la clase Coche:


class Coche
{
  String marca;
  String modelo;
  String color;
  int numeroDePuertas;
  int cuentaKilometros;
  int velocidad;
  boolean arrancado;
  
  void arrancar()
  {
  }
  
  void parar()
  {
  }
  
  void acelerar()
  {
  }
  
  void frenar()
  {
  }

  void pitar()
  {
  }

  int consultarCuentaKilometros()
  {
  }
}

Vamos a comentar esto con cuidado…

El nombre de método viene seguido por un par de paréntesis, pues en ocasiones los métodos podrán recibir argumentos que luego se utilizarán en el cuerpo del método. Aunque el método no requiera argumentos los paréntesis son absolutamente necesarios.

Por otro lado, el nombre del método va precedido por el tipo del valor que devuelve. Hay que indicarlo incluso si el método no devuelve explicitamente ningún valor. Ese caso se indica con el tipo void.

Entre el par de llaves { } introduciremos el cuerpo del método, las instrucciones que indican su operatividad.

Escribamos algo de código básico en cada uno de ellos:

class Coche
{
  String marca;
  String modelo;
  String color;
  int numeroDePuertas;
  int cuentaKilometros;
  int velocidad;
  boolean arrancado;
  
  void arrancar()
  {
    arrancado = true;
  }
  
  void parar()
  {
    arrancado = false;
  }
  
  void acelerar()
  {
    velocidad = velocidad + 1;
  }
  
  void frenar()
  {
    velocidad = velocidad - 1;
  }
  
  void pitar()
  {
    System.out.println("Piiiiiiiiiiiiiiiiii");
  }

  int consultarCuentaKilometros()
  {
    return cuentaKilometros;
  }
}

Es prácticamente autoexplicativo: los métodos arrancar() y parar() establecen el atributo booleano arrancado a true y false, respectivamente. Los métodos acelerar() y frenar() incrementan y decrementan en una unidad, respectivamente, el atributo velocidad. El método pitar() imprime en consola una cadena de caracteres. El método consultarCuentaKilometros() devuelve a quien lo invoca (fíjate en el return) lo que contiene el atributo cuentaKilometros. Observa que es el único que devuelve explícitamente un valor (de tipo entero); los restantes, aunque algunos modifican los atributos de la misma clase, no devuelven ningún valor a quien los llama.

Podríamos modelar la clase Persona del siguiente modo:

class Persona
{
  char sexo;
  String nombre;
  int edad;
  Coche coche;   // El coche que conduce esa persona
  
  void saludar()
  {
    System.out.println("Hola, me llamo " + nombre);
  }
  
  void dormir()
  {
    System.out.println("Zzzzzzzzzzz");
  }
  
  int obtenerEdad()
  {
    return edad;
  }
}

Fíjate que uno de los atributos es precisamente de la clase Coche que acabamos de definir:

Coche coche;

No confundas el nombre del atributo (coche, en minúsculas), con el nombre de la clase (Coche, con la primera en mayúsculas). Recuerda, nuevamente, que para Java son identificadore distintos.

Te propongo como ejercicio que te entretengas modelando las otras clases, u otras de tu elección, para asentar estos conceptos.

Las entidades no tienen por qué ser tangibles, necesariamente. El siguiente código modela nuestras emociones:

class Emocion
{
  String emocion;
  
  String obtenerEmocion()
  {
    return emocion;
  }
  
  void cambiarEmocion(String nuevaEmocion)
  {
    emocion = nuevaEmocion;
  }
}

El método obtenerEmocion() devuelve a quien lo invoca la cadena de caracteres referenciada en el atributo emocion. El método cambiarEmocion(), que requiere como argumento una cadena de caracteres, se ocupa de modificar el atributo con el argumento facilitado.

Lo verdaderamente importante es que comprendas el concepto de clase. No te preocupes si te resultan quizás algo oscuros algunos de los ejemplos; oportunamente profundizaremos en todas estas cuestiones.

¿Qué hacemos con nuestras flamantes clases recien creadas?

Típicamente las almacenaremos, cada una, en su propio fichero .java.

Créate una carpeta común y vuelca en ella los ficheros Coche.java, Persona.java y Emocion.java.

Podemos compilarlas, todas a la vez, del siguiente modo:

javac *.java

Obteniendo, si no hay errores, los ficheros Coche.class, Persona.class y Emocion.class.

En el próximo artículo utilizaremos estas clases, momento en el que introduciremos otro concepto esencial, el de objeto.

Javier Montero Gabarró


Java: El concepto de clase


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos sobre Java.

Hola mundo, hola Java

lasecreObjetivo: escribir un primer programa en Java y verificar el entorno de compilación y ejecución.

Una vez instaladas las herramientas de desarrollo llega el momento sublime del rito de iniciación. Sea cual sea tu lenguaje de programación, si quieres que las cosas te vayan bien como programador necesitarás invocar a los dioses del código para que te insuflen el don del buen hacer, la inspiración algorítmica y la creatividad. Y esto sólo se logra de un modo: escribiendo un primer programa que imprima en pantalla el texto Hola mundo. Cualquier otra frase, una simple variación, y sería una apuesta segura hacia el fracaso.

Toma tu editor de texto plano favorito y escribe el siguiente código:

public class HolaMundo
{
  public static void main(String[] args)
  {
    System.out.println("Hola mundo");
  }
}

No te preocupes ahora si no comprendes su significado. La misión principal del primer programa no es otra sino la verificación de que nuestro entorno de desarrollo está correctamente instalado y conocer los rudimentos básicos de la compilación y ejecución en Java.

Si no puedes evitar trastear, presta atención a la instrucción

System.out.println("Hola mundo");

El texto que figure dentro de los paréntesis, rodeado entre comillas dobles, será, obviamente, el que aparecerá impreso.

Guarda el fichero y ponle de nombre HolaMundo.java

Es muy importante que el nombre del fichero coincida exactamente con el que aparece en la línea

public class HolaMundo

Cuando digo coincidencia exacta me estoy refiriendo también a las mayúsculas y minúsculas. Java distingue entre ambas y aunque a tu sistema operativo pueda no importarle el asunto, a Java sí.

Fíjate en la extensión del fichero. El código fuente en Java se almacena en ficheros con extensión .java

C:\javacode>dir
 El volumen de la unidad C no tiene etiqueta.
 El número de serie del volumen es: FC32-C34D

 Directorio de C:\javacode

14/03/2013  11:38    <DIR>          .
14/03/2013  11:38    <DIR>          ..
14/03/2013  11:50               117 HolaMundo.java
               1 archivos            117 bytes
               2 dirs  39.903.391.744 bytes libres

Para compilar el programa ejecutamos el comando

javac HolaMundo.java

Si todo va bien no te aparecerá ningún error:

C:\javacode>javac HolaMundo.java

C:\javacode>

En caso contrario se te mostrará un informe que te dará buenas pistas de lo que puede estar sucediendo. Típicamente será un error de sintaxis en el código fuente; asegúrate de que esté escrito tal cual aparece aquí. Otros errores comunes en la primera compilación son que no se encuentre el programa javac en el PATH de búsqueda (algo que explicamos en el artículo anterior), que la variable de entorno CLASSPATH no contenga el directorio actual (.), o que emplees codificación UTF-8 con BOM. Si te atascas tratando de resolver estos problemas, siéntete libre de dejar un comentario en el blog, por si puedo ayudarte.

Si todo va bien, un nuevo fichero habrá entrado en escena:

C:\javacode>dir
 El volumen de la unidad C no tiene etiqueta.
 El número de serie del volumen es: FC32-C34D

 Directorio de C:\javacode

14/03/2013  12:07    <DIR>          .
14/03/2013  12:07    <DIR>          ..
14/03/2013  12:07               422 HolaMundo.class
14/03/2013  12:06               114 HolaMundo.java
               2 archivos            536 bytes
               2 dirs  41.376.903.168 bytes libres

Menuda sorpresa… Tal vez esperabas encontrar un HolaMundo.exe; en su lugar te ha aparecido HolaMundo.class.

La compilación no nos ha generado código ejecutable directamente por el sistema operativo. En su lugar, aparece una suerte de código intermedio, denominado bytecode, que será ejecutado mediante una máquina virtual Java. En este esquema reside la clave de la portabilidad de Java, pues el bytecode es el independiente de la plataforma.

Para saludar al mundo y cumplir el guión del ritual, escribimos:

C:\javacode>java HolaMundo
Hola mundo

Observa que no es necesario indicar la extensión .class. De hecho, hacerlo provocaría un error.

Suelo decir que cuando uno hace funcionar un “Hola mundo”, ya tiene recorrida la mitad del camino aprendiendo un lenguaje. El resto será fácil…

Javier Montero Gabarró


Hola mundo, hola Java


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos sobre Java.

Instalación del Kit de Desarrollo Java (JDK) en Windows

lasecreObjetivo: instalar el kit de desarrollo Java (JDK) en una plataforma Windows.

De modo que te has decidido a aprender a programar en Java

Quizás haya sido porque se trate del lenguaje de programación más utilizado y, como programador, no quieras permanecer ajeno a la fiesta. Tal vez te haya atraído su extraordinaria portabilidad o la capacidad para desarrollar programas para cualquier plataforma.

O simplemente te fascina la programación orientada a objetos. En Java, al contrario de lo que sucede en otros lenguajes, las clases y los objetos no son una opción, algo de lo que te darás cuenta en cuanto escribamos el Hola mundo de rigor.

Sea lo que sea lo que te ha movido, celebro tu decisión.

El primer paso, naturalmente, consiste en preparar el entorno de desarrollo. En el artículo de hoy mostraremos cómo instalar el JDK (Java Development Kit) para la edición estándar de Java sobre una plataforma Windows. En un artículo posterior realizaremos la instalación en alguna máquina Linux.

El proceso es bien sencillo y casi anecdótico, como podrás comprobar.

Comenzamos accediendo a la página oficial de descarga, desde la cual descargaremos el JDK de Java SE 7u17, es decir, la versión 7, update 17 (la actual en el momento de escribir esto) de la edición estándar de Java.

jdk-install-1

Llegado a este punto tienes que tener muy clara la diferencia entre el JDK y el JRE. El JRE (Java Runtime Environment) contiene la máquina virtual Java, y es necesario para poder ejecutar aplicaciones creadas en Java. Pero, como programador, lo que necesitas es el kit de desarrollo, el JDK, que además incluye el propio JRE.

Haz clic, entonces, en alguno de los iconos que he rodeado con un círculo rojo (ambos apuntan al mismo destino) para acceder a la página que contiene los enlaces de descarga.

jdk-install-2

Acepta los términos de licencia de Oracle para que los enlaces se activen.

Elige la opción adecuada en función de si tienes un sistema de 32 o 64 bits.

jdk-install-3

La instalación es poco más que hacer doble clic sobre el instalador y aceptar las opciones por defecto:

Nota: las imágenes, de aquí en adelante, corresponden al Update 15, versión de Java existente en el momento en que fueron capturadas, pero la instalación del Update 17 es exactamente la misma.

jdk-install-4

Pulsa sobre Next y que empiece el show.

Para amenizarte el proceso, la instalación te recordará que 3 billones de dispositivos utilizan Java. Son billones anglosajones (1000 millones), no de los nuestros (un millón de millones), pero aún así puedes hacerte una idea del orden de magnitud del despliegue de Java en la actualidad.

jdk-install-7

Si no ha habido sorpresas, enhorabuena, tu kit de desarrollo Java estará instalado.

jdk-install-8

Vamos a asomarnos a la carpeta de instalación. Navega hasta Archivos de Programa | Java | jdk1.7.0_15 | bin , donde se encuentran los ejecutables.

jdk-install-9

El corazón del kit lo conforman los ficheros javac.exe, el compilador, y java.exe, la máquina virtual Java. Obsérvalos en la figura.

Por lo general hay dos formas de programar en Java: empleando un IDE (como Eclipse o NetBeans, de los que hablaremos a su debido momento) o a pelo, sin más que un editor de texto plano y la línea de comandos, que es como trabajaremos en los siguientes artículos.

Pero, para poder invocar el compilador desde cualquier lugar en la línea de comandos, es necesario que la carpeta bin de arriba figure en el PATH del sistema.

Para asegurarte que no cometes ningún error trascribiendo la ruta exacta, te recomiendo que te sitúes sobre la dirección, en la parte superior del explorador de windows, hagas clic con el botón derecho y elijas Copiar dirección como texto. De este modo la ruta se copiará al portapapeles dispuesta a que la agreguemos a la variable PATH.

Accede, a continuación al cuadro de diálogo Propiedades del sistema:

jdk-install-10

Hay varios modos de llegar a él. Por ejemplo, botón derecho sobre Equipo | Propiedades | Configuración avanzada del sistema.

Dentro de la pestaña Opciones avanzadas, pulsa sobre el botón Variables de entorno para acceder al cuadro de diálogo que nos permite editarlas.

jdk-install-11

En el cuadro Variables del sistema, localiza la variable Path, selecciónala y pulsa el botón Editar.

jdk-install-12

Desplázate al final, agrega un punto y coma como separador y pega a continuación el contenido del portapapeles, que contiene la ruta completa al compilador de Java.

jdk-install-13

Acepta todo lo que haya que aceptar y probemos nuestra instalación.

Abre un intérprete de comandos y ejecuta los comandos:

javac -version
java -version

jdk-install-14

Como ves, no sólo hemos verificado que el compilador y la máquina virtual se encuentran accesibles desde cualquier ubicación; además, comprobamos que las versiones son las correctas.

Ahora sí, ya estamos en condiciones de escribir nuestro primer programa en Java.

Javier Montero Gabarró


http://elclubdelautodidacta.es/wp/2013/03/instalacion-del-kit-de-desarrollo-java-jdk-en-windows/


El texto de este artículo se encuentra sometido a una licencia Creative Commons del tipo CC-BY-NC-ND (reconocimiento, no comercial, sin obra derivada, 3.0 unported)


El Club del Autodidacta


Índice completo de artículos sobre Java.