¿Qué viene con Java 9?

¿Qué viene con Java 9?

Java 9 está avanzando hacia su disponibilidad general (23 de marzo de 2017). JDK committers están trabajando duro para entregar porque la cuenta regresiva ha comenzado.

Java Enhancement Proposals (JEP) ha publicado una larga lista de características como sus propuestas de mejora. Incluye muchas mejoras importantes / menores en la forma de nuevas capacidades, cambios sintácticos, ajustes de rendimiento y la modularidad muy esperada.

Estas mejoras pronto traerán algunos cambios notables en la forma en que programamos en Java. Este artículo recoge diez áreas clave del índice JEP que van a influir en los programadores Java en los próximos años.

1. Característica principal: Proyecto Jigsaw

Si lambda es una característica insignia de Java 8, la modularidad es la característica insignia de Java 9. La modularidad es el resultado de la gran influencia de Project Jigsaw. Es realmente una característica diferida que se suponía que iba a incluirse desde Java 8, pero tuvo un adelanto con Java 9. Se espera que cambie el paradigma de la codificación Java en el mantenimiento de problemas de dependencia popularmente llamado infierno jar, algo que rima con DLL infierno. Aunque Maven ha proporcionado un cierto respiro, se prevé que el proyecto Jigsaw será la respuesta principal a la tan necesaria capacidad de Java. Mantener una dependencia transitiva en una aplicación es y siempre ha sido un dolor en el cuello. Java 9 comprenderá mejor la dependencia entre módulos y los resolverá en tiempo de compilación o tiempo de ejecución. Según JEP, el objetivo principal de esta función es:

• Mejorar la escalabilidad de la plataforma Java SE y JDK hasta los pequeños dispositivos informáticos
• Mejorar la seguridad y la facilidad de mantenimiento
• Proporcionar fácil construcción y mantenimiento de bibliotecas
• La mejora tendrá un impacto general en las plataformas Java SE y Java EE.

2. Actualizaciones de la API de proceso (JEP 102)

Otra mejora importante se puede ver con las API que se ocupan de controlar y organizar los procesos del sistema operativo. Hasta Java 8, este había sido un área descuidada y el soporte de Java API era bastante limitado. Los programadores tuvieron que recurrir a códigos nativos para manejar muchas de las características principales del sistema operativo subyacente. Las nuevas APIs brindarán un apoyo considerable en esta área.

3. Imágenes multi-resolución (JEP 251)

La API que trata con imágenes en el paquete java.awt.image también se actualiza. La mejora de la API permitirá que un conjunto de imágenes se encapsule en una única imagen multi-resolución. La varianza de la resolución se puede recuperar basándose en métricas DPI y un conjunto de API de transformación de imagen.

4. API de apilamiento (JEP 259)

Java 8 no tiene ninguna API eficaz para recorrer marcos seleccionados en la pila de ejecución y para acceder a la instancia de Clase de cada trama. El nuevo stack-walking APIs nos permitirá filtrar y perezosamente cargar la información en trazas de pila.

5. API y servicio de registro (JEP 264)

Java 9 mejoró la infraestructura de registro utilizada por las clases JDK con la ayuda de las nuevas API de Service Loader. Hasta ahora (Java 8), las clases JDK utilizan su propia infraestructura de registro. Con Java 9, tendremos la opción de usar la implementación de registro por defecto basada en los mensajes de registro de plataforma java.util.logging o de ruta en el marco de registro, como SLF4J o Log4J.

6. Actualizaciones lingüísticas (JEP 213)

Hay muchos pequeños ajustes introducidos con las sintaxis del lenguaje Java 9, aparte de mejorar las capacidades de las interfaces. Una interfaz Java 9 puede declarar métodos privados, manteniendo intacta la característica del método predeterminado introducido por Java 8. La sintaxis de la sentencia try-with-resource se ha mejorado. Las sintaxis con clase anónima ahora pueden inferir su tipo designado. Otras mejoras incluidas en el área como anotación @SafeVarargs, sintaxis obsoletas, y así sucesivamente.

7. Actualizaciones simultáneas (JEP 266)

Las actualizaciones de concurrencia son mínimas y se supone que son una respuesta en apoyo de la red de suscripción pública de Reactive System. Un puñado de interfaces se proporciona, que puede ayudar a los desarrolladores a construir componentes personalizados para apoyar la interoperabilidad a través de varios sistemas asíncronos que se ejecutan en JVM.

