Fecha y hora actual: Jueves 22 Ago 2019 13:16
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Lección 63: Salida y entrada estándar en Java.

Responder al Tema

Índice del Foro > Programación en general > Lección 63: Salida y entrada estándar en Java.

Autor Mensaje
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Jueves 19 Jul 2012 21:19

Título del mensaje: Lección 63: Salida y entrada estándar en Java.

Responder citando

Salida estándar básica

Hemos visto el clásico “Hola mundo” en Java y con él se nos han venido encima un montón de cosas. Además da la sensación de que eso de main es complicado y que el System.out también. ¿Por qué no hay un simple WriteString o WriteLn y ya? Además hay un montón de palabras raras que todavía no sabemos que son: public, static, void… Bien, todo se irá aclarando de a poco a medida que avancemos. Por el momento tendremos interrogantes que se quedarán colgadas porque no tengo forma de explicarlas sin irme a temas más avanzados. Es por este motivo que no pasé de Pascal a Java directamente.

Bien, vimos que los programas en Java en vez de módulos tienen clases. Las clases no tienen archivos DEF ni MOD sino que se crean en un archivo CLASS que por suerte NetBeans lo hace solito. Todo el código fuente está en un solo archivo así que nos olvidamos de eso de tener un archivo de definición y otro de implementación, todo está en un solo lugar para Java.
También vimos que, como un programa puede tener muchas clases, tiene que haber una que sea la principal para que el programa tenga un punto de partida al ejecutarse. Esta clase se diferenciará de las demás porque tendrá dentro de sí un procedimiento llamado main declarado sí o sí de esta manera:

Código:
  1. public static void main(String[] args)


Dentro de este procedimiento irán las líneas de código fuente de ejecución del programa tal como sucedía en Modula 2 con el módulo principal.
Sabemos ya que al igual que en Modula, los literales de Strings van entre comillas dobles y que NetBeans los pinta en color naranja. La salida estándar está representada por System.out los cuales tienen para nosotros varios procedimientos y funciones útiles. De momento solo usaremos print y println.

En Pascal, cuando comenzamos con Write y WriteLn hicimos un ejemplo que mostraba el texto

Código:
Hice mi primer programa en Pascal.
Logré el clásico “Hola Mundo”

El código fuente en Pascal para mostrar esta salida era:

Código:
  1. WriteLn(‘Hice mi primer programa en Pascal.’);
  2. Write(‘Logré el clásico “Hola Mundo”.’);


En Java sería así:

Código:
  1. System.out.println(“Hice mi primer programa en Java.”);
  2. System.out.print(“Logré el clásico Hola Mundo.”);


Como ven no hay diferencia. Lo único es que si ustedes corren el código Pascal y el código Java las salidas serán diferentes ya que el de Pascal mostrará las comillas en “Hola Mundo” y el de Java no lo hará. Es decir, tendremos esto en la salida de Pascal:

Código:
Hice mi primer programa en Pascal.
Logré el clásico “Hola Mundo”.


y esto en la salida de Java:

Código:
Hice mi primer programa en Java.
Logré el clásico Hola Mundo.


Ya veremos cómo colocar esas comillas en la salida estándar de Java, ya que no es simplemente agregarlas. Esto es porque las comillas dobles en Java, al igual que en Modula 2, abren y cierran los literales de Strings, por eso si agregamos más comillas en nuestro argumento de print tendremos un error de sintaxis que NetBeans subrayará en rojo.

-------------------------------------------------------------------------------------

Secuencias de escape:

Justamente por el problema que señalé recién con las comillas y por otros tantos, además de lograr simplificarnos varias cosas, Java nos provee de ciertos caracteres especiales para utilizar en los literales de Strings. Como primer ejemplo veremos como lograr la misma salida anterior en una sola línea de código:

Código:
  1. System.out.print(“Hice mi primer programa en Java.\nLogré el clásico Hola Mundo.”);


Verán que solo hay un System.out.print. Sin embargo si ustedes corren ese programa saldrá el texto en dos líneas, tal como si hubiera usado println y print como en el ejemplo anterior. Si prestan atención, justo donde hay un salto de línea en la salida estándar tenemos en nuestro literal el símbolo \n. Este símbolo representa justamente el fin de línea. De este modo este código

