Esta presentación habla acerca de las librerías de Java

1. Librerías de Java
LSCA Alma Delia Otero Escobar

2. Existen diferentes librerías en Java, entre las cuales se encuentran:
java.lang
Colección de tipos básicos siempre importados a cualquier unidad de
compilación. Aquí están las declaraciones de objetos, clases, threads,
excepciones, wrappers de los tipos de datos primitivos y otras clases
fundamentales.
java.io
Archivos de stream y acceso aleatorio. Librería estándar de entrada y
salida.

3. java.net
Librería que apoya interfaces con telnet y URLs.
java.util
Clases como diccionarios, tabla de hash, stack, técnicas de
codificación y decodificación, hora, fecha, etcétera.
java.awt
Abstract Windowing Toolkit que proporciona una capa abstracta
que permite llevar una aplicación en Java de un sistema de
ventanas a otro. Contiene clases para componentes básicos de la
interfaz, tales como eventos, colores, tipos de letra, botones,
campos de texto, etc.

4. Identificadores

5. 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 subrayado (_) o un símbolo
de dólar ($).

6. Los siguientes caracteres pueden ser letras o dígitos.
Se distinguen las mayúsculas de las minúsculas y no
hay longitud máxima.
Serían identificadores válidos: y su uso sería, por ejemplo:
identificador
nombre_usuario int contador_principal;
Nombre_Usuario char _lista_de_ficheros;
_variable_del_sistema float $cantidad_en_Ptas;
$transaccion

7. Literales

8.  Un valor constante en Java se crea
utilizando una representación literal de él.
 Ejemplo:
 100
 98.6
 ‘X’
 <<Esto es una prueba>>

9. Comentarios

10.  En java existen tres tipos de comentarios:
 De múltiples líneas /* */
 De una línea //
 De documentación /** */

11. Separadores

12.  ( ) Lista de parámetros, precedencia
 { } Inicialización de matrices, bloques
 [ ] Tipos de matrices y referencias
; Separa sentencias
, separa o bien encadena sentencias
. Separa nombres de paquetes y
subpaquetes, variables y métodos

13. Palabras clave

14.  Las siguientes son las palabras clave que
están definidas en Java y que no se
pueden utilizar como identificadores:

15. abstract continue for new switch
synchroniz
boolean default goto null
ed
break do if package this
byte double implements private threadsafe
byvalue else import protected throw
case extends instanceof public transient
catch false int return true
char final interface short try
class finally long static void
const float native super while

16. Palabras
Reservadas

17.  Además, el lenguaje se reserva unas
cuantas palabras más, pero que hasta
ahora no tienen un cometido específico.
Son:

18. cast future generic inner
operator outer rest var

19. Literales

20.  Un valor constante en Java se crea
utilizando una representación literal de él.
Java utiliza cinco tipos de elementos:
enteros, reales en coma flotante,
booleanos, caracteres y cadenas, que se
pueden poner en cualquier lugar del
código fuente de Java.

21.  Cada uno de estos literales tiene un tipo
correspondiente asociado con él.

22. Enteros
Tipo Por ejemplo
8 bits
byte complemento a
dos
16 bits
short complemento a
dos
21 077 0xDC00
32 bits
int complemento a
dos
64 bits
long complemento a
dos

23. Reales en coma flotante:
Tipo Por ejemplo
32 bits IEEE
float
754 3.18 2e12
64 bits IEEE 3.1E12
double
754

24. Booleanos:
true
false

25. Caracteres:
Por ejemplo:
a t u???? [????] es un número unicode

26. Cadenas:
Por ejemplo:
"Esto es una cadena"

27. Tipos de datos,
variables y matrices

28. Sintaxis
 Declaración de una variable:
tipo nombre_variable;
byte b,c;

29. Ejemplos:
 int a, b, c;
 int d = 3, e, f = 5;
 byte z = 22;
 double pi = 3.14159;
 char X = ‘x’;

30. Inicialización dinámica
 Se hace utilizando expresiones validas en
el instante en el que la variable es
declarada.

31. Tipos simples
 Enteros
 byte, short, int y long
 Números en coma flotante
 float
 double
 Caracteres
 Char
 Booleano
 boolean

32. • Enteros:
• Byte
• Tamaño 8-bits.
• Valores entre -128 y 127.

33. • Enteros:
• short
• Tamaño 16-bits.
• Entre -32,768 y 32,767.

34. • Enteros:
• int
• Tamaño 32-bits.
• Entre -2,147,483,648 y 2,147,483,647.

