Mi tutorial de JAVA

[CompSystems]

Hola, inicie con mi autoaprendizaje de JAVA, la primer razón es crear interfaces graficas para el RASPBERRYPI, y como este puede cargar en LINUX Y WINDOWS entonces no tener que preocuparme por compilarlo para cada sistema operativo, un código en JAVA es multiplataforma y el lenguaje JAVA se esta convirtiendo el #1 entre todos los lenguajes, entonces porque no darle un espacio independiente en este foro (algún moderador por favor que lo realice), además deseo subir mi tutorial de JAVA en este nuevo espacio independiente a C, C++

Gracias

PD: Iniciando mi tutorial de JAVA, aportes etc todo es bienvenido

Programación informática en JAVA un enfoque matemático

El fin de la programación orientada a objetos es emular objetos de la vida real, se creó este tipo de lenguajes para dar solución a los nuevos desafíos de la programación informática.

Los lenguajes de alto nivel como C, operan sobre datos individuales,  y compuestos, pensar en objetos implica codificar siempre conjunto de datos agrupados, de ahora en adelante ya no pensamos en tipos de datos sino en conjunto de tipos de datos u objetos.

Un ejercicio de la vida real, graficar una función.

Sea la función lineal y = m*x+b, la gráfica de esta función es una línea recta, donde m  y b son parámetros (pendiente, e intersecto sobre el eje y) respectivamente, x es la variable independiente, y es la variable dependiente, la anterior función se puede expresar como y(x)= m*x+b o f(x)= m*x+b

Recordemos la definición de un parámetro y variable en algebra.
Parámetro, es un valor numérico o simbólico que para un caso particular de un problema no varía, podemos decir que es una constante.
Variable, también es un valor numérico o simbólico que aplicado en el mismo caso particular de un problema, difiere de un parámetro por que toma determinados valores en un dominio.

Ejercicio 1:
Graficar líneas rectas para los siguiente casos
1.A: pendiente 0, intersecto 2, x entre [0 5]
1.B: pendiente 4, intersecto 2 y -2, x entre [0 5]


Solución para el problema 1.A

Paso 1: definir identificadores para los parametros
m = 0
b = 2

Paso 2: Evaluar función y = m*x+b para obtener los puntos de graficacion
Tomando algunos valores entre 0 y 5

y= 0*1+2 -> 2
y= 0*2+2 -> 2
...

y= 0*5+2 -> 2

el resultado es
x   -5   -3   0   1   2   3   5
f1(x)   2   2   2   2   2   2   2

Según la tabla anterior los puntos resultantes son
p1 = (0,2)
p2 = (1,2)
p3 = (2,2)
p4 = (3,2)
p5 = (4,2)

Note que para todo valor de x, la función f(x) toma el valor de 2, es decir una línea recta paralela al eje x, y que se intersecta en y=2

Solución para el problema 1.B

Paso 1: definir identificadores para los parametros
m = 4
b = 2

Paso 2: Evaluar función y = m*x+b para obtener los puntos de graficacion
Tomando algunos valores entre 0 y 5

y= 4*0+2 -> 2
y= 4*1+2 -> 6
y= 4*2+2 -> 10
...
y= 4*5+2 -> 22

se obtienen los puntos
P1=(0,2)
P2=(1,6)
P3=(2,10)
P4=(3,14)
P5=(4,18)
P6=(5,22)

Ahora el ejercicio anterior codificado en JAVA, en JAVA aplicamos también los conceptos del algebra como función pero se denominan METODOS,
Un Método es similar a una función, requiere de un nombre identificador seguido de un paréntesis para contener los parámetros

Algebraicamente una función se expresa como f1(x)= expresionAlgebraica en JAVA
f1(x) { … } pero además requiere de unos prefijos, tipo de dato a retornar (entero, cadena, etc), acceso público, privado que se explicaran posteriormente
Entonces la función o mejor método se convierte en

public int f1(x) { … }