Código:
  1. System.out.println("Hola Mundo");


puede ser sustituido por

Código:
  1. System.out.print("Hola Mundo\n");


La barra diagonal inversa (\) se conoce como carácter de escape. Esta barra indica a print y a println que se va a imprimir un carácter especial, de modo que dicho carácter va justo luego de la barra. En este caso, la n minúscula indica que lo que se quiere imprimir es un salto de línea. De esta manera, si yo quiero que salga en pantalla este texto:

Código:
He logrado crear
mi primer programa
en el lenguaje Java.


podemos hacerlo con éste código.

Código:
  1. System.out.println(“He logrado crear”);
  2. System.out.println(“mi primer programa”);
  3. System.out.println(“en el lenguaje Java.”);



o bien podemos hacerlo con este código

Código:
  1. System.out.print(“He logrado crear\nmi primer programa\nen el lenguaje Java.”);


Es importante que quede claro que cada vez que dentro de un literal escribimos \n imprimiremos un salto de línea.

Para imprimir las comillas dobles tenemos la secuencia de escape \”. De este modo para lograr aquella salida que queríamos fuera igual que en Pascal el código fuente sería:

Código:
  1. System.out.println(“Hice mi primer programa en Java.”);
  2. System.out.print(“Logré el clásico \”Hola Mundo\”.”);


Así, cada vez que usamos \” Java imprime comillas dobles (“) en pantalla.
Tenemos un total de cinco secuencias de escape:

• \n Nueva línea. Imprime un carácter de fin de línea, o sea, baja el cursor una línea.
• \t Tabulación. Imprime una tabulación horizonal.
• \r Retorno de carro. Vuelve el cursor al inicio de la línea actual. Todo lo que se imprima allí sobreescribirá a los caracteres que ya estaban impresos.
• \\ Barra inversa. Imprime una barra inversa (\) en la salida.
• \” Doble comilla. Imprime comillas dobles (“) en la salida.

===============================================


Entrada estándar e introducción a las variables en Java:

Hemos visto la salida estándar en Java, lo cual, si lo analizan un poco, no es más que lo que ya usábamos en Pascal y es además bastante más simple que en Modula 2 ya que no tenemos que importar nada y podemos imprimir todo en una sola línea de código. Ahora bien, la entrada estándar no es algo tan sencillo porque Java no nos provee (dada su forma de funcionar) de un procedimiento o función que directamente lea lo que hemos escrito en consola, es decir, no tenemos un READ o READLN.

¿Cómo logramos leer algo de la entrada estándar entonces? Pues bien, tenemos que importarnos una clase llamada Scanner y crearnos un objeto de esa clase. Como ven, ya tenemos programación orientada a objetos solo para lograr una lectura estándar. Otro motivo para haber hecho un pasaje por Modula antes de llegar a Java. Igualmente por ahora no se compliquen, solo nos limitaremos a ver cómo funciona y cómo lograr obtener lecturas desde el teclado sin mayores complicaciones ¿ok?

Esto seguirá generando esa sensación de que Java nos complica todo, pero no es así, es su funcionamiento, que una vez comprendido será super intuitivo. Haremos un programa simple que pida el nombre del usuario y luego lo salude, tal como hicimos en Pascal. Esto nos llevará a tener variables. Veamos el código fuente:

Código:
  1. import java.util.Scanner;
  2.  
  3. public class HolaMundo {
  4. public static void main(String[] args){
  5. //Declaración de variables.
  6. Scanner entradaEstandar= new Scanner(System.in); //Lector de la entrada.
  7. String nombre; //Variable que almacenará lo leído.
  8.  
  9. System.out.print("Escribe tu nombre: "); //Un mensaje al usuario.
  10. nombre= entradaEstandar.nextLine(); //Leemos lo ingresado.
  11.  
  12. System.out.print("Hola "); //Imprimimos un mensaje.
  13. System.out.print(nombre); //Imprimimos el contenido de la variable entrada.
  14. }//Fin del procedimiento main.
  15. }//Fin de la clase HolaMundo.