35. • Enteros:
• long
• Tamaño 64-bits.
• Entre -9,223,372,036,854,775,808 y
9,223,372,036,854,775,807.

36. Ejercicio
 //calcula la distancia que recorre la luz.
utiliza variables long

37. class Luz{
public static void main(String args[]){
int velocidadluz;
long dias;
long segundos;
long distancia;
//velocidad aproximada de la luz en kilometros por segundo = 30000;
velocidadluz = 300000;
dias = 1000; //especifica el número de dias
segundos = dias * 24 * 60 * 60; //convierte a segundos
distancia = velocidadluz * segundos; // calcula la distancia
System.out.print("En " + dias);
System.out.print("dias la luz recorrera cerca de");
System.out.println(distancia + "kilometros");
}
}

38.  Números en coma flotante:
 float
 Tamaño 32-bits
 Con un rango de 3.4e-038 a 3.4e+038

39. • Números en coma flotante:
• double
• Tamaño 64-bits.
• Con un rango de 1.7e-308 a 1.7e+308

40. Ejercicio
 //Calcula el área de un circulo

41. class Area{
public static void main(String args[]){
double pi, r, a;
r = 10.8; //radio del circulo
pi = 3.1416; //pi, aproximadamente
a = pi * r * r; //calcula el area
System.out.println("El area del circulo es " + a);
}
}

42. • Caracteres:
• char
• Tamaño 16-bits.
• Unicode. Desde 'u0000' a 'uffff' inclusive.
Esto es desde 0 a 65535

43. Ejercicio
 //Muestra la utilización de variables de tipo
char

44. class CharDemo{
public static void main(String args[]){
char ch1, ch2;
ch1 = 88; //codigo de X
ch2 = 'Y';
System.out.print("ch1 y ch2: ");
System.out.println(ch1 + " " + ch2);
}
}

45. Ejercicio
 //las variables char se comportan como
enteros

46. class CharDemo2{
public static void main(String args[]){
char ch1;
ch1 = 'X';
System.out.println("ch1 contiene " + ch1);
ch1++; //incrementa ch1
System.out.println("ch1 es ahora " + ch1);
}
}

47. • Booleano:
• Boolean
• Puede contener los valores true o false.

48. Ejercicio
 Usa ya operadores de comparación
 Expresiones condicionales como:
 If
 For
 //Muestra la utilización de variables
booleanas

49. class BoolTest{
public static void main(String args[]){
boolean b;
b = false;
System.out.println("b es " +b);
b = true;
System.out.println("b es " +b);
//un valor boleano puede controlar la sentencia if
if(b)
System.out.println("Esta sentencia si se ejecuta.");
b = false;
if(b)
System.out.println("Esta sentencia no se ejecuta.");
//el resultado de un operador relacional es un valor boleano
System.out.println("10 > 9 es " + (10>9));
}
}

50. Inicialización dinámica
 Java permite que las variables sean
inicializadas dinámicamente utilizando
expresiones válidas en el instante en el
que la variable es requerida.

51. Ejercicio
 //Ejemplo de inicialización dinámica

52. class DynInit{
public static void main(String args[]){
double a = 3.0, b = 4.0;
//inicializa dinámicamente la variable c
double c = Math.sqrt(a * a + b * b);
System.out.println("La hipotenusa es " + c);
}
}

53. Ámbito y tiempo de vida de las
variables
 main()
 métodos
 públicas
 privadas

54. Ejercicio
 //Ejemplo del ámbito de un bloque

55. class Scope{
public static void main(String args[]){
int x; //visible por todo el código main
x = 10;
if(x==10){//comienza un nuevo ámbito
int y = 20; //visible sólo en este bloque
//x e y son visibles aqui
System.out.println("x e y: " + x + " " + y );
x = y * 2;
}
//y = 100; //Error! y no es visible aquí
//x todavía es visible aquí
System.out.println("x es " + x);
}
}

56.  Las variables se crean cuando se entra en
su ámbito y se destruyen cuando se sale
de su ámbito

57. Conversiones de tipos
 Java convierte automáticamente:
 Compatibles:
 int, long
 byte, short, long
 Java realiza un cast o conversión explicita entre
tipos no compatibles:
 No compatibles:
 double, byte
 char, boolean

58. Conversiones automáticas de Java
 Condiciones:
 Los dos tipos son compatibles
 El tipo destino es más grande que el tipo
origen

59.  ¿Qué ocurre?
 Un ensanchamiento o promoción.
 Ejemplo:
 El tipo int es suficientemente grande como para
almacenar un valor byte

60. Conversión de tipos incompatibles
 Por ejemplo si quiero convertir:
 inta byte
 byte es más pequeño que int
 Se le llama a este tipo de conversión