los objetos se deben plantear sobre una estructura llamada CLASE (class), requiere de un nombre identificador class y prefijos similar a la definición de un metodo

public class graficacion { ...  }


Continuara

[CompSystems]

//Codigo del primer ejercicio
//

Código: Java

1. package graficacion_linea_recta;
2.  
3. /**
4.  *
5.  * @author Compsystems Actualizado 25 Agosto del 2015
6.  */
7. public class graficacion_linea_recta {
8.  
9.     // 1: CAMPOS
10.     // Identificadores instancia de la clase
11.     int m; // parametro pendiente
12.     int b; // parametro intersecto
13.  
14.     // 2: CONSTRUCTOR
15.     // Función o método CONSTRUCTOR para inicializar los parámetros m y b
16.     graficacion_linea_recta(int pendiente, int intersecto) {
17.         m = pendiente;
18.         b = intersecto;
19.     }// fin de la función CONSTRUCTOR
20.  
21.     // 3: METODOS
22.     // para obtener las coordenadas de graficacion
23.     public void coordenadas() {
24.         int y; // variable dependiente de x, obtiene la coordenada Y para cada valor de x
25.         int x; // variable independiente x para contener un dominio por medio de un ciclo FOR
26.         System.out.println("Coordenadas Funcion f(x) = " + m + "* x + " + b );
27.         for (x = 0; x <= 5; x = x + 1) { // genera valores entre 0 y 5 en pasos de 1 para la variable x
28.             y = m * x + b; // calcula el valor de y
29.             System.out.println("P" + (x + 1) + "=(" + x + "," + y + ")"); // imprime la coordenada
30.         }
31.         System.out.println();
32.     } // fin de la función coordenadas
33.  
34.     // el metodo principal (MAIN) es llamado por el inteprete de JAVA, toma argumentos para almacenarlos en una STRING (cadena) de nombre args,
35.     // pero en este caso no se usan
36.     public static void main(String args[]) {
37.         // objeto 1
38.         graficacion_linea_recta y1 = new graficacion_linea_recta(0, 2); // crea un objeto y1 e inicializa los parámetros m y b
39.         // con pendiente m = 0, intersecto b=2
40.  
41.         y1.coordenadas();  // ejecuta el método coordenadas para el objeto y1, y muestra las coordenadas de graficacion
42.  
43.         // objeto 2
44.         graficacion_linea_recta y2 = new graficacion_linea_recta(4, 2);
45.         // con pendiente m = 4, intersecto b=2
46.  
47.         y2.coordenadas();
48.  
49.         // objeto 3
50.         graficacion_linea_recta y3 = new graficacion_linea_recta(4, -2);
51.         // con pendiente m = 4, intersecto b=-2
52.  
53.         y3.coordenadas();
54.  
55.     } // fin de la función principal MAIN
56.  
57. }// fin de la clase graficacion_linea_recta
58. //

Salida

run:
Coordenadas Funcion f(x) = 0* x + 2
P1=(0,2)
P2=(1,2)
P3=(2,2)
P4=(3,2)
P5=(4,2)
P6=(5,2)

Coordenadas Funcion f(x) = 4* x + 2
P1=(0,2)
P2=(1,6)
P3=(2,10)
P4=(3,14)
P5=(4,18)
P6=(5,22)

Coordenadas Funcion f(x) = 4* x + -2
P1=(0,-2)
P2=(1,2)
P3=(2,6)
P4=(3,10)
P5=(4,14)
P6=(5,18)

BUILD SUCCESSFUL (total time: 1 second)

[KILLERJC]

Yo jamas toque JAVA, por no tener la necesidad. Pero como todo lenguaje me interesa.
No se si un subforo de JAVA, pero si estaria bueno tener un espacio, y no que quede en ningun lugar, como ya hay otros subforos y este es el primer mensaje de JAVA que veo, podria moverse al de python y cambiarle el nombre al subforo para que entren ambos.

[CompSystems]