8. Métodos de fábrica para las colecciones (JEP 269)

Java 9 hizo cambios importantes en el proceso de creación de una colección ad-hoc con la ayuda del método estático de fábrica. Esto funcionará en la interfaz de Colección para crear una instancia de colección no modificable. Java 8 y sus predecesores habían sido muy detallados incluso en la creación de una lista simple, de la siguiente manera:

List<String> list1 = new ArrayList<>();
list1.add("Uno");
list1.add("Dos");
list1.add("Tres");
list1 = Collections.unmodifiableList(list1);

Alternativa,

List<String> list2 = Collections.unmodifiableList(new ArrayList<> (Arrays.asList("Cuatro", "Cinco", "Seis")));

O,

List<String> list3 =
Collections.unmodifiableList(new ArrayList<String>() {
{
   add("Siete");
   add("Ocho");
   add("Nueve");
   add("Diez");
}});

Con Java 9, podremos lograr lo mismo con el método simple de fábrica de ayuda, de la siguiente manera:

List<String> list4=List.of("Once", "Doce", "trece");

9. Características del escritorio (JEP 272)

Java 9 introduce una API para soportar la manipulación de características de escritorio específicas de la plataforma. Las plataformas específicas son Windows, Linux y Mac OS X. Las API públicas permitirán a los programadores interactuar con la barra de tareas o la base de acoplamiento, o escuchar sistemas o eventos de aplicaciones.

10. Mejoramiento del Proceso de Serialización (JEP 290)

Ha habido críticas sobre el mecanismo de serialización de objetos implementado convencionalmente por el marco principal de la JVM. La transmisión de datos es una tarea de serialización y puede verse comprometida, lo que a su vez puede hacer que la propia JVM sea vulnerable. Java 9 parece tener en cuenta el problema y proporciona una especie de mecanismo de filtrado en los flujos entrantes para mejorar la seguridad y robustez del sistema existente de los procesos de serialización y deserialización.

Conclusión

Aparte de estos diez, hay muchos otros ajustes y mejoras a ser servido una vez que la característica completa Java 9 se libera. Otras áreas de mejoras están en el ámbito de API de bajo nivel, redes, XML, API de análisis de Nashorn, extensiones de API existentes, jshell, etc. Se han eliminado muchas API antiguas de la biblioteca principal. Además, la estructura de archivos JDK 9 también ha sido renovada. Java 8 y sus usuarios anteriores de la versión encontrarán algo nuevo derecho del directorio de la instalación. Sin embargo, nada nos tranquiliza hasta que vemos la versión final. Hasta entonces, esperamos la cuenta final.

El uso de JSTL para mejorar la funcionalidad JSP

JSTL significa JavaServer Pages Standard Tag Library; se proporciona un conjunto de funciones básicas de la página Web que se pueden realizar muchas de las tareas básicas, tales como condicional e iteraciones de elementos estructurales, la manipulación de documentos XML y soporte para etiquetas de internacionalización a un procesamiento más sofisticado de los elementos de SQL. JSP es mejor conocido por scriplets, sin embargo, no es nada recomendable desde el inicio de JSTL y EL (Expression Language). La razón es que scriplet elemento dentro de JSP viola muchos de los principios básicos de buenas prácticas de ingeniería. El artículo profundiza en algunos de los aspectos clave de JSTL que ponen de relieve la conveniencia de usarla por scriplets.

Problemas del uso de elementos de Scripting en JSP
Mira en algunos de los problemas que surgen debido a los elementos de script (por escrito dentro de los <% ...%>). Hay demasiados. Vamos a obtener una visión general de algunas de ellas y el resto se puede deducir muy fácilmente.

Reutilización: Los scriplets incrustados dentro de JSP no pueden ser reutilizados. Como resultado, utilizando características de la tecnología orientada a objetos, tales como la herencia, la composición y la asociación es totalmente inaplicable. Además, no hay manera de hacer un extracto scriplet. El efecto secundario es la repetición del mismo código en múltiples lugares, una práctica altamente inaceptable en la programación orientada a objetos.
Depuración: Esta es una de las áreas oscuras. Intenta depurar una página JSP con scriplets salpicados ornamental esparcidos a través de algunas de las esquinas sin importancia de las etiquetas HTML. Es decir, si no se ha encontrado como archivo, déjeme decirle que es muy fácil de crear uno, al menos en JSP. Depurarlo. Ahora la parte difícil; no golpear su cabeza. Cualquier excepción lanzada en medio camino tthrough el código da una página en blanco, un rollo vacío para crear su propio significado fuera de él.

