Declaracion en una clase en Java

Declaración de la clase

Hay más de un modo para crear una clase desde el Package Explorer pero el modo más fácil es hacer clic derecho en el paquete que acaba de crear y elegir New > Class.... Verá el recuadro de diálogo New Class (Clase nueva).

En el recuadro de texto de Name escriba Person. Bajo ¿Qué resguardos de métodos le gustaría crear?, marque public static void main(String[] args). (Pronto verá por qué). Luego, haga clic en Finish.

La clase nueva aparece en su ventana de edición. Recomiendo cerrar algunas de las vistas de su aspecto predeterminado para que sea más fácil ver su código de origen, como se muestra en la Ilustración 5:

Ilustración 5. Un espacio de trabajo bien ordenado

Eclipse genera una clase de shell para usted e incluye la sentencia del paquete en la parte superior, junto con el método main() que usted pidió y los comentarios que ve. Ahora, solo necesita precisar la clase. Puede configurar cómo Eclipse genera clases nuevas por medio de Window > Preferences > Java > Code Style > Code Templates. Para simplificar, usted optará por la generación de código simple de instalar de Eclipse.

En la Ilustración 5, observe el asterisco (*) junto al nuevo archivo de código de origen, que indica que he hecho una modificación. Y observe que el código no está guardado. Luego, observe que he cometido un error cuando declaré el atribut Name: Declaré que el tipo de Name era Strin. El compilador no pudo encontrar una referencia para tal clase y la distinguió como un error de compilación (esa es la línea roja ondulada debajo de Strin). Por supuesto, puedo corregir mi error al agregar una g al final de Strin. Esto es solo una pequeña demostración del poder de un IDE sobre el uso de herramientas de líneas de comandos para el desarrollo de software.

Arreglos bidimensionales

Los arreglos bidimensionales son tablas de valores. Cada elemento de un arreglo bidimensional está simultáneamente en una fila y en una columna.

En matemáticas, a los arreglos bidimensionales se les llama matrices, y son muy utilizados en problemas de Ingeniería.

En un arreglo bidimensional, cada elemento tiene una posición que se identifica mediante dos índices: el de su fila y el de su columna.

Crear arreglos bidimensionales

Los arreglos bidimensionales también son provistos por NumPy, por lo que debemos comenzar importando las funciones de este módulo:

from numpy import *

Al igual que los arreglos de una dimensión, los arreglos bidimensionales también pueden ser creados usando la función array, pero pasando como argumentos una lista con las filas de la matriz:

a = array([[5.1, 7.4, 3.2, 9.9],
           [1.9, 6.8, 4.1, 2.3],
           [2.9, 6.4, 4.3, 1.4]])

Todas las filas deben ser del mismo largo, o si no ocurre un error de valor:

>>> array([[1], [2, 3]])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: setting an array element with a sequence.

Los arreglos tienen un atributo llamado shape, que es una tupla con los tamaños de cada dimensión. En el ejemplo, a es un arreglo de dos dimensiones que tiene tres filas y cuatro columnas:

>>> a.shape
(3, 4)

Los arreglos también tienen otro atributo llamado size que indica cuántos elementos tiene el arreglo:

>>> a.size
12

Por supuesto, el valor de a.size siempre es el producto de los elementos de a.shape.

Hay que tener cuidado con la función len, ya que no retorna el tamaño del arreglo, sino su cantidad de filas:

>>> len(a)
3

Las funciones zeros y ones también sirven para crear arreglos bidimensionales. En vez de pasarles como argumento un entero, hay que entregarles una tupla con las cantidades de filas y columnas que tendrá la matriz:

>>> zeros((3, 2))
array([[ 0.,  0.],
       [ 0.,  0.],
       [ 0.,  0.]])

>>> ones((2, 5))
array([[ 1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.]])

Lo mismo se cumple para muchas otras funciones que crean arreglos; por ejemplom la función random:

>>> from numpy.random import random
>>> random((5, 2))
array([[ 0.80177393,  0.46951148],
       [ 0.37728842,  0.72704627],
       [ 0.56237317,  0.3491332 ],
       [ 0.35710483,  0.44033758],
       [ 0.04107107,  0.47408363]])

Operaciones con arreglos bidimensionales