Estoy de acuerdo Python & JAVA como un solo foro, por favor mover este post a Python y renombrarlo, Gracias

Sobre el código anterior, Que os parece? trivial, difícil, es interesante el enfoque algebraico que les estoy dando?. casi todos los libros de programación y tutoriales inician con HOLA Mundo, clase que ni siquiera crea un objeto, solo hace uso del objeto STRING

PD: yo uso el compilador NetBeans https://netbeans.org/downloads/

[KILLERJC]

No me parece complejo a mi en la parte matematica por que estoy un poco acostumbrado. Aunque la explicacion al leerla no me parecio facil de interpretar, en el que uno que esta un poco perdido cuando vea tantos numeros se vuelva loco.

Con repecto a la programacion
Lo que si no se por que el crear "graficacion_linea_recta" que solo esa una asignacion de valores cuando podria haberlo realizado coordenadas().
Imagino que lo haces por que es un class, y no hacer una funcion simple y llamarla, y en este caso tampoco se por que hacer un class para esto xD. De todas formas es muy parecido al C/JS. Crei que iba a ser muy distinto.

Tal ves me estoy perdiendo algo. Y no se pueda hacer una funcion simple y llamarla como yo creo.

Tambien lo que noto es :

graficacion_linea_recta y2 = new graficacion_linea_recta(4, 2)

pense que podria hacerse sin esa parte en negrita.

Y bueno por ultimo no se el por que del package. Pero bueno esto desde afuera sin saber JAVA.

[CompSystems]

Hola KillerJC

La siguiente sentencia parece redundante a simple vista, PORQUE se muestra 2 veces la palabra graficacion_linea_recta . Esta una sentencia especial de DOBLE PROPOSITO creación del objeto Y1 y ejecución del constructor

Código: Java

1. graficacion_linea_recta y1 = new graficacion_linea_recta(0, 2);

LA PRIMERA palabra graficacion_linea_recta osea la que esta en el  lado izquierdo o antes del operador IGUAL es el tipo de dato para Y1, la segunda que esta en lado DERECHO es el constructor de la clase, que se debe llamar igual a ella de ahí la confusion

Resumen:
EL LADO IZQUIERDO debe tener un tipo de dato, en este caso seria OBJETO, al igual como lo hace C o C++
por ejemplo no podemos definir un dato solo con i = 6 requiere un prefijo int i=6,

También se observa que la parte derecha, después del operador de asignación = se necesita colocar NEW (NUEVO), además graficacion_linea_recta(0, 2) tiene dos parámetros, por esta razón hay que definir dentro de la clase un método o función extra que se llama CONSTRUCTOR con el mismo nombre de la clase, este tiene como fin inicializar de manera segura las variables de calculo que se desean GLOBALES,  podrían haberse definido dentro de coordenadas(),  pero es mejor separar la inicialización del algoritmo de calculo, además si estuvieran dentro de coordenadas(), no se las podría volver a llamar por que serian LOCALES dentro de este método o función

para ejecutar coordenadas() del objeto 1, 2 y 3 simplemente se usa el operador PUNTO

NombreDelOBJETO.coordenadas()

Código: Java

1. y1.coordenadas()

para el objeto llamado Y1

Código: Java

1. y2.coordenadas()

para el objeto Y2

Código: Java

1. y3.coordenadas()

para el objeto Y3
...

lo de package, lo agrega el compilador, aun no he llegado a esa parte

compilen el primer código y cualquier duda no duden en escribir

Nos vemos

[KILLERJC]

Yo un poco me confundi con JS, en el que recuerdo haber realizado:

Código: Javascript

1. var x5 = new Array();     // A new Array object

En C++, directamente

Nombre_de_clase Nombre_de_objeto;
Ejemplo clase rectangulo

Código: C++

1. Rectangulo Rect;
2. Rect.largo=10;

Y en python:

Código: Python

