Apuntes IntProg 2017-1 (Java Básico Con E-S)

Universidad del Bío-Bío Introducción a la Programación
Facultad de Ciencias Empresariales

Escuela de Ingeniería Civil Informática
Programando con JAVA

Introducción
¿Qué es JAVA?
Java es el primer lenguaje que tiene la virtud de ser compilado e interpretado de forma simultánea. Cuando
un programador realiza una aplicación o un applet en Java y lo compila, en realidad, el compilador no trabaja
como un compilador de un lenguaje usual. El compilador Java únicamente genera el denominado ByteCode.
Este código es un código intermedio entre el lenguaje máquina del procesador y Java. Evidentemente este
código no es ejecutable por sí mismo en ninguna plataforma hardware, pues no se corresponde con el lenguaje
de ninguno de los procesadores que actualmente se conocen (habrá que esperar a ver qué ocurre con los
procesadores Java). Por lo tanto, para ejecutar una aplicación Java es necesario disponer de un mecanismo
que permita ejecutar el ByteCode. Este mecanismo es la denominada Máquina Virtual Java. En cada
plataforma (Unix, Linux, Windows, Macintosh, etc.) existe una máquina virtual específica. Así que cuando el
ByteCode llega a la máquina virtual, esta lo interpreta pasándolo a código máquina del procesador donde se
esté trabajando y ejecutando las instrucciones en lenguaje máquina que se deriven de la aplicación Java. De
este modo, cuando el mismo ByteCode llega a diferentes plataformas, este se ejecutará de forma correcta, pues
en cada una de esas plataformas existirá la máquina virtual adecuada. Con este mecanismo se consigue la
famosa multiplataforma de Java, que con sólo codificar una vez, es posible ejecutar en varias plataformas.
En realidad la máquina virtual desempeña otras funciones, como la de aislar los programas Java del entorno
de la máquina virtual, consiguiendo una gran seguridad.
Sin embargo, esto tiene algunas desventajas y la más clara es la velocidad de ejecución. Puesto que la máquina
virtual debe estar interpretando constantemente el ByteCode, se consume demasiado tiempo de procesador en
realizar esta interpretación que por otra parte no aporta nada a la aplicación, obteniendo así un bajo
rendimiento. Para solucionarlo se han adoptado soluciones intermedias. Una de las más novedosas y útiles
son los compiladores JIT (Just-In-Time). Estos compiladores están situados a la entrada de la máquina virtual,
de forma que según llega el ByteCode lo van compilando al lenguaje máquina del procesador. A diferencia
de la interpretación, el compilador no ejecuta el ByteCode, únicamente lo traduce y lo almacena en código
nativo dentro de la máquina virtual. Así, una vez que la aplicación está dentro de la máquina virtual, ya se
encuentra en lenguaje máquina y, por lo tanto, será directamente ejecutable, sin necesidad de interpretaciones,
consiguiendo dotar de mayores rendimientos a la aplicación.
Usos o aplicaciones de JAVA
Java es un lenguaje orientado a construir aplicaciones bajo el enfoque orientado a objeto y como tal puede
usarse en diversos campos y organizaciones; sin embargo, Java también se utiliza para construir los llamados
applets, que son programas que se ejecutan a través de un browser o navegador Web como Firefox que tenga
el intérprete adecuado (que la versión corresponda con la del lenguaje Java usado para escribir el programa o
applet). Lo anterior implica que las páginas Web pueden contener invocaciones a programas o applets, los
cuales son traídos desde el servidor donde se encuentren y cargados en la memoria del equipo donde se
visualiza la página (lo que se trae y carga es el bytecode). Un applet puede corresponder a una animación u
MASCh/MAC [Escriba aquí] 1

otra operación. Sin embargo los applets no son el único mecanismo que permite escribir aplicaciones web
usando Java.
Características
El lenguaje Java tiene las siguientes características:
• Simple, comparado con otros lenguajes orientados a objeto