estrechamiento

61.  Se usa un cast
 Es una conversión de tipo explicita y tiene la
siguiente forma:
(tipo) valor
Donde:
tipo indica el tipo al que se ha de convertir el valor
especificado

62.  Ejemplo:
 Convierte de int a byte
int a;
byte b;
b = (byte) a;

63. Ejercicio
 //Ejemplo de conversión de tipo explícita

64. class Conversion{
public static void main(String args[]){
byte b;
int i = 257;
double d = 323.142;
System.out.println("nConversion de int a byte.");
b = (byte) i;
System.out.println("i y b: " +i + " " + b);
System.out.println("nConversion de double a int.");
i = (int) d;
System.out.println("d e i: " +d + " " + i);
System.out.println("nConversion de double a byte.");
b = (byte) d;
System.out.println("d y b: " +d + " " + b);
}
}

65. Promoción de tipo automática en
expresiones
 Se da cuando se supera el rango
permitido por el tipo de dato.
 Ejemplo:
 byte a = 40;
 byte b = 50;
 byte c = 100;
 Int d = a + b

66.  El resultado de a * b podría superar el
rango de cualquiera de sus operandos de
tipo byte
 Java promociona automáticamente los
operandos de tipo byte o short a int
cuando calcula la expresión

67. Reglas de promoción de tipos
 byte, shor a int
 long a long
 float a float
 double a double

68. Ejercicio
 //Revisión de las reglas de promoción

69. class Promote{
public static void main(String args[]){
byte b = 42;
char c = 'a';
short s = 1024;
int i = 50000;
float f = 5.67f;
double d = .1234;
double result = (f * b) + (i / c) - (d * s);
System.out.println((f * b) + " + " + (i / c) + " - " + (d *
s));
System.out.println("resultado = " + result);
}
}

70. Arreglos

71.  Una matriz o arreglo es un grupo de
variables del mismo tipo a las que se hace
referencia con el mismo nombre.
 Se pueden crear matrices de cualquier
tipo y pueden tener una o mas
dimensiones

72.  Se pueden declarar en Java arrays de cualquier
tipo:
 char s[ ];
int Array[ ];
 Incluso se pueden construir arrays de arrays:
 int tabla[ ][ ] = new int[4][5];
 Los límites de los arrays se comprueban en
tiempo de ejecución para evitar
desbordamientos y la corrupción de memoria.

73. Matriz unidimensional
1. tipo nombre_matriz [ ];
int dias[ ]; //declaración
2. nombre_matriz = new tipo [tamaño]
//new reserva memoria
dias = new int [12];

74.  Java reserva memoria dinámicamente

75. Ejercicio
 /Ejemplo de una matriz unidimensional