1. class Complex:
2.      def __init__(self, realpart, imagpart):
3.          self.r = realpart
4.          self.i = imagpart
5.  
6. x = Complex(3.0, -4.5)

Por eso me sorprendi al verlo asi.

[CompSystems]

Mejore la explicación anterior y continuo con el tutorial,
Para KILLERJC o algún forero, deseo por favor ver los códigos que escribo aca portados a C++, C# y Phython, claro esta en post paralelos para comparar tipos de codificación de lenguajes
Gracias


El código de la mayoría de las clases puede descomponerse en 2 partes principales
La parte externa de la clase tiene la forma
//

Código: Java

1. Public class NombreDeLaClase{
2. }
3. //

En la parte interna de la clase se definen tres partes principales, que por lo general siguen el siguiente orden
CAMPOS, CONSTRUCTORES luego METODOS
//

Código: Java

1. Public class NombreDeLaClase{
2. //CAMPOS
3. //CONSTRUCTORES
4. //METODOS
5. }
6. //

Los CAMPOS o también llamados identificadores instancia de la clase, almacenan datos para que cada objeto creado los use
Los CONSTRUCTORES hacen que los campos se asignen o tomen un ESTADO adecuado o razonable (inicialización), una vez haya sido creado el objeto
Los METODOS implementan el comportamiento de los objetos

Del ejemplo anterior seccionando cada parte
//  CAMPOS
//

Código: Java

1. public class graficacion_linea_recta {
2.  
3.     // 1: CAMPOS
4.     // Identificadores instancia de la clase
5.     int m; // parámetro: pendiente
6.     int b; // parámetro: intersecto
7.   // … se omite el resto del código
8. }// fin de la clase graficacion_linea_recta
9. //

Para CONSTRUCTORES
//

Código: Java

1. public class graficacion_linea_recta {
2.  
3.   // … se omite el código CAMPOS
4.     // 2: CONSTRUCTOR
5.     // Función o método CONSTRUCTOR para inicializar los parámetros m y b
6.     graficacion_linea_recta(int pendiente, int intersecto) {
7.         m = pendiente;
8.         b = intersecto;
9.     }// fin de la función CONSTRUCTOR  // … se omite el resto del código
10.  
11. }// fin de la clase graficacion_linea_recta
12. //

Para Funciones o METODOS
//

Código: Java

1. public class graficacion_linea_recta {
2.  
3.   // … se omite el código CAMPOS, y CONSTRUCTOR
4.  
5.     // 3: METODOS
6.     // para obtener las coordenadas de graficacion
7.     public void coordenadas() {
8.         int y; // variable dependiente de x, obtiene la coordenada Y para cada valor de x
9.         int x; // variable independiente x para contener un dominio por medio de un ciclo FOR
10.         System.out.println("Coordenadas Funcion f(x) = " + m + "* x + " + b );
11.         for (x = 0; x <= 5; x = x + 1) { // genera valores entre 0 y 5 en pasos de 1 para la variable x
12.             y = m * x + b; // calcula el valor de y
13.             System.out.println("P" + (x + 1) + "=(" + x + "," + y + ")"); // imprime la coordenada
14.         }
15.         System.out.println();
16.     } // fin de la función coordenadas
17.  
18.     public static void main(String args[]) {
19.         // objeto 1
20.         graficacion_linea_recta y1 = new graficacion_linea_recta(0, 2); // crea un objeto y1 e inicializa los parámetros m y b
21.         // con pendiente m = 0, intersecto b=2
22.  
23.         y1.coordenadas();  // ejecuta el método coordenadas para el objeto y1, y muestra las coordenadas de graficacion
24.  
25.         // objeto 2
26.         graficacion_linea_recta y2 = new graficacion_linea_recta(4, 2);
27.         // con pendiente m = 4, intersecto b=2
28.  
29.         y2.coordenadas();
30.  
31.         // objeto 3
32.         graficacion_linea_recta y3 = new graficacion_linea_recta(4, -2);
33.         // con pendiente m = 4, intersecto b=-2
34.  
35.         y3.coordenadas();
36.  
37.     } // fin de la función principal MAIN
38.  
39.  
40. }// fin de la clase graficacion_linea_recta
41. //