Bueno, se ha complicado un poquito así que como siempre, veamos línea por línea lo que tenemos a fin de que no queden dudas de nada. Así que vamos por la línea 01 donde hay una importación. Como dije hoy necesitábamos usar la clase Scanner. En java las librerías constan de varias clases las cuales se agrupan en paquetes. Un paquete consta entonces de varias clases y subpaquetes. Bien, la clase Scanner está dentro de un paquete llamado util que está dentro de un paquete llamado java. Las importaciones en Java se hacen, al igual que en Modula, al inicio del código fuente antes de declarar la clase. Usamos la palabra reservada import para decir que queremos importar una clase o un paquete de clases. La declaración es entonces así

Código:
  1. import nombreDelPaquete.nombreDelSubpaquete.nombreDelSubpaquete….nombreDeLaClase;


Como ven, lo que se hace es separar por puntos (no espacios) cada nombre de cada paquete hasta llegar a la clase. Como Scanner está en el paquete util el cual está dentro del paquete java, tenemos que escribir

Código:
  1. import java.util.Scanner;


De momento solo deben saber eso, luego veremos como el IDE nos facilitará la vida con las importaciones, pero primero tienen que aprender a hacerlas ustedes a mano.

Sigamos. En la línea 03 tenemos la declaración de la clase HolaMundo. Como verán, usé la misma clase que ya teníamos solo porque no tenía ganas de hacer otro proyecto. En la línea 04 tenemos la declaración del procedimiento main. En la línea 05 tenemos un comentario de fin de línea. Estos comentarios los habíamos visto en Pascal y se abren con el mismo símbolo que en aquel lenguaje (//). Se cierran automáticamente con el fin de la línea en que se escriben. Como ven, el IDE pinta en gris los comentarios.

En la línea 06 aparece por primera vez la declaración de una variable, que encima no es de un tipo primitivo sino que es de tipo Scanner, es decir, es una variable del tipo de una clase (como si nosotros nos declaráramos una variable del tipo de un módulo en Modula 2), o sea que es una referencia a un objeto. No me concentraré en este hecho todavía porque no quiero llegar a la programación orientada a objetos en Java tan rápido, hay mucho por ver antes.
En Pascal y en Modula 2, a la hora de declarar una variable primero escribíamos el nombre de la variable, luego dos puntos y luego el tipo de datos que almacenaría. En Java va primero el tipo de datos y luego el nombre de la variable sin poner dos puntos. Por ejemplo, en Pascal una variable nombre del tipo String se declararía así:

Código:
  1. nombre: String;


En Modula 2 sería así:

Código:
  1. nombre: ARRAY[1..N] OF CHAR;


En Java sería

Código:
  1. String nombre;


Algo nuevo es que no necesitamos poner una palabra reservada para declarer variables en Java como sucedía en Pascal y en Modula donde teníamos que poner VAR y luego declarar las variables. Ahora podemos declararnos una variable en cualquier momento donde se nos antoje. Si vamos programando y nos damos cuenta que necesitamos tal o cual variable la declaramos en el momento y ya. No es prolijo, a pesar de que Java nos permite hacer eso, se suele declarar todas las variables al inicio del código para que este sea más legible por otras personas y por uno mismo.
Bien, me declaré una variable llamada entradaEstandar del tipo Scanner. Esta variable será la que nos devuelva los textos de ingresados por el usuario. En la misma línea donde está declarada entradaEstandar la he inicializado asignándole un valor por defecto mediante

Código:
  1. new Scanner(System.in)


Esta asignación quedará colgada por ahora. Lo importante es que para poder obtener resultados de la entrada estándar debemos declararnos una variable Scanner tal como yo lo he hecho.

El símbolo de asignación en Pascal y Modula era (:=), ahora en Java es simplemente el (=).

En la líena 07 me declaro una variable llamada nombre del tipo String. En Java volvemos a tener el tipo String y nos olvidamos del ARRAY OF CHAR de Modula 2. Este tipo es casi como si fuera un tipo primitivo de Java aunque en realidad no lo es. Por el momento nosotros lo usaremos como un tipo primitivo ya que podemos hacerlo sin ningún problema. Luego en la línea 09 imprimimos un simple mensaje al usuario.
La línea 10 es la que hace la lectura de la entrada estándar. Veámoslo de forma simple:

Scanner nos provee de una función llamada nextLine que no recibe argumentos y retorna un String que es justamente lo leído de la entrada estándar. La función nextLine lee toda la línea completa, como si fuera READLN. A diferencia de READ o READLN, donde poníamos la variable que recibiría los datos como argumento de estos procedimientos, nextLine lo retorna como función, por tanto tenemos que asignar ese retorno a la variable nombre. Es como si en Pascal en vez de hacer

Código:
  1. ReadLn(nombre);


hiciéramos

Código:
nombre:= ReadLn();


Sin embargo, nextLine al ser una operación de Scanner debe usarse mediante un objeto de esta clase (eso es parte de POO en Java y lo veremos luego). De este modo debo usar el objeto entradaEstandar para usar nexLine simplemente escribiendo entradaEstandar.nextLine().

Entonces, la línea 10 lo único que hace es asignar a nombre lo leído en la entrada estándar.
La línea 12 simplemente muestra el mensaje Hola con un espacio al final y la línea 13 imprime el contenido de la variable nombre. Como ven, println y print puede recibir variables como argumentos para ser mostrados en pantalla tal como sucedía con WriteLn y Write de Pascal.
Las líneas 14 y 15 cierran los bloques de main y HolaMundo respectivamente con comentarios que lo aclaran. Dejar comentarios que aclaren qué cierra cada llave ayuda a mejorar el código, más allá de que NetBeans marca en amarillo las llaves que abren y cierran un bloque.

-------------------------------------------------------------------------------------


El operador + en los literales:

Las dos líneas finales que muestran el mensaje al usuario

Código:
  1. System.out.print("Hola ");
  2. System.out.print(nombre);


Podrían haberse sustituido con esta línea

Código:
  1. System.out.print(“Hola “ + nombre);


Esto no era permitido en Pascal y mucho menos en Modula 2. Java nos permite utilizar el operador + en los literales y hace la unión automáticamente. En Pascal teníamos la salvedad de que un mismo procedimiento Write o WriteLn podía recibir varios argumentos separados por comas, pero esto en Java y Modula no es posible. De este modo Java nos provee una forma elegante de solucionarlo.
Si quisiéramos que el mensaje final fuera:

Código:
Hola [nombreIngresado]. Es un placer conocerte.


tendríamos básicamente dos opciones:

• Escribimos este código:

Código:
  1. System.out.println(“Hola “);
  2. System.out.println(nombre);
  3. System.out.println(“. Es un placer conocerte”);


• Escribimos este código:

Código:
  1. System.out.println(“Hola “ + nombre + “. Es un placer conocerte.”);


Como verán, queda mucho más corto y más sencillo el código fuente. Así se podría escribir todo en una sola línea, no importa cuántos signos de + tengan que utilizar, cuantas variables hayan, cuantas veces usen cada variable. Pueden armar las frases que quieran.


Notas interesantes:

• Si ponemos el cursor sobre una variable, NetBeans pinta todas las partes del código donde dicha variable aparece. Además nos muestra en la barra vertical a la derecha de la pantalla todos los lugares de modo que si hacemos clic allí vamos directo a la parte del código que queremos.
• Si al escribir el nombre de la variable del tipo Scanner ponemos luego un punto, NetBeans nos muestra todas las operaciones disponibles detallando información al respecto. Podemos subir y bajar por todas ellas a fin de elegir la que necesitamos.

===============================================

En la próxima lección veremos el ejemplo del programa que calcula el área del triángulo a fin de ver la entrada estándar de datos numéricos. Además veremos dos tipos nuevos de variables y otros aspectos de la salida estándar que ayudan a simplificar la forma en que mostramos mensajes al usuario.



Ultima edición por Kyshuo Ayame el Lunes 06 May 2013 17:20; editado 1 vez
Volver arriba
Ver perfil del usuario Enviar mensaje privado
sixbutcher



Registrado: 20 Jul 2012
Mensajes: 3

Mensaje Publicado: Viernes 20 Jul 2012 15:10

Título del mensaje: Re: Lección 63: Salida y entrada estándar en Java.

Responder citando

Muchísimas gracias por otro apartado mas, a la espera del siguiente capitulo. muchísimas gracias

Volver arriba
Ver perfil del usuario Enviar mensaje privado
portal 47



Registrado: 16 Mar 2010
Mensajes: 8
Ubicación: Mexico

Mensaje Publicado: Lunes 30 Jul 2012 01:44

Título del mensaje: Re: Lección 63: Salida y entrada estándar en Java.

Responder citando

tengo una duda, en esta linea me marca un foco con un ! en rojo
foco! import java.util.Scanner;

si me corre bien pero quisiera saber si no hay ningún problema

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Lunes 30 Jul 2012 03:12

Título del mensaje: Re: Lección 63: Salida y entrada estándar en Java.

Responder citando

Asoma el puntero del mouse a esa línea subrayada y te aparecerá un detalle del error. Puedes auntar al signo en rojo que te aparecerá lo mismo.

Es raro. Si has segui9do todos los pasos como he detallado no debería haber ningún error.

Si el problema persiste muéstrame una captura de pantalla. Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
portal 47



Registrado: 16 Mar 2010
Mensajes: 8
Ubicación: Mexico

Mensaje Publicado: Lunes 30 Jul 2012 20:06

Título del mensaje: Re: Lección 63: Salida y entrada estándar en Java.

Responder citando

Kyshuo Ayame escribió:
Asoma el puntero del mouse a esa línea subrayada y te aparecerá un detalle del error. Puedes auntar al signo en rojo que te aparecerá lo mismo.

Es raro. Si has segui9do todos los pasos como he detallado no debería haber ningún error.

Si el problema persiste muéstrame una captura de pantalla. Saludos.


lo volví a hacer y ya no me marco

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Shell



Registrado: 29 Feb 2012
Mensajes: 7

Mensaje Publicado: Jueves 15 Nov 2012 10:58

Título del mensaje: Re: Lección 63: Salida y entrada estándar en Java.

Responder citando

Hola!. Acabo de comenzar el curso de Java.

Después de ver la clase Scanner el ejemplo que os muestro queda un poco
como mas sobrecargado. Fue el primero que vi antes de aprender
que existe la clase Scanner.

Código:

// Este programa le pide ingresar varios datos para concluir
import java.io.*;

public class HolaTux
{
   public static void main(String[] args) throws IOException
      {
         InputStreamReader reader = new InputStreamReader(System.in);
         BufferedReader input = new BufferedReader(reader);
         System.out.println("Ingrese su nombre: ");
         String nombre = input.readLine();
         
         System.out.println("Hola,como estas "+nombre);
      }
}


¿ Este es más antiguo ?.

Saludos

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Jueves 15 Nov 2012 13:37

Título del mensaje: Re: Lección 63: Salida y entrada estándar en Java.

Responder citando

Pues sí, es más antiguo. Digamos que Scanner igualmente realiza tareas como esas pero nos simplifica las cosas. Fue implementado en las últimas versiones de Java.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

¿Cómo instalar correctamente JDK (Java Develope...

Alfonso Lara Temas generales 2 Martes 07 May 2019 22:09 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Ayuda con TestNG Parametrico en java netbeans

baltigo Java 0 Sábado 30 Jun 2018 01:37 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Publicar Aplicación web JAVA en tomcat

Irvin Java Web 1 Viernes 13 Oct 2017 17:54 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Imagen referencial De creación de jtable en apl...

Jensel S.G Java 6 Miércoles 13 Sep 2017 20:06 Ver último mensaje
El tema está bloqueado: no pueden editarse ni agregar mensajes.

EMPLEO ANALISTA PROGRAMADOR/A BACK-END JAVA EE

GRUPOARESTORA Bolsa de trabajo 0 Viernes 23 Jun 2017 14:33 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,