76. class Array{
public static void main(String args[]){
int dias[ ]; // p bien int dias[ ] = new int[12];
dias = new int[12];
dias[0] = 31;
dias[1] = 28;
dias[2] = 31;
dias[3] = 30;
dias[4] = 31;
dias[5] = 30;
dias[6] = 31;
dias[7] = 31;
dias[8] = 30;
dias[9] = 31;
dias[10] = 30;
dias[11] = 31;
System.out.println("Abril tiene " + dias[3] + "dias.");
}

77. Inicialización de matrices al
declararse
 Es una listas de expresiones separadas
por comas y entre llaves { }
 Los valores se separan con las comas

78. Ejercicio
 //Versión mejorada del programa anterior

79. class AutoArray{
public static void main(String args[]){
int dias[] =
{31,28,31,30,31,30,31,31,30,31,30,31};
System.out.println("Abril tiene " + dias[3] +
"dias");
}
}

80. Ejercicio
 //Calcula la media de los valores de una
matriz

81. class Media{
public static void main(String args[]){
double nums[] = {10.1, 11.2, 12.3, 13.4, 14.5};
double result = 0;
int i;
for(i=0; i<5; i++)
result = result + nums[i];
System.out.println("La media es " + result/5);
}
}

82.  En Java un array es realmente un objeto,
porque tiene redefinido el operador [ ].
 Tiene una función miembro: length. Se
puede utilizar este método para conocer la
longitud de cualquier array.

83. int a[][] = new int[10][3];
a.length; /* 10 */
a[0].length; /* 3 */

84.  Para crear un array en Java hay dos
métodos básicos.
Crear un array vacío:
 int lista[] = new int[50];

85.  o se puede crear ya el array con sus
valores iniciales:
String nombres[] =
{"Juan","Pepe","Pedro","Maria“ };

86.  Esto que es equivalente a:
String nombres[];
nombres = new String[4];
nombres[0] = new String( "Juan" );
nombres[1] = new String( "Pepe" );
nombres[2] = new String( "Pedro" );
nombres[3] = new String( "Maria" );

87.  No se pueden crear arrays estáticos en
tiempo de compilación:
 int lista[50]; // generará un error en tiempo
de compilación

88.  Tampoco se puede rellenar un array sin
declarar el tamaño con el operador new:
int lista[];
for(int i=0; i < 10; i++ )
lista[i] = i;

89.  Es decir, todos los arrays en Java son
estáticos. Para convertir un array en el
equivalente a un array dinámico en C/C+
+, se usa la clase vector, que permite
operaciones de inserción, borrado, etc. en
el array.

90. Matriz multidimensionales
 Son matrices de matrices

91. Declaración
 Bidimensional
 Int dosD[][] = new int [4][5];

92. Ejercicio
 //Ejemplo de una matriz bidimensional

93. class DosDArray{
public static void main(String args[]){
int dosD[][] = new int[4][5];
int i, j, k = 0;
for(i=0; i<4; i++)
for(j=0; j<5; j++){
dosD[i][j] = k;
k++;
}
for(i=0; i<4; i++){
for(j=0; j<5; j++)
System.out.println(dosD[i][j] + " ");
System.out.println("&&");
}
}
}

94.  Cuando se reserva memoria para una
matriz multidimensional, solo es necesario
especificar la memoria que necesita la
primera dimensión, después se reservara
para las otras dimensiones

95.  Ejemplo:
 int
dosD[][] = new int [4][];
 dosD[0] = new int[5];
 dosD[1] = new int[5];
 dosD[2] = new int[5];
 dosD[3] = new int[5];

96. Vista conceptual de matriz
bidimensional de 4 x 5
[0] [0] [0] [1] [0] [2] [0] [3] [0] [4]
[1] [0] [1] [1] [1] [2] [1] [3] [1] [4]
[2] [0] [2] [1] [2] [2] [2] [3] [2] [4]
[3] [0] [3] [1] [3] [2] [3] [3] [3] [4]

97. Ejercicio
 //Reserva distintos tamaños para la
segunda dimensión de cada elemento

98. class DosDArrayN{
public static void main(String args[]){
int dosD[][] = new int[4][];
dosD[0] = new int[1];
dosD[1] = new int[2];
dosD[2] = new int[3];
dosD[3] = new int[4];
int i, j, k = 0;
for(i=0; i<4; i++)
for(j=0; j<i+1; j++){
dosD[i][j] = k;
k++;
}
for(i=0; i<4; i++){
for(j=0; j<i+1; j++)
System.out.print(dosD[i][j] + " ");
System.out.println();
}
}
}

99. Inicialización de matrices
multidimensionales
 Es necesario encerrar entre llaves el
inicializador de cada dimensión

100. Ejercicio
 //Inicializa una matriz bidimensional

101. class Matrix{
public static void main(String args[]){
double m[][] = {
{ 0*0, 1*0, 2*0, 3*0 },
{ 0*1, 1*1, 2*1, 3*1 },
{ 0*2, 1*2, 2*2, 3*2 },
{ 0*3, 1*3, 2*3, 3*3 }
};
int i,j;
for(i=0; i<4; i++){
for(j=0; j<4; j++)
System.out.print(m[i][j] + " ");
System.out.println();
}
}
}

102. Ejercicio
 //Ejemplo de una matriz tridimensional

103. class threeDMatrix{
public static void main(String args[]){
int threeD[][][] = new int [3][4][5];
int i,j,k;
for(i=0; i<3; i++)
for(j=0; j<4; j++)
for(k=0; k<5; k++)
threeD[i][j][k] = i * j * k;
for(i=0; i<3; i++){
for(j=0; j<4; j++){
for(k=0; k<5; k++)
System.out.print(threeD[i][j][k] + " ");
System.out.println();
}
System.out.println();
}
}
}

104. Operadores

105.  Los operadores de Java son muy
parecidos en estilo y funcionamiento a los
de C. En la siguiente tabla aparecen los
operadores que se utilizan en Java, por
orden de precedencia:

106. [] ()
++ --
! ~
* / %
+ -
<< >>
< > <= >= == !=
& ^ |
&& ||

107.  Los operadores numéricos se comportan
como esperamos:
 int + int = int
 Los operadores relacionales devuelven un
valor booleano.

108.  Para las cadenas, se pueden utilizar los
operadores relacionales para
comparaciones además de + y += para la
concatenación:
 String nombre = "nombre" + "Apellido";

109.  El operador = siempre hace copias de
objetos, marcando los antiguos para
borrarlos, y ya se encargará el garbage
collector de devolver al sistema la
memoria ocupada por el objeto eliminado.

110. Operadores aritméticos
 + - * /
 % ++ -- -=
 *= /= %= --

111. Ejercicio
 //Muestra los operadores aritméticos
básicos

112. class BasicMath{
public static void main(String args[]){
//operaciones aritmeticas con enteros
System.out.println("Aritmetica con enteros");
int a = 1 + 1;
int b = a * 3;
int c = b / 4;
int d = c - a;
int e = -d;
System.out.println("a = " +a);
System.out.println("b = " +b);
System.out.println("c = " +c);
System.out.println("d = " +d);
System.out.println("e = " +e);
//aritmetica utilizando el tipo double
System.out.println("nAritmetica en coma flotante");
double da = 1 + 1;
double db = da * 3;
double dc = db / 4;
double dd = dc - a;
double de = -dd;
System.out.println("da = " + da);
System.out.println("db = " + db);
System.out.println("dc = " + dc);
System.out.println("dd = " + dd);
System.out.println("de = " + de);
}
}

113. Operador Modulo
 Devuelve el resto de un división.
 Se aplica tanto a tipos flotantes como a
enteros.

114. Ejercicio
 / El operador %

115. class Modulo{
public static void main(String args[]){
int x = 42;
double y = 42.3;
System.out.println("x mod 10 = " +x % 10);
System.out.println("y mod 10 = " +y % 10);
}
}

116. Asignaciones con operadores
aritméticos
 Combina una operación aritmética con
una asignación
 Ejemplo:
a = a + 4;
 a += 4;

117. Sintaxis:
 var = var operador expresión;
 var operador = expresión;

118. Ejercicio

119. Control de Flujo

120.  Muchas de las sentencias de control del
flujo del programa se han tomado del C:

121. Sentencias de Salto
if/else
if( Boolean ) {
sentencias;
}
else {
sentencias;
}

122. switch
switch( expr1 ) {
case expr2:
sentencias;
break;
case expr3:
sentencias;
break;
Default:
sentencias;
break;
}

123. Sentencias de Bucle

124. Bucles for
for( expr1 inicio; expr2 test; expr3 incremento )
{
sentencias;
}

125.  El siguiente trocito de código Java que
dibuja varias líneas en pantalla alternando
sus colores entre rojo, azul y verde. Este
fragmento sería parte de una función Java
(método):

126. int contador;
for( contador=1; contador <= 12; contador++ ) {
switch( contador % 3 ) {
case 0:
setColor( Color.red );
break;
case 1:
setColor( Color.blue );
break;
case 2:
setColor( Color.green );
break;
}
g.drawLine( 10,contador*10,80,contador*10 );
}

127. También se soporta el operador coma (,) en
los bucles for
for( a=0,b=0; a < 7; a++,b+=2 )

128. Bucles while
while( Boolean ) {
sentencias;
}

129. Bucles do/while
do {
sentencias;
}while( Boolean );

130. Manejo de memoria
y recolección de
basura

131.  Java tiene un colector automático de
basura. El manejo de memoria en Java
esta basado en objetos y referencias a
objetos. No hay apuntadores en Java.

132.  El manejador de memoria de Java lleva
un registro de las referencias a un objeto.
Cuando un objeto no tiene referencias
entonces se convierte en un candidato
para ser considerado basura.

133. Por ejemplo, veamos la siguiente clase:
// Voltea una cadena de caracteres
class CADENA_ALREVES
{
public static String volteala(String FUENTE)
{
int I,
LONGITUD = FUENTE.length();
StringBuffer DESTINO = new StringBuffer(LONGITUD);
for ( I = (LONGITUD - 1); I >= 0; I--)
{
DESTINO.appendChar(FUENTE.charAt(I));
}
return DESTINO.toString();
}
}

134.  En este ejemplo la variable DESTINO es
usada como un objeto temporal de
referencia durante la ejecución del
proceso de invertir una cadena. Cuando el
método "volteala" llega a su return la
referencia al objeto DESTINO ya no
existe, siendo entonces DESTINO un
candidato a ser basura.

135.  Los elementos de clase String (como FUENTE)
tienen los métodos length y charAt (el cual
regresa el caracter correspondiente a la posicion
indicada). Los elementos de la clase
StringBuffer tienen los métodos appendChar (el
cual incluye un caracter al final del buffer) y
toString (el cual transforma los datos del buffer
en una representación de tipo String).