[CompSystems]

INICIALIZACION AUTOMATICA DE LOS CONSTRUCTORES

Si no se define una función o método CONSTRUCTOR, JAVA automáticamente asigna valores por defecto, 0 para el caso de los enteros, “” cadena vacia para STRING, etc


Comente del ejercicio 1 el METODO CONSTRUCTOR y dentro del METODO PRINCIPAL MAIN agregue un 4to objeto de la siguiente manera, (sin parametros)
//

Código: Java

1. // objeto 4
2.         graficacion_linea_recta y4 = new graficacion_linea_recta(); // sin parametros
3.         y4.coordenadas();//

la salida es

run:
Coordenadas Funcion f(x) = 0 * x + 0
P1=(0,0)
P2=(1,0)
P3=(2,0)
P4=(3,0)
P5=(4,0)
P6=(5,0)


note que m & b se inicializan en 0

[CompSystems]

OPERADOR THIS

veamos la siguiente porción de código del ejercicio1

Código: Java

1. // 1: CAMPOS
2.     // Identificadores instancia de la clase
3.     int m; // parametro pendiente
4.     int b; // parametro intersecto
5.  
6.  // 2: CONSTRUCTOR
7.     // Función o método CONSTRUCTOR para inicializar los parámetros m y b
8.     graficacion_linea_recta(int m, int b) {
9.         m = m;
10.         b = b;
11. }// fin de la función CONSTRUCTOR

Los parametrso del método graficacion_linea_recta(...) son m & b
para modificar o inicializar los CAMPOS m & b, habría un conflicto por que el compilador no podría decidir o interpretar la siguientes sentencias

        m = m;
        b = b;

para resolver este problema si se desea usar los mismos nombres ente CAMPOS y PARAMETROS, se antepone al identificador el operador .THIS a los identificadores que están el cuerpo del METODO

pruden comprobar cambiando la definicion del CONSTRUCTOR por la siguiente

Código: Java

1. // 2: CONSTRUCTOR
2.     // Función o método CONSTRUCTOR para inicializar los parámetros m y b
3.     graficacion_linea_recta(int m, int b) {
4.         this.m = m;
5.         this.b = b;
6. }// fin de la función CONSTRUCTOR

próximamente métodos GET (OBTENER) y SET (FIJAR, ASIGNAR)

[CompSystems]

La meta del ejercicio#1 es llegar a mostrar una ventana y graficar las funciones

Voy a colocar un 2do ejercicio donde solo se usa el METODO MAIN,, pero se llama a los OBJETOS y METODOS DE SISTEMA: IMPRESION DE SALIDA out.println(), LECTURA DE DATOS Scanner

Ejercicio#2 IMPRIMIR en pantalla la secuencia o sucesión FIBONACCI 1

1
2
3
5
8
13
21
34
...

https://es.wikipedia.org/wiki/Sucesi%C3%B3n_de_Fibonacci

//Codigo del 2do ejercicio
//

Código: Java