Capacidad de mantenimiento: Bueno, algo que es contrario a la reusabilidad con la capacidad de depuración horrendo, que está fuera de la cuestión. códigos desordenados, destrozados, y duplicados son difícilmente mantenible.
Sin embargo, unos sencillos dentro scriplets JSP es una marca de conveniencia, pero aún dentro de la lógica de negocio escrito scriplets JSP es una estricta no-no, no porque no se puede escribir, sino porque es un mal presagio (difícil de mantener). La convención de código JSP 1.2 Especificación recomienda el uso de la biblioteca de etiquetas JSP estándar en la aplicación Web. Sería de gran ayuda a reducir la necesidad de scriptlets JSP en páginas JSP. Las páginas que usan JSTL son, en general, más fácil de leer y mantener. Se refieren a la Convención de código para JSP .... Aparte de JSTL, hay otras maneras de superar algunos de los problemas antes mencionados, tales como el uso de componentes de frijol Java para escribir la lógica de negocio, y así sucesivamente. Pero, vamos, renunciar a los detalles y se adhieren a lo que JSTL tiene que ofrecer.

Visión general de JSTL

etiquetas JSTL se pueden agrupar en cinco categorías. Cada uno de ellos se puede utilizar para un propósito específico. Por ejemplo:

tagsare Core utilizado para la programación de propósito general en una página JSP, como se presentan elementos de cadena, sentencias condicionales, iteración, y redirigir a una nueva URL. La sintaxis para incluir la biblioteca central es:

<% @ Taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core"%>

Formateo de tagsare particularmente útil para la internacionalización, además de dar formato al texto, fecha, hora y números. La sintaxis para incluir la biblioteca es:

<% @ Taglib prefix = "FMT" uri = "http://java.sun.com/jsp/jstl/fmt"%>

SQL tagscan ser utilizado para todas las operaciones CRUD cuando se trata de bases de datos relacionales. La sintaxis para incluir la biblioteca es:

<% @ Taglib prefix = "sql" uri = "http://java.sun.com/jsp/jstl/sql"%>

tagsare XML útil para manipular documentos XML tales como análisis y transformación de datos XML. La sintaxis para incluir la biblioteca es:

<% @ Taglib prefix = "x" uri = "http://java.sun.com/jsp/jstl/xml"%>

funciones JSTL proporcionan numerosas etiquetas para el procesamiento de cadenas. La sintaxis para incluir la biblioteca es:

<% @ Taglib prefix = "Fn" uri = "http://java.sun.com/jsp/jstl/functions"%>

Explorar la API de Java para el procesamiento de JSON

JSON, acrónimo de JavaScript Object Notation, es un formato de intercambio de datos independiente lenguaje basado en texto, estándar abierto, que se utiliza principalmente para serializar / deserializar y transmitir datos a través de una conexión de red. JSON puede tener muchos otros usos también. Sin embargo, en el ámbito del intercambio de datos, realiza funciones similares como XML. Java ya tiene soporte para la API para XML, JSON y pronto cogió interés. Java EE 7 abrazó a la biblioteca y estandarizada gran parte de su funcionalidad a través de Java Specification Request (JSR) 353. Sin embargo, incluso antes de la incorporación de este núcleo, hubo varias bibliotecas de terceros para procesar, transformar, serializar / deserializar o generar datos JSON , como JSON-lib, fastjson, Flexjson, Jettison, Jackson, y así sucesivamente. Cada uno tiene sus usos menores escenario diferente. Así, Java realidad nunca le faltó el apoyo para el procesamiento de JSON. Pero aquí, nuestro interés específico se encuentra en el grupo de la API del núcleo.

JSON y XML