• Orientado a Objetos
• Distribuido
• Robusto
• Arquitectura Neutral
• Seguro
• Portable
• Interpretado
• Multihilo
• Dinámico
¿Cómo se usa JAVA?
La forma de trabajo depende del ambiente de programación JAVA que se tenga. En el caso particular de este
curso el proceso para escribir y ejecutar programas JAVA se explica a continuación.
Consideraciones generales respecto de la construcción de programas tanto en la plataforma Windows o

LINUX:
• El código fuente debe escribirse con algún editor de texto ASCII. El archivo debe llevar la extensión .java
 En Windows se puede usar Wordpad u otro editor
 En Linux se puede usar vi u otro (hay varios disponibles)
• Una vez escrito el programa debe ser "compilado" usando el programa javac (en realidad se genera el
código intermedio conocido como bytecode)
Por ejemplo, si se ha escrito y grabado el programa sumador.java, entonces para "compilar":
javac sumador.java
• Si el programa tiene errores, javac generará un listado con los errores detectados, los cuales deben ser
corregidos con el editor de texto usado y vuelto a "compilar".
• Cuando el programa no tenga errores, javac generará un archivo con el mismo nombre del programa
fuente, pero con la extensión .class. Dicho archivo podrá ser ejecutado usando java del siguiente modo:
java sumador