Al igual que los arreglos de una dimensión, las operaciones sobre las matrices se aplican término a término:

>>> a = array([[5, 1, 4],
...            [0, 3, 2]])
>>> b = array([[2, 3, -1],
...            [1, 0, 1]])

>>> a + 2
array([[7, 3, 6],
       [2, 5, 4]])

>>> a ** b
array([[25,  1,  0],
      [ 0,  1,  2]])

Cuando dos matrices aparecen en una operación, ambas deben tener exactamente la misma forma:

>>> a = array([[5, 1, 4],
...            [0, 3, 2]])
>>> b = array([[ 2,  3],
...            [-1,  1],
...            [ 0,  1]])
>>> a + b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: shape mismatch: objects cannot be broadcast to a single shape

Obtener elementos de un arreglo bidimensional

Para obtener un elemento de un arreglo, debe indicarse los índices de su fila i y su columna j mediante la sintaxis a[i, j]:

>>> a = array([[ 3.21,  5.33,  4.67,  6.41],
               [ 9.54,  0.30,  2.14,  6.57],
               [ 5.62,  0.54,  0.71,  2.56],
               [ 8.19,  2.12,  6.28,  8.76],
               [ 8.72,  1.47,  0.77,  8.78]])
>>> a[1, 2]
2.14

>>> a[4, 3]
8.78

>>> a[-1, -1]
8.78

>>> a[0, -1]
6.41

También se puede obtener secciones rectangulares del arreglo usando el operador de rebanado con los índices:

>>> a[2:3, 1:4]
array([[ 0.54,  0.71,  2.56]])

>>> a[1:4, 0:4]
array([[ 9.54,  0.3 ,  2.14,  6.57],
       [ 5.62,  0.54,  0.71,  2.56],
       [ 8.19,  2.12,  6.28,  8.76]])

>>> a[1:3, 2]
array([ 2.14,  0.71])

>>> a[0:4:2, 3:0:-1]
array([[ 6.41,  4.67,  5.33],
       [ 2.56,  0.71,  0.54]])

>>> a[::4, ::3]
array([[ 3.21,  6.41],
       [ 8.72,  8.78]])

Para obtener una fila completa, hay que indicar el índice de la fila, y poner : en el de las columnas (significa «desde el principio hasta el final»). Lo mismo para las columnas:

>>> a[2, :]
array([ 5.62,  0.54,  0.71,  2.56])

>>> a[:, 3]
array([ 6.41,  6.57,  2.56,  8.76,  8.78])

Note que el número de dimensiones es igual a la cantidad de rebanados que hay en los índices:

>>> a[2, 3]      # valor escalar (arreglo de cero dimensiones)
2.56

>>> a[2:3, 3]    # arreglo de una dimensión de 1 elemento
array([ 2.56])

>>> a[2:3, 3:4]  # arreglo de dos dimensiones de 1 x 1
array([[ 2.56]])

Otras operaciones

La trasposicion consiste en cambiar las filas por las columnas y viceversa. Para trasponer un arreglo, se usa el método transpose:

>>> a
array([[ 3.21,  5.33,  4.67,  6.41],
       [ 9.54,  0.3 ,  2.14,  6.57],
       [ 5.62,  0.54,  0.71,  2.56]])

>>> a.transpose()
array([[ 3.21,  9.54,  5.62],
       [ 5.33,  0.3 ,  0.54],
       [ 4.67,  2.14,  0.71],
       [ 6.41,  6.57,  2.56]])

El método reshape entrega un arreglo que tiene los mismos elementos pero otra forma. El parámetro de reshape es una tupla indicando la nueva forma del arreglo:

>>> a = arange(12)
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

>>> a.reshape((4, 3))
array([[ 0, 1, 2],
       [ 3, 4, 5],
       [ 6, 7, 8],
       [ 9, 10, 11]])

>>> a.reshape((2, 6))
array([[ 0, 1, 2, 3, 4, 5],
       [ 6, 7, 8, 9, 10, 11]])

La función diag aplicada a un arreglo bidimensional entrega la diagonal principal de la matriz (es decir, todos los elementos de la forma a[i, i]):