Cuando hablamos de JSON, una pregunta viene a la mente: ¿Es mejor que XML? En vista del sistema de intercambio de datos, que parecen desempeñar funciones similares. Pueden ser similares, pero no son el mismo. De hecho, sus características no son comparables en absoluto en función de su originalidad. JSON es puramente un formato de datos. Es excelente para el intercambio de datos donde la legibilidad para los seres humanos, así como máquinas es la principal preocupación. Ahora bien, ¿qué significa esto legibilidad a una máquina? Los servidores web y los datos de cambio de páginas web, ¿verdad? JavaScript es rica en la lógica de la página Web de procesamiento. La mayoría de las páginas web se construyen en él. JSON (JavaScript Object Notation) está cerca de JavaScript; esto significa que las páginas web que utilizan JavaScript pueden consumir fácilmente los datos que figuran en formato JSON. XML, por otro lado, es un extranjero poco cuando JavaScript consumabilidad se refiere y requiere análisis críptico. Además, sintácticamente JSON utiliza un menor número de caracteres para representar los datos. Esto hace que el tamaño de datos pequeño y compacto. Por ejemplo, en un tipo de elemento JSON (String / Número / JSON anidada de objetos) se puede inferir sintácticamente. Esto disminuye el esfuerzo del analizador para darse cuenta de que la identificación es un número y firstName una cadena. A simple código JavaScript para ilustrar la idea es la siguiente:

obj1=JSON.parse(jsonObj1);
obj1.id==102;   // true
"Rica"      // true

Las expresiones regulares de Java - Tutorial con ejemplos

Las expresiones regulares se utilizan para definir patrones de cadena que se pueden utilizar para la búsqueda, la manipulación y edición de un texto.


Estas expresiones también se conocen como expresiones regulares (forma corta de expresiones regulares).


Vamos a tomar un ejemplo para entenderlo mejor:


En el siguiente ejemplo, la expresión regular. * Libro. * Se utiliza para buscar la ocurrencia de cadena "libro" en el texto.

import java.util.regex.*;  
class RegexEjemplo1{  
   public static void main(String args[]){  
      String content1 = "Este es Pedro " +
   "de holalibro.com.";

      String pattern = ".*libro.*";

      boolean esMatch = Pattern.matches(pattern, content1);
      System.out.println("El texto contiene 'libro'? " + esMatch);
   }
}  

Salida:

El texto contiene 'libro'? true

En este tutorial vamos a aprender a definir los patrones y la forma de utilizarlos. La API java.util.regex (el paquete que tenemos que importar al tratar con expresiones regulares) tiene dos clases principales:


1) java.util.regex.Pattern - Se utiliza para definir los patrones

2) java.util.regex.Matcher - Se utiliza para realizar operaciones de los partidos en los patrones de texto usando


java.util.regex.Pattern clase:

1) Pattern.matches ()

Ya hemos visto el uso de este método en el ejemplo anterior, donde se realizó la búsqueda de la cadena "libro" en un texto dado. Este es uno de los más simple y más fácil de buscar una cadena en un texto usando expresiones regulares.

String content1 = "Este es un tutorial!";
String patternCadena = ".*tutorial.*";
boolean esMatch = Pattern.matches(patternCadena, content1);
System.out.println("El texto contiene 'tutorial'? " + esMatch);

Como se puede ver, tenemos método de clase de patrón coincide utilizados () para buscar el patrón en el texto dado. El patrón. * Tutorial. * Permite cero o más caracteres al principio y al final de la "tutorial" String (la expresión. * Se utiliza para cero y más caracteres).

Limitaciones: De esta manera podemos buscar una sola aparición de un patrón en un texto. Para hacer coincidir múltiples ocurrencias se debe utilizar el método Pattern.compile () (discutido en la siguiente sección).

2) Pattern.compile ()

En el ejemplo anterior se realizaron búsquedas en una cadena "tutorial" en el texto, que es una búsqueda sensible caso, sin embargo, si usted quiere hacer una búsqueda que ignore o quiere hacer buscar múltiples ocurrencias entonces puede que tenga que compilar primero el patrón utilizando el patrón .compile () antes de buscar en el texto. Así es como este método se puede utilizar para este caso.

String content1 = "Este es un tutorial!";
String patternCadena = ".*tutoRiAl.";
Pattern pattern1 = Pattern.compile(patternCadena, Pattern.CASE_INSENSITIVE);

Aquí hemos utilizado un Pattern.CASE_INSENSITIVE bandera para búsqueda que ignore, hay varias otras banderas que se pueden utilizar para diferentes 2-fines.

Ahora lo que: Hemos obtenido una instancia del patrón, sino cómo hacerlo coincidir? Para que iba a necesitar una instancia Matcher, que podemos obtener mediante el método Pattern.matcher (). Vamos a discutir él.