Comentarios
Tiene como fin documentar programas, esto es, agregar explicaciones referentes a las variables usadas o al
código escrito, sin que sean considerados por el compilador al momento de generar el código intermedio
(bytecode). En Java hay tres tipos de comentarios, en este curso se utilizarán los dos siguientes:
• Comentarios para una sola línea. Se debe colocar como primer carácter del comentario doble slash (//), de
allí hasta el final de la línea no será considerado al momento de "compilar"
Ejemplo:
// comentario ...
• Comentarios de una o más líneas. Cuando el comentario a colocar ocupará más de una línea se debe usar
un formato como el siguiente:
/*
comentario
extenso
*/
Separadores
Los separadores admitidos en Java son:
() Paréntesis.
Para contener listas de parámetros en la definición y llamada a métodos. También se utiliza para
definir precedencia en expresiones, contener expresiones condicionales en las estructuras de control y rodear
las conversiones de tipo.
{} Llaves.
Para contener los valores de arreglos inicializados automáticamente. También se utiliza para definir
un bloque de código. Otros usos serán señalados más adelante
[] Corchetes.
Para declarar arreglos. También se utiliza cuando se referencian valores de arreglos (los arreglos se
abordan más adelante).
; Punto y coma.
Separa sentencias.
, Coma.
Separa identificadores consecutivos en una declaración de variables. También se utiliza para encadenar
sentencias dentro de una sentencia for.
. Punto.
Entre sus usos está el separar una variable o método (término de la programación orientada a objetos)
de una variable de referencia.

Identificadores
Los identificadores nombran variables, funciones, clases y objetos; cualquier cosa que el programador necesite
identificar o usar.
En Java, un identificador comienza con una letra, un guion bajo (_) o un símbolo peso ($). Los siguientes
caracteres pueden ser letras o dígitos. Se distinguen las mayúsculas de las minúsculas y no hay una longitud
máxima establecida para el identificador.
Serían identificadores válidos:
identificador
nombreUsuario
_variableDelSistema
$transaccion
promTests
Palabras Clave
En la Tabla 1 se indican las palabras clave que están definidas en Java y que no se pueden utilizar como
identificadores.
Palabras Reservadas
Son palabras reservadas los literales booleanos: true y false, y el literal que representa una referencia
(dirección de memoria) a nada: null. Al igual que las palabras clave, las palabras reservadas no pueden usarse
como identificadores.
abstract continue goto * package this

boolean default if private threadsafe
break do implements protected throw
byte double import public transient
byvalue else instanceof return try
case extends int short void
catch final interface static while
char finally long super
class float native switch
const * For new synchronized
(* No se utilizan actualmente)
Tabla 1. Palabras claves de Java.

Tipos de datos básicos
Java posee varios tipos de datos básicos que se pueden clasificar en:
• Tipo caracter
• Tipo lógico o boolean
• Tipo numérico
El detalle de los tipos de datos anteriores se muestra en la Tabla 2.
Tipo de Operaciones Nombre Tamaño Descripción

datos
Booleano Operaciones boolean 1 bit Comprende aquellos valores empleados para
lógicas. definir el valor de verdad de algo: falso y
verdadero. Específicamente, en Java, se manejan
los valores false y true.
Caracter Operaciones de char 16 bits Contiene la posición en la cual se encuentra cada
relación y de caracter en la tabla Unicode1, es decir comprende
asignación valores entre 0 y 65536.
Numérico Aritméticas, de byte 8 bits Comprende el rango de valores enteros entre -128
relación y de y +127. Lo anterior, se debe a que sólo usa 8 bits
asignación de memoria para guardar un valor, de ahí su
nombre, pues 8 bits forman un byte.
short 16 bits Definido para valores enteros, y el rango que
puede albergar está entre -215 .. 215-1
int 32 bits Definido para valores enteros, y el rango que
puede albergar está entre -231 .. 231-1.
long 64 bits Definido para valores numéricos enteros y el
rango va desde -263 .. 263-1.
float 32 bits Definido para valores numéricos de tipo real, y el
rango de valores es -1032 .. 1032 , aprox.
double 64 bits Definido para valores numéricos de tipo real, y el
rango de valores es -10300 .. 10300, aprox.
Tabla 2. Tipos de datos básicos.
Las siguientes son constantes válidas para los tipos de datos básicos presentados:
• Enteras: 1, 0, 1024 (short o int), -3, 1L (long)

• Reales: 1.0, -3.1416, 1.5e4, 1.0f (float)
• Caracteres: 'a', '1', '+'
• Booleanas: true, false
Estas constantes serán valores posibles de asignar explícitamente a una variable o bien, valores que pueden ser
usados en una expresión o ingresados al leer una variable. Los conceptos de variable y asignación se presentan
en detalle más adelante.

Por otra parte, Java soporta constantes con nombre y la forma de crearlas es usando la palabra clave final. Un
ejemplo es:
final float PI = 3.14159;
Esta línea de código produce un valor que se puede referenciar en el programa bajo el nombre de PI, pero no
puede ser modificada. La palabra clave final es la que evita que esto suceda.
Variables
Las variables se utilizan en la programación Java para almacenar datos que varían durante la ejecución del
programa. Para usar una variable, hay que indicarle al compilador el tipo y nombre (identificador) de esa
variable, esto se denomina declaración de la variable. El tipo de la variable determinará el conjunto de valores
que se podrán almacenar en la variable y el tipo de operaciones que se podrán realizar con ella.
La forma básica de una declaración de variable tiene la siguiente sintaxis:
<tipo de dato> <identificador> [ = <valor>][,<identificador> [= <valor>] ...];
Donde:
• <> implica que debe ser reemplazado por lo que se indica al interior de los signos.
• [] implica que lo encerrado entre estos paréntesis es opcional, puede estar presente o no. Los paréntesis no
forman parte de la estructura.
Por ejemplo, el código de programa siguiente:

int numero;
char letra;
float totalKilos, pi;
boolean continua
declara:
• Una variable llamada numero de tipo entera que puede almacenar valores desde -231 hasta 231-1
• Una variable letra que almacena un caracter cualquiera (código ascii)
• Una variable totalKilos y una variable pi que almacenan valores reales aproximadamente desde -1032
hasta 1032
• y una variable boolean continua que puede asumir los valores true o false.
¡NOTA IMPORTANTE!!!
Los nombres de variables siempre parten con minúsculas Ej. (contador). Si el nombre es compuesto, las
siguientes palabras comienzan con mayúscula como por ejemplo:
totalKilos, cuentaNumPos

Expresiones y Operadores
Los programas en Java, al igual que en C y C++, se componen de sentencias, que a su vez están compuestas
en base a expresiones. Una expresión es una determinada combinación de operadores y operandos que se
evalúan para obtener un resultado particular. Los operandos pueden ser variables, constantes o llamadas a
métodos, los cuales se resumen en la Tabla 3.
Operadores Aritméticos Unarios

Símbolo Notación Significado Tipo del argumento Ejemplo
++ ++var preincremento: hace var=var+1 y int, short, byte, long, ++i
luego se usa var float, double
var++ postincremento: usa var y luego i++
hace var=var+1
-- --var predecremento --j
var-- postdecremento j--
+ +exp nada int, long, float, double +(nro+5)
- -exp cambia el signo de exp (Si exp es int o short se -(nro+5)
convierte a int)
Operadores Aritméticos Binarios
* exp+exp multiplicación int, long, float, double Nro*2
/ exp/exp división nro*total/5
+ exp+exp suma (Al usar short o byte, (a+5)/3
- exp-exp resta éstos se convierten a+5-nro
% exp%exp módulo (resto división entera) implícitamente a int) nro%2
Operadores Relacionales
> exp>exp mayor Ambas expresiones total>10
>= exp>=exp mayor o igual deben ser del mismo total>=20
< exp<exp menor tipo: cont<0
<= exp<=exp menor o igual int, long, float o double cont<=0
== exp==exp igual El resultado es boolean i==10
!= exp!=exp distinto k != 50
Operadores Booleanos
! !exp negación boolean !(c>0)
&& exp&&exp y lógico a>1&& b==2
|| exp||exp o lógico a==2 || b<=5
Operador de Casting
(tipo) (tipo)exp cambia el tipo de dato de la cualquiera (excepto float pi=3.14;
expresión a la derecha, algunas combinaciones) ...
forzándola al tipo dado int i = (int) pi;
Tabla 3. Operadores de Java.

Pre y post incremento/decremento
Estos operadores tienen como fin ahorrar líneas de código y resultan bastante cómodos de usar. A continuación
se presenta un ejemplo que ayudará a clarificar su significado.
Ejemplo:
int a, b, c, d; // declara las variables a, b, c y d como enteras
float f; // declara la variable f como flotante
a = 1; // asigna 1 a la variable a
b = 2;
c = ++a; // Incrementa en 1 la variable antes de asignarla a c.
d = -(c+1); // Asigna -2 a la variable d
b = a++; /* Asigna a b el valor de a y luego incrementa el valor de a.
Los resultados finales son: b=1; a=2 */
a = --b; // a=b=0
(a+1)++; // Error! a+1 no es una variable
f = a; // f= 1.0
f++; // f=2.0
En ciertos casos, el orden en que se realizan las operaciones es determinante para el resultado que se obtenga.
Al igual que en C++, Pascal y otros lenguajes, en Java se puede controlar el orden de evaluación de las
expresiones mediante el uso de paréntesis. Si no se proporcionan estos paréntesis, el orden estará determinado
por la precedencia de operadores (ver Tabla 4), de tal modo que las operaciones en las que estén involucrados
operadores con más alta precedencia serán los que primero se evalúen.
. () [ ] Mayor precedencia
unarios: - + (cast)
* / %
+ -
!
< > <= >= == !=
&&
|| Menor precedencia
Tabla 4. Orden de precedencia de operadores
Una característica importante del funcionamiento de los operadores && y || (y que es pasado a veces por alto,
incluso por programadores experimentados) es que las expresiones se evalúan de izquierda a derecha y que la
evaluación de la expresión finaliza tan pronto como se pueda determinar el valor de la expresión. Por ejemplo,
en la expresión siguiente:
(a < b) || (c < d)
si la variable a es menor que la variable b, no hay necesidad de evaluar el operando derecho del operador ||
para determinar el valor de la expresión entera.

Casting
Java automáticamente cambia el tipo de un dato a otro cuando es pertinente, siempre que el tipo
original de la variable sea de rango menor a aquél al que debe cambiar. Los rangos están dados por el espacio
de almacenamiento ocupado en la memoria por el tipo de dato, por lo tanto se tiene que:
byte < short < int < long < float < double
Lo anterior se ilustrará a través de los dos siguientes ejemplos.
Ejemplo 1:
int i = 1; // Se asigna un 1 a i
long nl = i, // Ok. (Se asigna el valor de i a nl, que en este caso es 1)
nl = 1000000000000l; /* El caracter final es la letra l (también puede ser L) para indicar long,
si se omite se asumirá como int y provocará un error por ser
demasiado grande */
float f = nl; // Ok
Ejemplo 2:
Pero hay problemas de conversión de tipo en este ejemplo, al tratar de transformar desde un tipo de dato más
grande (derecha) a uno más pequeño (izquierda)
double d = 1.0e24;
int i = d; // Error durante la compilación
float f = 1.0f; // Es necesario agregar f, pues se asume por defecto que un decimal es double
int i = f; // Error durante la compilación
short s = i; // Error durante la compilación
El casting, o moldeo, permite forzar o cambiar explícitamente el tipo de dato cuando normalmente no se haría.
Para realizar un casting, se coloca el tipo de dato que se desea (incluyendo todos los modificadores) dentro de
paréntesis a la izquierda del valor a cambiar.
Ejemplo:
double d = 1.0;
int i = (int)d; // Ok en compilación
Sin embargo, se debe tener cuidado, ya que Java no avisa en caso de errores de conversión numéricos, como
sucede en el siguiente ejemplo.

Ejemplo:
int i = 256;
byte b = (byte)i; // b almacenará cero
i = (int)b;
b = (byte)i; // b almacenará -1
Asignación
Para asignar un valor a una variable existe más de un operador en Java, sin embargo, es suficiente con dominar
uno de ellos. Se puede asignar un valor a una variable al momento de ser declarada.
Ejemplo 1:
int total = 50, cont=0; // Asignación al momento de declarar las variables
int i;
...
i = total; // Instrucción de asignación
...
i = i-1 // También se pudo usar i--
Ejemplo 2: Declaración de variables, asignaciones y castings

public class PruebaTiposDeDatos {
public static void main (String[] args) {
boolean True = true;
boolean sw = True;
System.out.println("sw = " + sw);
double double1;
long long1;
float float1=0.513f, float2;
int int1 = 1 / 4;
float float3 = 1 / 4;
System.out.println("double1 = " + double1 + ", long1 = " + long1 + ", float1 = " + float1);
System.out.println("float2 = " + float2 + ", int1 = " + int1 + ", float3 = " + float3);
System.out.println("1.0/4.0 = " + 1.0 / 4.0 + ", en cambio 1/4 = " + 1 / 4);
int int2=9, int3=9;

long1 = 1000000000000l;
float2 = long1;
double1 = 12e1;
double1++;
System.out.println(!(double1 < 10) || long1 >= -5);
System.out.println(int2 > -10 || int3 < 20 && int2 != int3);
float float4=0, float5 = 12.5f;

float5++;
System.out.println("La suma de " + float4 +" y "+ float5 +" es: "+ (float4 + float5) +" y no "+ float4 + float5);
double double2=1.0e24;
int int4=(int)double2;
System.out.println("double2 =" + double2 + ", int4 = (int)double2 = " + int4);
double double3=1.0e8;
int int5=(int)double3;
System.out.println("double3 = " + double3 + ", int5 = (int)double3 = " + int5);
int int6 = 256;

byte byte1 = (byte)int6;
System.out.print("int6 = " + int6 + ", byte1 = (byte)int6 = " + byte1);
byte1 = (byte)int4;
System.out.println(", pero byte1 = (byte)int4 = " + byte1);
}
}
El programa anterior tiene como finalidad declarar variables de distintos tipos de datos para comprobar la
naturaleza de los valores almacenados y el efecto de realizar castings a los mismos. Se desea también probar
el uso de System.out al incluir expresiones en la salida.
Lo desplegado por el programa es:
sw = true
double1 = 121.0, long1 = 1000000000000, float1 = 0.513
float2 = 1.0E12, int1 = 0, float3 = 0.0
1.0/4.0 = 0.25, en cambio 1/4 = 0
true
true
La suma de 0.0 y 13.5 es: 13.5 y no 0.013.5
double2 =1.0E24, int4 = (int)double2 = 2147483647
double3 = 1.0E8, int5 = (int)double3 = 100000000
int6 = 256, byte1 = (byte)int6 = 0, pero byte1 = (byte)int4 = -1
Ejercicio:
Escribir un programa Java que permita calcular la nota final de un alumno (en una escala de 1-7) cuyos
promedios han sido:
Test : 5.2 (15%)
Tareas : 5.8 (15%)
Certámenes : 4.2 (70%)

Solución:
El archivo que guarde el programa debe llevar el

nombre Promedio.java (tal como está escrito)
public class Promedio { Todo programa Java comenzará igual1

public static void main (String[] args) { sólo variará el nombre después de class
int notaFinal;
notaFinal = (int) (5.2*0.15 + 5.8*0.15 + 4.2*0.70);
} Dado que esta expresión es real (float) es necesario forzarla a int

} mediante casting para no generar error en la asignación. Sin
embargo, se perderá la parte decimal de la nota.
Una versión con tipos de datos más adecuados sería:
public class Promedio {

public static void main (String[] args) {
float notaFinal;
notaFinal = (5.2*0.15 + 5.8*0.15 + 4.2*0.70);
}
}
Para ejecutar este programa es necesario compilarlo previamente con javac:

javac Promedio.java
y luego ejecutarlo mediante java:

java Promedio
1
El significado de estas dos líneas se comprenderá en un siguiente curso de programación, por ahora debe aceptarse.

Salida
Para desplegar por pantalla se hace uso de System.out, que representa la salida estándar. Típicamente
corresponde a la pantalla u otra salida especificada en las variables de entorno del sistema en el que se ejecuta.
System.out se puede utilizar combinado con: print que permite desplegar los tipos de datos básicos y cadenas
que hemos visto previamente; también se puede combinar con println, idéntico a print, salvo que agrega un
salto de línea al final
Es importante destacar que la primera S de System.out es mayúscula. Si se escribe con minúscula se obtendrá
un error de compilación. Hay que tener presente que los espacios dentro de las comillas cuentan, es decir, el
resultado de escribir (“Mensaje a mostrar”); no es el mismo que el de escribir (" Mensaje a mostrar");.
La sintaxis básica es: System.out.print (expresión1 + expresión2 + …… + expresión), donde el símbolo + se

usa para concatenar cadenas de texto o variables que representen texto. Si se introduce en una concatenación
un número o una variable que no sea una cadena Java por defecto realizará la conversión de aquello que
hayamos concatenado a texto. La Tabla 5 presenta algunos ejemplos.
Instrucción en JAVA En pantalla aparecerá

System.out.println ("El peso es " + 42 + " kilos"); El peso es 42 kilos
System.out.println ("El peso es " + peso + " kilos"), donde peso El peso es 42 kilos
es la variable que puede tener por ejemplo un valor de 42.
System.out.println ("El peso es" + peso + "kilos"). No se El peso es42kilos
consideró los espacios en la expresión.
System.out.println ("El peso es :\t " + peso + " kilos") El peso es: 42 Kilos
Tabla 5. Ejemplos de salidas.
Para imprimir una línea en blanco se pueden usar una de las siguientes instrucciones:
System.out.println ();
System.out.println ("");
Existen algunos caracteres de control que permiten manejar la salida, los cuales se detallan en la Tabla 6.
Caracter de control Significado
\b Retrocede una posición
\n Salta al inicio de la siguiente línea
\r Va al inicio de la línea en la que está el cursor
\t Tabulación
\f Salto de página
\" La comilla doble
\' La comilla simple
\\ El caracter backslash o barra invertida
Tabla 6. Caracteres de control disponibles.

Entrada Estándar
En Java existen varias alternativas para realizar lectura desde la entrada estándar (el teclado), una de ellas es
usando Scanner que se encuentra disponible en la API (Application Programming Interface) del lenguaje.
Lectura de datos usando Scanner
La Figura 1 presenta, en forma gráfica, el funcionamiento de Scanner como mecanismo para leer desde la
entrada estándar, considerando que se ha llevado a cabo la ejecución de la siguiente instrucción Java:
Scanner teclado = new Scanner(System.in);
Donde System.in representa la entrada estándar.
teclado . nextXXXXX() ;
Referencia Operación
La entrada estándar
(teclado)
Origen
Figura 1. Representación gráfica de la entrada estándar en Java.
Scanner permite leer texto desde la entrada estándar, convirtiéndolo en tipos de datos primitivos (byte, int,
float, etc.) y string, utilizando operaciones de acuerdo al tipo de dato ingresado por teclado.
La Tabla 7 muestra algunas de las operaciones que proporciona Scanner para la lectura de datos. Cada dato
que se lee se le llama token en Java, siendo posible recuperar varios datos (tokens) separados por uno o más
caracteres denominados delimitadores. En este curso se usarán como caracteres delimitadores los de retorno
de carro (\r) y salto de línea (\n), esto implica que se ingresará un dato por vez, es decir, se digitará el dato (de
tipo int, float, String, …) en el teclado y se presionará la tecla <enter>.

Tipo de dato
Operación y Descripción
que retorna
close()
void
Cierra el scanner
hasNext()
boolean
Retorna true si este scanner tiene otro token en su entrada.
hasNextByte()
boolean Retorna true si el siguiente token en la entrada de este scanner se puede interpretar como un valor
byte usando nextByte().
hasNextDouble()
double usando nextDouble().
hasNextFloat()
float usando nextFloat().
hasNextInt()
int usando nextInt().
hasNextLong()
long usando nextLong().
hasNextShort()
short usando nextShort().
next()
String
Encuentra y retorna el siguiente token de la entrada.
nextByte()
byte
Escanea o recupera el siguiente token de la entrada como un byte.
nextDouble()
double
Escanea o recupera el siguiente token de la entrada como un double.
nextFloat()
float
Escanea o recupera el siguiente token de la entrada como un float.
nextInt()
int
Escanea o recupera el siguiente token de la entrada como un int.
nextLong()
long
Escanea o recupera el siguiente token de la entrada como un long.
nextShort()
short
Escanea o recupera el siguiente token de la entrada como un short.
String nextLine()
Escanea o recupera el siguiente token completo cuyo único delimitador es el salto de línea.
Tabla 7. Operaciones disponibles en Scanner.
A continuación se presentan una serie de ejemplos que muestran el uso de variables de tipo Scanner
definidas y usadas para leer desde teclado.

Ejemplo 1: Lectura de un string
Scanner teclado= new Scanner(System.in); // Declara y crea un Scanner para leer desde el teclado
String nombre = teclado.nextLine(); // Lee el dato de teclado y lo almacena como string
System.out.println("El nombre leido fue: " + nombre);
Si se ingresa por teclado el dato “Daniel Rivera” (sin las comillas, se presiona < enter> al final), se desplegará
el mensaje:
El nombre leido fue: Daniel Rivera
Ejemplo 2: Lectura de un string y un entero
Scanner teclado= new Scanner(System.in); // Declara y crea un scanner para leer desde teclado
String nombre = teclado.nextLine(); // Lee un string
int edad= teclado.nextInt(); // Lee un dato entero de tipo int
teclado.close(); // Ya no se podrá leer desde teclado
if (edad>=18) {
System.out.println(nombre +" tiene " + edad + " años, es mayor de edad");
}
else {
System.out.println(nombre +" tiene " + edad + " años, es menor de edad");
}
Si se ingresa por teclado el dato “Daniel Rivera” (se presiona <enter> al terminar) y luego se ingresa 18 (se
presiona <enter> al terminar), se desplegará el mensaje:
Daniel Rivera tiene 18 años, es mayor de edad
Cabe hacer notar que para utilizar Scanner es necesario incluir una instrucción que permita importar su
funcionalidad al inicio del programa. El Ejemplo 3 muestra cuál es esta instrucción.
Ejemplo 3: Lee y suma dos enteros.
import java.util.Scanner; // Se importa Scanner de la API de Java para usar sus operaciones
public class SumaEnteros {
public static void main (String[] args ) {
int a, b, suma;
Scanner tcld = new Scanner(System.in); // Declara y crea un scanner para leer desde teclado
System.out.print("Suma de dos enteros.\nIngrese el primer entero: ");
a = tcld.nextInt(); // Lee el primer entero
System.out.print("Ingrese el segundo entero: ");
b = tcld.nextInt(); // Lee el segundo entero
tcld.close(); // Cierra el scanner
suma = a + b;
System.out.println("La suma de los números leidos es: " + suma);
}
}

Apuntes IntProg 2017-1 (Java Básico Con E-S)

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Apuntes IntProg 2017-1 (Java Básico Con E-S)

Uploaded by

Copyright:

Available Formats

Universidad del Bío-Bío Introducción a la Programación

Facultad de Ciencias Empresariales

Programando con JAVA

Usos o aplicaciones de JAVA

MASCh/MAC [Escriba aquí] 1

El lenguaje Java tiene las siguientes características:

• Simple, comparado con otros lenguajes orientados a objeto

¿Cómo se usa JAVA?

Consideraciones generales respecto de la construcción de programas tanto en la plataforma Windows o

MASCh/MAC [Escriba aquí] 2

Los separadores admitidos en Java son:

MASCh/MAC [Escriba aquí] 3

Serían identificadores válidos:

abstract continue goto * package this

MASCh/MAC [Escriba aquí] 4

Tipos de datos básicos

El detalle de los tipos de datos anteriores se muestra en la Tabla 2.

Tipo de Operaciones Nombre Tamaño Descripción

• Enteras: 1, 0, 1024 (short o int), -3, 1L (long)

MASCh/MAC [Escriba aquí] 5

final float PI = 3.14159;

La forma básica de una declaración de variable tiene la siguiente sintaxis:

<tipo de dato> <identificador> [ = <valor>][,<identificador> [= <valor>] ...];

Por ejemplo, el código de programa siguiente:

MASCh/MAC [Escriba aquí] 6

Operadores Aritméticos Unarios

MASCh/MAC [Escriba aquí] 7

Pre y post incremento/decremento

Tabla 4. Orden de precedencia de operadores

MASCh/MAC [Escriba aquí] 8

Lo anterior se ilustrará a través de los dos siguientes ejemplos.

MASCh/MAC [Escriba aquí] 9

Ejemplo 2: Declaración de variables, asignaciones y castings

int int2=9, int3=9;

float float4=0, float5 = 12.5f;

MASCh/MAC [Escriba aquí] 10

int int6 = 256;

Lo desplegado por el programa es:

MASCh/MAC [Escriba aquí] 11

El archivo que guarde el programa debe llevar el

public class Promedio { Todo programa Java comenzará igual1

notaFinal = (int) (5.2*0.15 + 5.8*0.15 + 4.2*0.70);

} Dado que esta expresión es real (float) es necesario forzarla a int

Una versión con tipos de datos más adecuados sería:

public class Promedio {

Para ejecutar este programa es necesario compilarlo previamente con javac:

y luego ejecutarlo mediante java:

MASCh/MAC [Escriba aquí] 12

La sintaxis básica es: System.out.print (expresión1 + expresión2 + …… + expresión), donde el símbolo + se

Instrucción en JAVA En pantalla aparecerá

Tabla 5. Ejemplos de salidas.

MASCh/MAC [Escriba aquí] 13

Lectura de datos usando Scanner

Scanner teclado = new Scanner(System.in);

Donde System.in representa la entrada estándar.

Figura 1. Representación gráfica de la entrada estándar en Java.

MASCh/MAC [Escriba aquí] 14

MASCh/MAC [Escriba aquí] 15

Ejemplo 1: Lectura de un string

Ejemplo 2: Lectura de un string y un entero

Daniel Rivera tiene 18 años, es mayor de edad

Ejemplo 3: Lee y suma dos enteros.

MASCh/MAC [Escriba aquí] 16

You might also like

notaFinal = (int) (5.20.15 + 5.80.15 + 4.2*0.70);