>>> a
array([[ 3.21,  5.33,  4.67,  6.41],
       [ 9.54,  0.3 ,  2.14,  6.57],
       [ 5.62,  0.54,  0.71,  2.56]])

>>> diag(a)
array([ 3.21,  0.3 ,  0.71])

Además, diag recibe un segundo parámetro opcional para indicar otra diagonal que se desee obtener. Las diagonales sobre la principal son positivas, y las que están bajo son negativas:

>>> diag(a, 2)
array([ 4.67,  6.57])
>>> diag(a, -1)
array([ 9.54,  0.54])

La misma función diag también cumple el rol inverso: al recibir un arreglo de una dimensión, retorna un arreglo bidimensional que tiene los elementos del parámetro en la diagonal:

>>> diag(arange(5))
array([[0, 0, 0, 0, 0],
       [0, 1, 0, 0, 0],
       [0, 0, 2, 0, 0],
       [0, 0, 0, 3, 0],
       [0, 0, 0, 0, 4]])

Reducciones por fila y por columna

Algunas operaciones pueden aplicarse tanto al arreglo completo como a todas las filas o a todas las columnas.

Por ejemplo, a.sum() entrega la suma de todos los elementos del arreglo. Además, se le puede pasar un parámetro para hacer que la operación se haga por filas o por columnas:

>>> a = array([[ 4.3,  2.9,  9.1,  0.1,  2. ],
...            [ 8. ,  4.5,  6.4,  6. ,  4.3],
...            [ 7.8,  3.1,  3.4,  7.8,  8.4],
...            [ 1.2,  1.5,  9. ,  6.3,  6.8],
...            [ 7.6,  9.2,  3.3,  0.9,  8.6],
...            [ 5.3,  6.7,  4.6,  5.3,  1.2],
...            [ 4.6,  9.1,  1.5,  3. ,  0.6]])
>>> a.sum()
174.4
>>> a.sum(0)
array([ 38.8,  37. ,  37.3,  29.4,  31.9])
>>> a.sum(1)
array([ 18.4,  29.2,  30.5,  24.8,  29.6,  23.1,  18.8])

El parámetro indica a lo largo de qué dimensión se hará la suma. El 0 significa «sumar a lo largo de las filas». Pero hay que tener cuidado, ¡por que lo que se obtiene son las sumas de las columnas! Del mismo modo, 1 significa «a lo largo de las columnas, y lo que se obtiene es el arreglo con las sumas de cada fila.

Las operaciones a.min() y a.max() funcionan del mismo modo:

>>> a.min()
0.1
>>> a.min(0)
array([ 1.2,  1.5,  1.5,  0.1,  0.6])
>>> a.min(1)
array([ 0.1,  4.3,  3.1,  1.2,  0.9,  1.2,  0.6])

a.argmin() y a.argmax() también:

>>> a.argmin(0)
array([3, 3, 6, 0, 6])
>>> a.argmin(1)
array([3, 4, 1, 0, 3, 4, 4

Arreglos unidimencionales

VARIABLES CON ÍNDICE O LOCALIZADOR. ARRAYS (ARREGLOS).

Vamos a repasar algunos conceptos que ya deberíamos conocer. Un array (arreglo) en Java es una estructura de datos que nos permite almacenar un conjunto de datos de un mismo tipo. El tamaño de los arrays se declara en un primer momento y no puede cambiar luego durante la ejecución del programa, como sí puede hacerse en otros lenguajes. Veremos ahora cómo declarar arrays estáticos de una dimensión.

ARRAYS UNIDIMENSIONALES

La sintaxis para declarar e inicializar un array será:

Tipo_de_variable[ ]   Nombre_del_array = new  Tipo_de_variable[dimensión];

También podemos alternativamente usar esta declaración:

Tipo_de_variable[ ] Nombre_del_array;   Nombre_del_array = new Tipo_de_variable[dimensión];

El tipo de variable puede ser cualquiera de los admitidos por Java y que ya hemos explicado. Ejemplos de declaración e inicialización con valores por defecto de arrays usando todos los tipos de variables Java, serían:

-        byte[ ] edad = new byte[4]; -        short[ ] edad = new short[4]; -        int[ ] edad = new int[4]; -        long[ ] edad = new long[4]; -        float[ ] estatura = new float[3]; -        double[ ] estatura = new double[3]; -        boolean[ ] estado = new boolean[5]; -        char[ ] sexo = new char[2]; -        String[ ] nombre = new String[2];

Aclarar que los valores por defecto son los siguientes:

a)      Para números el valor cero “0”.

b)      Para cadenas y letras el valor vacío.