3) Método de Pattern.matcher ()

En la sección anterior hemos aprendido cómo obtener una instancia de patrón mediante el método compile (). Aquí vamos a aprender cómo conseguir ejemplo Matcher de instancia de patrón mediante el método de coincidencias ().

String content1 = "Este es un tutorial!";
String patternCadena = ".*tutoRiAl.*";
Pattern pattern1 = Pattern.compile(patternCadena, Pattern.CASE_INSENSITIVE);
Matcher matcher1 = pattern1.matcher(content1);
boolean esMatched = matcher1.matches();
System.out.println("Este matchea?" + esMatched);

Salida:

Este matchea? true

4) Pattern.split ()

Para dividir un texto en varias cadenas basadas en un delimitador (delimitador Aquí se especifica el uso de expresiones regulares), podemos utilizar el método Pattern.split (). Esta es la forma en que puede hacerse.

import java.util.regex.*;  
class RegexEjemplo2{  
public static void main(String args[]){  
String texto1 = "EsteEsPedro.EsteEsMiEjemplo";
    // Pattern for delimiter
String patternCadena = "Es";
Pattern pattern1 = Pattern.compile(patternCadena, Pattern.CASE_INSENSITIVE);
String[] misCadenas = pattern1.split(texto1);
for(String temp1: misCadenas){
   System.out.println(temp1);
}
System.out.println("Cantidad de cadenas: "+misCadenas.length);
}}

Salida:

te
Pedro.
te
MiEjemplo
Cantidad de cadenas: 4


Clase java.util.regex.Matcher

Ya hemos discutido poco sobre la clase Matcher anteriormente. Vamos a recordar algunas cosas:

Creación de una instancia Matcher

String content1 = "Algun texto";
String patternCadena = ".*algunascadenas.*";
Pattern pattern1 = Pattern.compile(patternCadena);
Matcher matcher1 = pattern1.matcher(content1);

Principales métodos

matches(): Coincide con la expresión regular en contra de todo el texto se pasa al método Pattern.matcher () al crear instancia Matcher.

Matcher matcher1 = pattern1.matcher(content1);
boolean esMatch = matcher1.matches();

lookingAt(): Similar al método matches(), excepto que coincida con la expresión regular sólo contra el principio del texto, mientras que los partidos () de búsqueda en todo el texto: lookingat ().

find(): busca las ocurrencias de las expresiones regulares en el texto. Se utiliza principalmente cuando estamos en busca de múltiples ocurrencias.

start() y al end(): Ambos métodos se utilizan generalmente junto con el método find (). Se utilizan para obtener los índices de inicio y final de un partido que se encontró método find () usando.

Vamos a tomar un ejemplo para descubrir las múltiples ocurrencias utilizando métodos Matcher:

package hola.com;
import java.util.regex.*;  
class RegexEjemploMatcher{  
public static void main(String args[]){  
  String content1 = "ZZZ JJ PP JJ QQQ JJJ ZZ";

  String cadena = "JJ";
  Pattern pattern1 = Pattern.compile(cadena);
  Matcher matcher1 = pattern.matcher(contenido);

  while(matcher1.find()) {
     System.out.println("Encontrado en: "+ matcher1.start()
    + 
    " - " + matcher1.end());
  }
}
}

Salida:

Encontrado en: 4 - 6
Encontrado en: 10 - 12
Encontrado en: 17 - 19

Ahora estamos familiarizados con el modelo y la clase Matcher y el proceso de búsqueda de una expresión regular en contra del texto. Vamos a ver qué tipo de varias opciones que tenemos para definir una expresión regular:

1) Los literales de cadena

Digamos lo que desea es buscar una cadena en particular en el texto de ejemplo "Abc" entonces simplemente puede escribir el código como este: Aquí el texto y expresiones regulares ambos son iguales.
Pattern.matches ( "abc", "abc")

2) Clases de caracteres

Una clase de caracteres coincide con un único carácter en el texto de entrada contra múltiples caracteres permitidos en la clase de caracteres. Por ejemplo [CC] asandra coincidiría con todas las ocurrencias de "Casandra" cadena, ya sea con minúsculas o mayúsculas C ". Algunos ejemplos más:
Pattern.matches ( "[]" PQR, "ABCD"); Sería dar un falso ya que no p, q o r en el texto
Pattern.matches ( "[PQR]", "r"); Devuelve verdadero como se encuentra r
Pattern.matches ( "[PQR]", "pq"); Return false como uno cualquiera de ellos puede estar en texto no tanto.