1. package sucesionfibonacci;
2.  
3. import java.util.*; // Para usar el flujo de entrada estándar System.in
4.  
5. /**
6.  *
7.  * @author Compsystems Actualizado 26 Agosto del 2015
8.  */
9. public class SucesionFibonacci {
10.     // 1: CAMPOS
11.  
12.     // 2: CONSTRUCTOR
13.     // 3: METODOS
14.     // METODO MAIN
15.     public static void main(String args[]) {
16.         // Definicion de variables Locales
17.         int numInferior = 1;
18.         int numSuperior = 1;
19.         int limSuperior; // el valor limite lo puede modificar el usuario
20.  
21.  
22.         // Se crea el objeto entrada, usando métodos de sistema
23.         Scanner entradaTeclado = new Scanner(System.in);
24.  
25.         // Obtiene por medio del teclado el valor superior limite de calculo
26.         System.out.println("Entre Valor limite aproximado: ");
27.         limSuperior = entradaTeclado.nextInt();  // la invocación nextInt espera un numero entero
28.  
29.         // Muestra el primer elemento de la sucesión
30.         System.out.println(numInferior);
31.  
32.         while (numSuperior <= limSuperior) {
33.             // Muestra el siguiente elemento de la sucesión
34.             System.out.println(numSuperior);
35.             // calculo del numero Superior
36.             numSuperior = numInferior + numSuperior;
37.             // calculo del numero Inferior
38.             numInferior = numSuperior - numInferior;
39.         } // fin While
40.         //
41.     } // fin de la función principal MAIN
42. }// fin de la clase SucesionFibonacci
43. //

//Entrada
Si el usuario digita 56
//Salida

run:
1
1
2
3
5
8
13
21
34
55
BUILD SUCCESSFUL (total time: 0.001 seconds)

si el usuario entra una expresión solo se toma el primer numero
ejemplo 56 60 70

la entrada se toma como 56

si el usuario entra una expresión que no sea un numero entero, se genera una excepción en tiempo de ejecución
ejemplo 56.1

Exception in thread "main" java.util.InputMismatchException

próximamente veremos que hacer cuando esto ocurra

[CompSystems]

Codigo con detección de error: entrada no valida por parte del usuario

//Codigo del 2do ejercicio
//

Código: Java

1. package sucesionfibonacci;
2.  
3. import java.util.*; // Para usar el flujo de entrada estándar System.in
4.  
5. /**
6.  *
7.  * @author Compsystems Actualizado 26 Agosto del 2015
8.  */
9. public class SucesionFibonacci {
10.     // 1: CAMPOS
11.  
12.     // 2: CONSTRUCTOR
13.     // 3: METODOS
14.     // METODO MAIN
15.     public static void main(String args[]) {
16.         // Definicion de variables Locales
17.         int numInferior = 1;
18.         int numSuperior = 1;
19.         int limSuperior = 1; // el valor limite lo puede modificar el usuario
20.         int ind_entradaValida = 0;
21.  
22.         // Se crea el objeto entrada, usando métodos de sistema
23.         Scanner entradaTeclado = new Scanner(System.in);
24.  
25.         // Obtiene por medio del teclado el valor superior limite de calculo
26.         System.out.println("Entre Valor limite aproximado: ");
27.         while (ind_entradaValida == 0) {
28.             try {
29.                 Thread.currentThread(); Thread.sleep(1000);//  PAUSA DE 1000ms
30.                 System.out.println("Entre Valor limite aproximado: ");
31.                 limSuperior = entradaTeclado.nextInt();  // la invocación nextInt espera un numero entero
32.                 ind_entradaValida = 1;
33.             } catch (Exception MensajeDeError) {
34.                 ind_entradaValida = 0;
35.             }
36.         }
37.         // Muestra el primer elemento de la sucesión
38.         System.out.println(numInferior);
39.  
40.         while (numSuperior <= limSuperior) {
41.             // Muestra el siguiente elemento de la sucesión
42.             System.out.println(numSuperior);
43.             // calculo del numero Superior
44.             numSuperior = numInferior + numSuperior;
45.             // calculo del numero Inferior
46.             numInferior = numSuperior - numInferior;
47.         } // fin While
48.         //
49.     } // fin de la función principal MAIN
50. }// fin de la clase SucesionFibonacci
51. //

El código anterior tiene una pequeña falla no se pausa para pedir un nuevo dato, creo que hay que replantear la solución para volver a pedir el dato, alguna sugerencia de como hacerlo?

[KILLERJC]

a que te referis con que no se pausa a pedir un nuevo dato ?

Código: Java