c)       Para booleanos el valor false.

En caso de que queramos inicializarlos con valores propios, haremos esto:

Para números enteros

 int[ ] edad = {45, 23, 11, 9};  //Array de 4 elementos

De la misma forma procederíamos para los otros tipos de enteros : byte, short, long.

Para números reales

double[ ] estatura = {1.73, 1.67, 1.56}; //Array de 3 elementos

De la misma forma procederíamos para el tipo float, pero teniendo en cuenta que los números deberán llevar al final la letra “f” o “F”. Por ejemplo 1.73f o 1.73F.

Para cadenas

String[ ] nombre = {"María", "Gerson"};   //Array de 2 elementos

Para caracterers

char[ ] sexo = {'m', 'f'};   //Array de 2 elementos

Para booleanos

boolean[ ] = {true,false};    //Array de 2 elementos

Cuando creamos un array de nombre “a” y de dimensión “n” (int[ ] a = new int[n]) estamos creando n variables que son a[0], a[1], a[2], ..., a[n-1]. Los arrays se numeran desde el elemento cero, que sería el primer elemento, hasta el n-1 que sería el último elemento. Es decir, si tenemos un array de 5 elementos, el primer elemento sería el cero y el último elemento sería el 4.  Esto conviene tenerlo en cuenta porque puede dar lugar a alguna confusión. Disponer de un valor con índice cero puede ser de utilidad en situaciones como considerar cada variable asociada a una hora del día, empezando a contar desde la hora cero hasta la 23 (total de 24 horas), cosa que es habitual en algunos países. En lugar de 1, 2, 3, ..., 24 estaríamos usando 0, 1, 2, ..., 23.

Vamos a trabajarlo sobre el ordenador en un programa y ver qué pasaría si declaramos un array de tamaño “n” y vamos asignando un valor a cada variable del array desde la posición cero hasta la posición “n-1”. Adicionalmente vamos a comprobar qué ocurre si tratamos de asignarle valor a la variable de posición  “n”.

El código fuente del programa (escríbelo en BlueJ) es el siguiente:

/* Ejemplo uso Arrays – aprenderaprogramar.com */   public class ArrayDeNombres {        public static void main(String arg[ ]) {              String[ ] nombre = new String[4];              nombre[0] = "Luis";              nombre[1] = "María";              nombre[2] = "Carlos";              nombre[3] = "Jose";              nombre[4] = "Ismael";   //Error:No existe esta variable array de índice 4      }   }

Procedemos a la compilación del programa pulsando en el botón de Compile y después a su ejecución:

Obtenemos una respuesta (interpretación) que es la siguiente:

Una vez escrito el programa, cuando compilamos observamos que no hay ningún error de sintaxis, es decir, no faltan puntos y comas, las llaves están bien equilibradas, las palabras reservadas del lenguaje son las correctas, etc. Por tanto, aparentemente el programa debería ejecutarse y darnos un resultado. Sin embargo cuando cuando interpretamos el programa observamos un error “ArrayIndexOutBoundsException”. Este mensaje de error significa “desbordamiento de array”, es decir, que tratamos de acceder a una posición del array que no existe. En nuestro caso, hemos tratado de acceder a la posición 4, que no está definida (sólo se ha definido hasta la posición 3). En esto Java es muy estricto y no admite este tipo de error lógico del programador. Siguiendo el análisis del error que nos aparece en la ventana leemos lo siguiente “ArrayDeNombres.java:12”, que nos está indicando que el error está en el archivo que contiene el programa de nombre “ArrayDeNombres.java”, y más concretamente en la línea 12.

Ahora ampliaremos conocimientos con respecto a la instrucción public static void main(String arg[ ]). Esta instrucción es un estándar en Java, es decir, es la forma habitual de encabezar un programa que se ejecuta en consola. Ahora trataremos de entender un poco mejor el significado de este encabezado. Vamos a analizar el significado de (String arg[ ]). En esta instrucción el método main admite que se le pase un “array de Strings” cuando se proceda a la ejecución del programa si así lo deseamos. String arg[] significa “un array de Strings” cuyo nombre es arg. Dicho de otra manera, al ejecutar el programa podemos indicar “parámetros de entrada” de forma opcional. Si especificamos parámetros de entrada, éstos parámetros quedan asignados al array arg tomando el orden arg[0], arg[1].

Lo dicho podemos aclararlo mejor con el siguiente ejemplo:

El código fuente del programa es el siguiente. Escríbelo en el editor de BlueJ:

/* Ejemplo uso parámetros de entrada – aprenderaprogramar.com */      public class ParametrosDeEntrada {          public static void main(String arg[ ]) {               System.out.println(“Cantidad de parámetros : “ + arg.length);               System.out.println(arg[0]);               System.out.println(arg[1]);          }      }

Damos por entendido que ya hemos compilado el programa y no hay errores de sintaxis. Nos centramos por tanto en la ejecución del programa (interpretación).

Si hacemos click derecho sobre ParametrosDeEntrada y seleccionamos la opción void main(String arg[ ]) pasaremos a ejecutar el programa. En la ventana emergente pondremos lo siguiente: { "Pepe", "Luis", "Juan"} incluidos las llaves y las comillas dobles, los parámetros de entrada son Pepe, Luis y Juan. Cuando ejecutamos el programa se nos mostrará que la cantidad de parámetros son tres, y además nos mostrará el primer y segundo elementos del array, es decir, Pepe y Luis.

Si al ejecutar el método main de ParamentrosDeEntrada le pasaramos solo el parámetro “Pepe”, como solo hay un solo parámetro de entrada, el array arg tiene un solo elemento. En este caso el programa nos va a dar un error porque la única variable que existe es arg [0], y al tratar de llamar a arg[1] nos va a dar error.

Veamos ahora qué ocurre al ejecutar ParametrosDeEntrada con los parámetros "Hola" "Java":

Estos dos parámetros son las cadenas "Hola" y "Java", las cuales son capturadas en las variables del array de cadenas arg[0] y arg[1]. Estas variables se usan para imprimir los parámetros en pantalla. Esto se puede ver en el código fuente del programa. Por otro lado, con el atributo “arg.length” podemos saber cuántos parámetros se le han pasado a nuestro programa. También decir que hacemos uso de un nuevo símbolo: “+”, que significa “concatenar” la cadena “Cantidad de parámetros” con el valor del atributo arg.length (que es 2 en este caso). El resultado es la cadena “Cantidad de parámetros : 2 “, que se imprime en la ventana como parte de la salida de nuestro programa.

El introducir parámetros al mismo tiempo que se invoca la ejecución de un programa es una posibilidad que admite Java. En otros lenguajes no es posible pasar parámetros de entrada a un programa.

EJERCICIO 1

Crea un array numérico con 5 elementos. Los números de cada elemento deben ser valores pedidos por teclado al usuario. Muestra por consola el índice y el valor al que corresponde. Debes utiliza bucles tanto para pedir los valores de los elementos del array como para mostrar su contenido por pantalla.

Ejemplo: Introducimos los valores 2, 4, 5, 8 y 10 .Lo que se tiene que mostrar por consola  sería:

En el indice 0 esta el valor 2

En el indice 1 esta el valor 4

En el indice 2 esta el valor 5

En el indice 3 esta el valor 8

En el indice 4 esta el valor 10

Para comprobar si es correcta tu solución puedes consultar en los foros aprenderaprogramar.com

EJERCICIO 2

Crea un programa en el que se pida por consola el nombre de 2 alumnos y la nota de cada uno de ellos como valor numérico. El resultado que debe mostrarse es el nombre de cada alumno, su nota y su calificacion como texto (Sobresaliente, Notable, Bien o Suspenso).

Para ello crea un array numérico y otro de String (ambos unidimensionales). En el array numérico se insertarán las calificaciones facilitadas por el usuario entre 0 y 10 (debemos controlar que inserte una nota valida), pudiendo ser decimal. En el array de Strings se insertarán los nombres de los alumnos.

Crea también un array de String donde insertaremos el resultado de la nota con palabras admitiéndose estos valores: Sobresaliente, Notable, Bien o Suspenso.

El programa debe comprobar la nota de cada alumno teniendo en cuenta esta equivalencia:

Si la nota está entre 0 y 4,99 será un Suspenso.

Si la nota está entre 5 y 6,99 será un Bien.

Si la nota está entre 7 y 8,99 será un Notable.

Si la nota está entre 9 y 10 será un Sobresaliente.

Muestra por pantalla, el alumno su nota y su resultado en palabras utilizando bucles. Crea los métodos que creas convenientes. Puedes comprobar si tu código es correcto consultando en los foros aprenderaprogramar.com.

Nuevo Java 11

Hace justo un año Oracle lanzaba la esperadísima versión 9 de Java. Era la primera gran versión de la plataforma desde Java 8, aparecido más de cuatro años antes, en marzo de 2014. Lo cierto es que traía bastantes novedades, pero a pesar de ello muchas empresas todavía siguen usando Java 8 en sus desarrollos. Y es que el mundo Java tiende a moverse lento porque se utiliza sobre todo para aplicaciones de gestión y de backend en donde se prima la estabilidad por encima de todo.

El año pasado, con Java 9, Oracle se comprometió a lanzar una nueva versión de Java cada 6 meses, y de momento lo está cumpliendo aún a costa de que las nuevas versiones no traigan grandes novedades. En marzo de este año salió Java 10, sin apenas nada reseñable y que pasó sin pena ni gloria. Ahora lanzan Java 11. En esta ocasión, sin embargo, sí que viene con algo muy importante que deberíamos tener en cuenta si vamos a desarrollar: el cambio de licencia y el soporte a largo plazo asegurado para el JDK.

Cambios radicales: Kits de desarrollo de Java, licencias y precios
☕ De cero a Javero en 3 meses con nuestro curso online 👉 Infórmate aquí
Un Kit de desarrollo de software (SDK) de Java es lo que nos permite desarrollar con la plataforma Java. Incluye una implementación concreta del estándar de la plataforma, así como herramientas y compiladores. Oracle ofrece uno oficial llamado JDK. Aparte del de Oracle existen otros, siendo el más conocido el OpenJDK, la versión open source del kit de desarrollo, apoyada principalmente por la propia Oracle.

El JDK 11 inicia una nueva era en la licencia de uso. Hasta ahora podías descargar y programar con el Kit de Desarrollo de Java oficial de Oracle y luego poner tu aplicación en producción o distribuirla sin tener que pagar nada al gigante del software. Sin embargo, a partir de Java 11 y del JDK 11, aunque puedes seguir desarrollando con él, tendrás que pagar una licencia a Oracle si quieres utilizarlo para poner las aplicaciones en producción. El coste es de 2,5 dólares al mes por cada usuario de escritorio, y de 25 dólares por procesador en el caso de aplicaciones de servidor. Aquí tienes la lista de precios oficial.

Esto no afecta a versiones anteriores del JDK, por lo que si usas Java 8, 9 o 10 sigue siendo gratuito.

Además de la nueva licencia y el coste asociado, existe otra novedad: desde Java 9 Oracle se ha comprometido a sacar una nueva versión "mayor" de Java (y del JDK) cada 6 meses, con dos actualizaciones garantizadas entre ellas: una al mes del lanzamiento (la x.0.1) y otra al cabo de tres meses (la x.0.2). Después tendrás que actualizarte a la versión "mayor" siguiente, que sale a los 6 meses. Esto es un problema para muchas organizaciones puesto que un cambio de versión muchas veces supone problemas e inestabilidad. Es por eso que una gran mayoría de empresas sigue todavía con Java 8 a pesar de las nuevas versiones que han aparecido.

Bien, pues Java 11 es la primera versión de Java con un JDK denominado LTS o Long Term Support. Esto significa que Oracle garantiza que te dará soporte y actualizaciones para la versión durante 3 años, en lugar de tan solo 6 meses. Eso sí, a cambio de un "módico" precio (¿sabes cómo se lee "Oracle" del revés? Pues eso...).

Esto es muy interesante para las grandes empresas, porque se aseguran que tienen soporte y actualizaciones del JDK oficial durante bastante tiempo (aunque seguramente menos de lo que les gustaría), y no les importa pagar a Oracle por el privilegio del soporte y de las licencias de uso. Pero es un grave problema para los desarrolladores individuales y las empresas pequeñas.





¿Qué opciones tenemos?
Que no cunda el pánico. No es necesario que te quedes con el JDK 8 o 9 para no tener que pagar licencia, perdiéndote además las novedades que surjan en la plataforma. Además, es importante seguir avanzando...

Hasta hace poco, el OpenJDK era el patito feo de los SDKs de Java. El JDK oficial tenía más cosas, era más estable y además gratuito, por lo que el JDK siempre ha sido la opción por defecto para programar con Java.

Sin embargo, sabiendo los cambios de licencias que estaban preparando, Oracle ha trabajado muy duro para hacer que el OpenJDK se haya equiparado en todos los aspectos al JDK, hasta el punto de que se puede decir que el OpenJDK y el JDK son idénticos desde un punto de vista técnico, desde la versión 11.

Debido a ello, ahora el OpenJDK debería ser tu opción por defecto para programar en Java.

¿Cuál es la pega entonces? Nos pasamos al OpenJDK y punto ¿no?

Dos problemas... y sus soluciones
Fundamentalmente el uso del OpenJDK implica que tienes que lidiar con dos posibles problemas: las actualizaciones y el soporte.

En teoría, el OpenJDK seguirá la cadencia de lanzamientos que describíamos antes: una versión grande cada 6 meses con dos intermedias programadas. Si quieres soporte a más largo plazo, en teoría, no lo obtendrás y tendrás que ir subiendo de versión.

En cuanto al soporte tienes dos opciones:

Tratar de que te ayude, gratis, la comunidad del OpenJDK
Pagarle a alguien para que te dé soporte comercial (aunque Oracle no es la única opción (tienes a IBM o a Redhat que también lo dan), sí es la fuente y la que la mayor parte de las empresas usarán)
Esto puede ser un problema para algunas empresas, sobre todo si buscan estabilidad, y es a lo que juega Oracle con su JDK: ¿quieres soporte y actualizaciones a largo plazo? Pues paga.

Por suerte, siempre suele haber solución para casi todo.

En primer lugar, la comunidad de OpenJDK está hablando de que habrá al menos actualizaciones públicas de cada versión durante 4 años (más incluso que el LTS del JDK). Lo malo es que eso incluye tan solo el código fuente, y si queremos el producto final (clases base, herramientas, compiladores...) tendríamos que compilarlo nosotros mismos, lo cual no siempre es fácil, y mucho menos directo. Por suerte existe una comunidad dentro de OpenJDK llamada AdoptOpenJDK cuyo objetivo es precisamente facilitar el uso de este proporcionando versiones compiladas del OpenJDK para descarga y usos directos. A través de este proyecto podemos descargar cualquier versión del OpenJDK compilado para su uso en múltiples sistemas operativos. ¡Genial!

En cuanto al soporte... eso es harina de otro costal. O pagamos por él o tendremos que confiar en la comunidad. Por suerte es una comunidad grande y fuerte, y con los cambios de licencia de Java 11 aún lo será más, así que no deberíamos tener problema. Por otro lado, Stackoverflow es tu mejor amigo, ya sabes...

En resumen
Con Java 11 se inaugura una nueva era en la plataforma Java. Ahora el JDK ya no es gratuito y deberás pagar una licencia mensual por usuario o por procesador si quieres usarlo en producción. Además, el soporte técnico también es de pago y si lo quieres a largo plazo (3 años). Java 11 de hecho es la primera versión LTS (soporte a largo plazo) oficial de la plataforma Java.

Esto no significa que Java deje de ser gratuito, ni es una gran tragedia para la plataforma tampoco. Para la mayoría de desarrolladores y empresas no habrá una gran diferencia. El desarrollo se trasladará a OpenJDK (que ahora es equiparable al JDK) en lugar de al tradicional JDK de Oracle, y el soporte se obtendrá de la comunidad. Para ciertas grandes empresas y administraciones, el hecho de pagar no les importará y de hecho será una ventaja porque tendrán garantizada la estabilidad y el soporte directo de Oracle durante unos años.

Aún así Java sigue y seguirá siendo el lenguaje más popular del mundo, y el que más puestos de trabajo genera, así que merece la pena aprenderlo bien.

¡Ya estás tardando en actualizar tus herramientas de desarrollo Java y el SDK subyacente para usar OpenJDK!

¡Ah!, y por cierto, si te preguntas qué novedades hay de verdad en la plataforma... quitando la palabra clave var (copiada descaradamente de C#), el nuevo recolector de basura y el "Flight Recorder" el framework para recopilar datos para diagnosticar aplicaciones, poco hay que contar...



Referencias
Java is Still Free por Java Champions (Google Docs)
No free Java LTS Version? por Nicolai Parlog
Time to look beyond Oracle's JDK por Stephen Colebourne
Oracle Java SE Support Roadmap por Oracle
Oracle JDK Releases for Java 11 and Later por Donald Smith (Oracle)
All You Need To Know For Migrating To Java 11 por Nicolai Parlog
A Quick Summary on the new Java SE Subscription por Donald Smith (Oracle)
Oracle Java SE Subscription FAQ

¿Cómo puedo descargar e instalar Java en un equipo con Windows de forma manual?

Este artículo se aplica a:

• Plataformas: Windows 2008 Server, Windows 7, Windows 8, Windows XP, Windows Server 2012, Windows Vista, Windows 10
• Versiones de Java: 7.0, 8.0

---

El procedimiento de instalación de Java consiste, a grandes rasgos, en:

1. Descargar e instalar
2. Probar la instalación

» Requisitos del sistema Windows

Nota: la instalación de Java necesita que pueda acceder a Windows como administrador en su computadora.

---

Descarga e instalación

Se recomienda, antes de proceder con la instalación en línea, desactivar el cortafuegos de Internet. En algunos casos, la configuración del cortafuegos predeterminado se establece para rechazar todas las instalaciones automáticas o en línea, como la instalación en línea de Java. Si el cortafuegos no se configura correctamente, podría impedir la operación de descarga/instalación de Java en determinadas circunstancias. Consulte las instrucciones del manual específico del cortafuegos de Internet para desactivarlo.

• Vaya a la página de descarga del manual.
• Haga clic en Windows en línea.
• Aparecerá el cuadro de diálogo Descarga de archivos y le pedirá que ejecute o guarde el archivo descargado
  • Para ejecutar el instalador, haga clic en Ejecutar.
  • Para guardar el archivo y ejecutarlo más tarde, haga clic en Guardar.
    Seleccione la ubicación de la carpeta y guarde el archivo en el sistema local.
    Sugerencia: guarde el archivo en una ubicación conocida de su equipo; por ejemplo, en el escritorio.
    Haga doble clic en el archivo guardado para iniciar el proceso de instalación.

• Se iniciará el proceso de instalación. Haga clic en el botón Instalar para aceptar los términos de la licencia y continuar con la instalación.
  
• Oracle colabora con empresas que ofrecen distintos productos. Es posible que el instalador le ofrezca la opción de instalar estos programas como parte de la instalación de Java. Una vez seleccionados los programas que desee, haga clic en el botón Siguiente para proseguir con el proceso de instalación.
• Se abrirán varios cuadros de diálogo con información para completar las últimas etapas del proceso de instalación; haga clic en Cerrar en el último cuadro de diálogo. Con esta acción se completará el proceso de instalación de Java.
  

Notificaciones sobre Java desactivado y restauración de peticiones de datos

Installer le notifica si el contenido de Java está desactivado en los exploradores web y proporciona instrucciones para activarlo. Si había elegido ocultar algunas peticiones de datos de seguridad para applets y aplicaciones de Java Web Start, Installer ofrece una opción para restaurar las peticiones de datos. Puede que el instalador le pida reiniciar la computadora si, cuando se le solicitó, optó por no reiniciar el explorador de Internet.

---

Probar la instalación

Para comprobar que Java se ha instalado y funciona correctamente en el equipo, ejecute este applet de prueba.

NOTA: quizá deba reiniciar (cerrar y abrir) su navegador para habilitar la instalación de Java en su navegador.