Esta es la lista completa de las diversas clases de personajes construye:
[ABC]: Sería coincida con el texto si el texto está teniendo cualquiera de ellos (a, b, c) y sólo una vez.
[^ Abc]: Cualquier carácter excepto a, b, oc (^ denota negación)
[A-zA-Z]: A a la Z, o la A a la Z, ambos inclusive (rango)
[A-d [m-p]]: A a la D, o m p a través de: [a-dm-p] (unión)
[A-z && [def]]: Cualquiera de ellos (d, e, o f)
[A-z && [^ bc]]: a través de z, a excepción de b y c: [ad-z] (sustracción)
[A-z && [^ m-p]]: A a la Z, y no a través de m p: [a-LQ-z] (sustracción)

Clases de caracteres predefinidos - Metacaracteres

Estos son como los códigos de acceso que se pueden utilizar al escribir expresiones regulares.

Construir          Descripción
.                ->      Cualquier carácter (puede o no coincidir con las terminaciones de línea)
\D            ->      Un dígito: [0-9]
\D            ->      A no dígito: [^ 0-9]
\S            ->       Un espacio en blanco: [\ t \ n \ x0B \ f \ r]
\S            ->       A no está en blanco: [^ \ s]
\W           ->      Un carácter de palabra: [a-zA-Z_0-9]
\W           ->      Un carácter no-palabra: [^ \ w]

Por Ejemplo:

Pattern.matches ("\\d", "1"); volvería verdadera
Pattern.matches ("\\D", "z"); return true
Pattern.matches (".P", "qp"); de vuelta verdad, no (.) representa cualquier carácter

Comparadores de limites

^   Coincide con el comienzo de una línea.
$   Coincidencias entonces el final de una línea.
\b  Coincide con un límite de palabra.
\B  Coincide con un límite de palabra.
\A  Coincide con el comienzo del texto de entrada.
\G  Coincidir el final del partido anterior
\Z   Coincidir el final del texto de entrada, excepto el terminador final, si los hubiere.
\z   Coincidir el final del texto de entrada.

Por Ejemplo:

Pattern.matches("^Hola$", "Hola"): de vuelta verdad, comienza y termina con Hola
Pattern.matches("^Hola$", "Prueba! Hola"): Retorna false, no comienza con Hola
Pattern.matches("^Hola$", "Hola Prueba!"): Retorna false, no termina con Hola

Enum de Java tutorial con ejemplos

Una enumeración es un tipo especial de tipo de datos que es básicamente una colección (conjunto) de las constantes. En este tutorial vamos a aprender a utilizar las enumeraciones en Java y cuáles son los posibles escenarios en los que podemos utilizar.

Esta es la forma en que definimos Enum:

public enum Direcciones{
  EAST, 
  WEST, 
  NORTH, 
  SOUTH
}

Aquí tenemos una variable de tipo de enumeración llegar, que es una colección de cuatro constantes de este, oeste, norte y sur.

Cómo asignar valor a un tipo de enumeración?

Direcciones dir = Direcciones.NORTH;

El dir variable es de tipo Direcciones (que es un tipo de enumeración). Esta variable puede tomar cualquier valor, de los posibles cuatro valores (este, oeste, norte, sur). En este caso se establece en el norte.

El uso de tipos Enum en declaraciones if-else

Se trata de cómo podemos utilizar una variable de enumeración en una lógica if-else.


Direcciones dir = Direcciones.NORTH;  

if(dir == Direcciones.EAST) {

} else if(dir == Direcciones.WEST) {
    
  } else if(dir == Direcciones.NORTH) {
    
    } else {
      
      }

Ejemplo de enumeración

Esto es sólo un ejemplo para demostrar las enumeraciones de uso. Si usted entiende la parte central y básico, que sería capaz de escribir su propia lógica basado en el requisito.

public enum Direcciones{
 EAST, 
 WEST, 
 NORTH, 
 SOUTH
}
public class EnumDemostracion
{
   public static void main(String args[]){
Direcciones dir = Direcciones.NORTH;  
if(dir == Direcciones.EAST) {
   System.out.println("Direccion: East");
} else if(dir == Direcciones.WEST) {
   System.out.println("Direccion: West");
 } else if(dir == Direcciones.NORTH) {
     System.out.println("Direccion: North");
     } else {
System.out.println("Direccion: South");
     }
   }
}

