import java.util.Scanner;

public class guess {
    static final int N = 42;
    public static void main (String[] arg) {

    int h = 0;

    Scanner in = new Scanner(System.in);
    
    System.out.print ("Adivina en que número estoy pensando ? ");
    int v = in.nextInt();
    if (v < 0) {
        System.err.println ("Solo números positivos");
        return;
    }
        
    if (v == N)
        System.out.println ("Bien Hecho!");
    else {
        System.out.println ("Sigue Probabndo!");
        System.out.println ("El número es " + ((v < n) ? "MAYOR" : "MENOR"));

        // Como hemos fallado generamos una pista
        h = Math.abs (v - n);
        System.out.print ("PISTA : ");
        if      (h < 5)  System.out.println ("TE QUEMAS!!!");
        else if (h < 10) System.out.println ("CALIENTE");
        else if (h < 15) System.out.println ("TEMPLADO");
        else             System.out.println ("FRIO");
    }
  }
}

La versión java de nuestro pequeño programa es, sintácticamente hablando prácticamente igual que la versión C. Solo que un poco más Verbosa. La instrucción if toma la siguiente forma:

if (condicion) SentenciaTrue else SentenciaFalse

Donde una sentencia puede ser una única instrucción, o un bloque de instrucciones entre llaves, como ya sabemos.

Java ofrece un operador ternario con la sintaxis clásica utilizada por la mayoría de lenguajes que soportan este tipo de operador.

(condicion) ? expresionTrue : expresionFalse;

En este caso, el operador ternario no puede ser utilizado como una sentencia o instrucción y solo puede ser utilizado como expresión. Es decir, no podemos escribir expresiones como:

(a < 10) ? System.out.println ("MENOR") : System.out.println("MAYOR");

Java requiere que las variables se declaren antes de ser usadas, siguiendo el formato estándar de type variable [= valor], donde la asignación inicial de valores es opcional

Java ofrece una instrucción switch con el siguiente formato:

switch (val) {
  case CONTANTE1: instruccion1
  case CONTANTE2: instruccion2
  ...
}

En Java break puede ser usado para salir prematuramente de un caso y es necesaria para evitar que los casos definidos a continuación se ejecuten, y el caso default se ejecutará cuando ninguno de los otros casos se cumpla. En el ejemplo anterior, si val == CONSTANTE1 , la instruction1 e instruccion2 se ejecutarán. Para evitar ese comportamiento es necesario añadir una instrucción break al final de cada caso.

Versiones más modernas de Java han introducido mejorar en el comando switch:

• Java 8 permite utilizar Strings en los casos además de valores enteros.
• Java 14 introduce nuevas funcionalidades como: retornar valor usando yield o el operador -> y permitir casos con múltiples etiquetas, y termina los casos automáticamente sin necesidad de incluir la instrucción break. A partir de Java 14, la instrucción switch se puede utilizar como una expresión que devuelve parámetros.
• Java 17 añade las siguientes funciones adicionales: comprobar tipos, casos de guarda que nos permiten añadir condiciones adicionales en cada caso y condiciones nulas para lidiar con punteros null

A modo de ejemplo todas estas funcionalidades descritas arriba, en Java 17 se puede escribir código como el siguiente:

    //Integer v = new Integer(11);
    //String v = new String("Hola Mundo");
    //Boolean v = new Boolean (true);
    Object v = null;
    
    System.out.println (switch ((Object)v) {
      case Boolean i -> "Es un Booleano";
      case String  s -> "Es una cadena";
      case Integer i && ((i % 2) == 0) -> "Es un numero par";
      case null -> "Objeto no valido";
      default -> "No se de que me hablas";
      });

Java permite definir constantes utilizando las palabras clave static y final y puesto que son valores estáticos deben ser definidos como miembros de una clase, registro o interface. No podemos declarar una constante dentro de un método, aunque si podemos declarar una variable final dentro de un método que no puede ser modificada. Algo así como una constante local. Otra cosa es que eso pueda resultar útil en algún caso.

Como suele ser el caso, el convenio generar para nombrar constantes es utilizar letras mayúsculas y separar palabras usando el carácter _ (underscore). Por ejemplo:

class MiClase {
  static final int MI_CONSTANTE_GUAY = 42;
  static final double NUMERO_PI = 3.14159
  (...)
}

Dentro de la clase MiClase podemos usar la constante directamente, exactamente como lo hacemos en el código de ejemplo. Pero también podemos utilizar la constante desde otros módulos (a no ser que la declaremos privada dentro de la clase) de la siguiente forma:

System.out.println ("El valor de PI es : " + MiClase.NUMERO_PI);

Resumen

• Soporta if ... [else if] ...[else] ...
• Soporta operador terciario (cond) ? valor_Verdad : Valor_Falso
• Soporta booleanos nativamente
• Soporta switch
• No soporta constantes nativamente (con static y final )