1. while (ind_entradaValida == 0) {
2.             try {
3.                 System.out.println("Entre Valor limite aproximado: ");
4.                 limSuperior = entradaTeclado.nextInt();
5.                 ind_entradaValida = 1;
6.                 entradaTeclado.next()
7.             }
8.             catch (Exception MensajeDeError) {
9.                 ind_entradaValida = 0;
10.             }
11.         }

Tal ves agregando esa linea ayude, aunque no estoy muy convencido de como se esta haciendo eso xD

[juaperser1]

No estoy siguiendo el hilo por no tener mucho tiempo, y este lo requiere, pero c# es uno de mis lenguajes que mejor manejo y java es muy parecido, es mas tuvieron un comienzo junto hasta que se separaron y microsoft lo llamo c#.

Por lo tanto de unirlo a algún foro lo dejaría en el de "c# y java", antes que "phyton y java" a no ser que los separemos en interpretados y compilados

Dicho esto, que excepción intentas capturar con ese try catch?

Yo creo que en la variable int se guardara el valor numérico de la tabla ASCII y no dará excepción, pero no estoy seguro de ello. Cual es la excepción que quieres capturar?

Un saludo

[KILLERJC]

Dicho esto, que excepción intentas capturar con ese try catch?

Yo creo que en la variable int se guardara el valor numérico de la tabla ASCII y no dará excepción, pero no estoy seguro de ello. Cual es la excepción que quieres capturar?

Te lo respondo yo.
Tu primer pregunta y segunda pregunta:

Throws:
InputMismatchException - if the next token does not match the Integer regular expression, or is out of range
NoSuchElementException - if input is exhausted
IllegalStateException - if this scanner is closed

Esta mas que claro el por que del try catch. aunque como dije yo lo hubiera realizado de otra forma con un while(!Scanner.hasNext()) De esa forma se pausa el programa por el Scanner.hasNext().

Código: [Seleccionar]

public boolean hasNext():

Finds and returns the next complete token from this scanner. A complete token is preceded and followed by input that matches the delimiter pattern. This method may block while waiting for input to scan, even if a previous invocation of hasNext() returned true.
Y luego preguntando si hay un entero

Código: [Seleccionar]

public boolean hasNextInt()
Returns true if the next token in this scanner's input can be interpreted as an int value in the default radix using the nextInt() method. The scanner does not advance past any input.

Con respecto a los problemas es como se maneja el buffer de entrada. Tenes que pensarlo como en un buffer FIFO.
Casi todos los del Scanner como .next() .nexLine() utilizan el demarcador de salto de linea \n (Enter)
Mientras que el .nextInt() no lo hace.

Por eso mismo si uno escribe

"10 20 35 80 \n pepito no hizo nada etc"

Si a esa entrada le haces un .nextInt creo que deberia salir:
10
el proximo nextInt
20
y cuando tire el 80 quedaria algo asi:
" \n pepito no hizo nada etc"
Ya no hay mas int por lo cual tiraria una excepcion.
Distinto es un next() que te devuelve TODO lo ingresado y un nextLine el cual te devolveria "10 20 35 80 " y dejaria en el buffer " pepito no hizo nada etc"

Entonces el trata primero de leer un .nextInt() con las siguientes posibilidades:
Buffer vacio - Excepcion
No hay un entero - Excepcion

Cuando podria preguntar primero si es que llego algo. o si es un entero para luego tambien poder agregar la opcion de "salir" del programa.
Por otro parte el nextInt como bien puse arriba no se bloquea para esperar un dato. Si no que intenta indefinidamente.

Ahora que veo crei que agregando el next() seria suficiente como para limpiar el buffer, y evitar esto pero no fue asi.

En fin. Esto es lo que entendi yo de como funciona el Scanner y la entrada de system
Con respecto al subforo, no lo pense en "compilado e interpretados" sino en popular el foro. ya que el foro de python tiene pocos hilos y si alguien mas aporta sobre JAVA va a auemntar y no tener miles de subforos con 5/6 hilos.