Salida:

Direccion: Norte

El uso de Enumeración de declaraciones switch de los casos

Aquí está el ejemplo para demostrar el uso de las enumeraciones en declaraciones switch-case.

public enum Direcciones{
 EAST, 
 WEST, 
 NORTH, 
 SOUTH
}
public class EnumDemostracion
{
   Direcciones dir;
   public EnumDemostracion(Direcciones dir) {
      this.dir = dir;
   }
   public void getMiDireccion() {
     switch (dir) {
       case EAST:
          System.out.println("East Direccion");
          break;
                    
       case WEST:
          System.out.println("West Direccion");
          break;
                         
       case NORTH: 
          System.out.println("North Direccion");
          break;
                        
       default:
          System.out.println("South Direccion");
          break;
     }
   }
    
    public static void main(String[] args) {
        EnumDemostracion obj1 = new EnumDemostracion(Direcciones.EAST);
        obj1.getMiDireccion();
        EnumDemostracion obj2 = new EnumDemostracion(Direcciones.SOUTH);
        obj2.getMiDireccion();
    }
}

Salida:

East Direccion
South Direccion

Cómo iterar a través de una variable de enumeración

class EnumDemostracion
{
    public static void main(String[] args) {
    for (Direcciones dir : Direcciones.values()) {
       System.out.println(dir);
    }
    }
}

Este código mostraría todas las cuatro constantes.

Hola Mundo en Java

Hola amigos bienvenidos al blog de Java, hoy vamos a ver un ejemplo básico:


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


Como podemos ver esta es la estructura básica de un programa java

Primero nombramos la clase "Hello" después dentro ponemos el método main y allí podemos poner las sentencias que necesitemos en este caso una impresión de "Hola Mundo".

EJEMPLO DE CLASE CON CAMPOS, CONSTRUCTOR Y MÉTODOS

La palabra clave this tiene distintos usos en Java y en general podríamos interpretarla como este objecto.
La invocación this o this(parámetros) que es la invocación al constructor que coincida con los parámetros que se pasan para que se ejecute.
Al igual que existen formas de invocar a métodos, existen formas de invocar a constructores, y a continuacion una de ellas.

public class Deposito {    

    //La forma de crear campos de la clase
    private float diametro;
    private float altura;
    private String idDeposito;

    //Constructor por default sin parámetros auxiliar
    public Deposito () { //Lo que hace es llamar al constructor con parámetros pasándole valores vacíos
        this(0,0,"");            } //Cierre del constructor


    //Constructor de la clase que pide los parámetros necesarios para crear objetos
    public Deposito (float valor_diametro, float valor_altura, String valor_idDeposito) {
        if (valor_diametro > 0 && valor_altura > 0) {            
            diametro = valor_diametro;
            altura = valor_altura;
            idDeposito = valor_idDeposito;
        } else {
            diametro = 10;
            altura = 5;
            idDeposito = "000";
            System.out.println ("Creado depósito con valores por defecto diametro 10 metros altura 5 metros id 000" );
        }   } //Cierre del constructor

    
    //Creacion de metodo
    public void setValoresDeposito (String valor_idDeposito, float valor_diametro, float valor_altura) {
        idDeposito = valor_idDeposito;
        diametro = valor_diametro;
        altura = valor_altura;
        if (idDeposito !="" && valor_diametro > 0 && valor_altura > 0) {
        } else {
            System.out.println ("Valores no admisibles. No se han establecido valores para el depósito");
            //Deposito (0.0f, 0.0f, ""); Esto no es posible. Un constructor no es un método y por tanto no podemos llamarlo
            idDeposito = "";
            diametro = 0;
            altura = 0;
        }     } //Cierre del método

    public float getDiametro () { return diametro; } //Método de acceso
    public float getAltura () { return altura; } //Método de acceso
    public String getIdDeposito () { return idDeposito; } //Método de acceso
    public float valorCapacidad () { //Método tipo función
        float capacidad;
        float pi = 3.1416f; //Si no incluimos la f el compilador considera que 3.1416 es double
        capacidad = pi * (diametro/2) * (diametro/2) * altura;
        return capacidad;
    }    
} //Cierre de la clase