Librerías de Java

LSCA Alma Delia Otero Escobar

Existen diferentes librerías en Java, entre las cuales se encuentran:

java.lang

Colección de tipos básicos siempre importados a cualquier unidad decompilación. Aquí están las declaraciones de objetos, clases, threads,excepciones, wrappers de los tipos de datos primitivos y otras clasesfundamentales.

java.io

Archivos de stream y acceso aleatorio. Librería estándar de entrada ysalida.

java.netLibrería que apoya interfaces con telnet y URLs.

java.utilClases como diccionarios, tabla de hash, stack, técnicas de codificación y decodificación, hora, fecha, etcétera.

java.awtAbstract 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.

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

Serían identificadores válidos: y su uso sería, por ejemplo:

identificadornombre_usuarioNombre_Usuario

_variable_del_sistema$transaccion

int contador_principal;char _lista_de_ficheros;

float  $cantidad_en_Ptas;

Los siguientes caracteres pueden ser letras o dígitos. Se distinguen las mayúsculas de las minúsculas y no hay longitud máxima.

Literales

Un valor constante en Java se crea utilizando una representación literal de él.

Ejemplo:10098.6 ‘X’<<Esto es una prueba>>

Comentarios

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

Separadores

( ) 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

Palabras clave

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

abstract  continue  for  new  switch

 boolean  default  goto  null synchronized

 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                                  

Palabras Reservadas

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

cast  future  generic  inner

 operator  outer  rest  var

Literales

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.

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

Enteros Tipo    Por ejemplo

 byte 8 bits complemento a dos

 21 077 0xDC00

 short 16 bits complemento a dos

 int 32 bits complemento a dos

 long 64 bits complemento a dos

Reales en coma flotante:

 Tipo    Por ejemplo

 float 32 bits IEEE

754   3.18 2e12    3.1E12

 double 64 bits IEEE

754

Booleanos:

truefalse

Caracteres:

Por ejemplo:

a \t \u???? [????] es un número unicode

Cadenas:

Por ejemplo:

"Esto es una cadena"

Tipos de datos, variables y matrices

Sintaxis

Declaración de una variable:

tipo nombre_variable;

byte b,c;

Ejemplos:

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

Inicialización dinámica

Se hace utilizando expresiones validas en el instante en el que la variable es declarada.

Tipos simples

Enteros byte, short, int y long

Números en coma flotante float double

Caracteres Char

Booleano boolean

Enteros:

Byte Tamaño 8-bits. Valores entre -128 y 127.

Enteros:

short Tamaño 16-bits. Entre -32,768 y 32,767.

Enteros:

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

Enteros:

long Tamaño 64-bits. Entre -9,223,372,036,854,775,808 y

9,223,372,036,854,775,807.

Ejercicio

//calcula la distancia que recorre la luz. utiliza variables long

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 diassegundos = dias * 24 * 60 * 60; //convierte a segundosdistancia = velocidadluz * segundos; // calcula la distancia

System.out.print("En " + dias);System.out.print("dias la luz recorrera cerca de");System.out.println(distancia + "kilometros");

}}

Números en coma flotante:

float Tamaño 32-bits Con un rango de 3.4e-038 a 3.4e+038

Números en coma flotante:

double Tamaño 64-bits. Con un rango de 1.7e-308 a 1.7e+308

Ejercicio

//Calcula el área de un circulo

class Area{public static void main(String args[]){

double pi, r, a;

r = 10.8; //radio del circulopi = 3.1416; //pi, aproximadamentea = pi * r * r; //calcula el area

System.out.println("El area del circulo es " + a);}

}

Caracteres:

char Tamaño 16-bits. Unicode. Desde '\u0000' a '\uffff' inclusive.

Esto es desde 0 a 65535

Ejercicio

//Muestra la utilización de variables de tipo char

class CharDemo{public static void main(String args[]){

char ch1, ch2;

ch1 = 88; //codigo de Xch2 = 'Y';

System.out.print("ch1 y ch2: ");System.out.println(ch1 + " " + ch2);

}}

Ejercicio

//las variables char se comportan como enteros

class CharDemo2{public static void main(String args[]){

char ch1;

ch1 = 'X';System.out.println("ch1 contiene " + ch1);

ch1++; //incrementa ch1System.out.println("ch1 es ahora " + ch1);

}}

Booleano:

Boolean Puede contener los valores true o false.

Ejercicio

Usa ya operadores de comparación Expresiones condicionales como:

IfFor

//Muestra la utilización de variables booleanas

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 boleanoSystem.out.println("10 > 9 es " + (10>9));

}}

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.

Ejercicio

//Ejemplo de inicialización dinámica

class DynInit{public static void main(String args[]){

double a = 3.0, b = 4.0;

//inicializa dinámicamente la variable cdouble c = Math.sqrt(a * a + b * b);

System.out.println("La hipotenusa es " + c);}

}

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

Ejercicio

//Ejemplo del ámbito de un bloque

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 aquiSystem.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);

}}

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

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

Conversiones automáticas de Java

Condiciones:

Los dos tipos son compatiblesEl tipo destino es más grande que el tipo

origen

¿Qué ocurre?Un ensanchamiento o promoción.Ejemplo:

El tipo int es suficientemente grande como para almacenar un valor byte

Conversión de tipos incompatibles

Por ejemplo si quiero convertir: int a bytebyte es más pequeño que intSe le llama a este tipo de conversión

estrechamiento

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

Ejemplo: Convierte de int a byte

int a;

byte b;

b = (byte) a;

Ejercicio

//Ejemplo de conversión de tipo explícita

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);

}}

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

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

Reglas de promoción de tipos

byte, shor a int long a long float a float double a double

Ejercicio

//Revisión de las reglas de promoción

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);

}}

Arreglos

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

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.

Matriz unidimensional

1. tipo nombre_matriz [ ];

int dias[ ]; //declaración

2. nombre_matriz = new tipo [tamaño]//new reserva memoria

dias = new int [12];

Java reserva memoria dinámicamente

Ejercicio

/Ejemplo de una matriz unidimensional

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.");

}}

Inicialización de matrices al declararse Es una listas de expresiones separadas

por comas y entre llaves { } Los valores se separan con las comas

Ejercicio

//Versión mejorada del programa anterior

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");}

}

Ejercicio

//Calcula la media de los valores de una matriz

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);}

}

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.

int a[][] = new int[10][3];

a.length; /* 10 */

a[0].length; /* 3 */

Para crear un array en Java hay dos métodos básicos.

Crear un array vacío:

int lista[] = new int[50];

o se puede crear ya el array con sus valores iniciales:

String nombres[] = {"Juan","Pepe","Pedro","Maria“ };

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" );

No se pueden crear arrays estáticos en tiempo de compilación:

int lista[50]; // generará un error en tiempo de compilación

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;

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.

Matriz multidimensionales

Son matrices de matrices

Declaración

Bidimensional Int dosD[][] = new int [4][5];

Ejercicio

//Ejemplo de una matriz bidimensional

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("&&");}

}}

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

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];

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]

Ejercicio

//Reserva distintos tamaños para la segunda dimensión de cada elemento

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();}

}}

Inicialización de matrices multidimensionales Es necesario encerrar entre llaves el

inicializador de cada dimensión

Ejercicio

//Inicializa una matriz bidimensional

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();}

}}

Ejercicio

//Ejemplo de una matriz tridimensional

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();}

}}

Operadores

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:

[ ] ()        

++ --        

! ~        

* / %      

+ -        

<< >>      

< > <= >= == != 

 & ^ |      

&& ||        

Los operadores numéricos se comportan como esperamos:

int + int = int Los operadores relacionales devuelven un

valor booleano.

Para las cadenas, se pueden utilizar los operadores relacionales para comparaciones además de + y += para la concatenación:

String nombre = "nombre" + "Apellido";

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.

Operadores aritméticos

+ - * /

% ++ -- -=

*= /= %= --

Ejercicio

//Muestra los operadores aritméticos básicos

class BasicMath{public static void main(String args[]){

//operaciones aritmeticas con enterosSystem.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);

}}

Operador Modulo

Devuelve el resto de un división. Se aplica tanto a tipos flotantes como a

enteros.

Ejercicio

/ El operador %

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);

}}

Asignaciones con operadores aritméticos Combina una operación aritmética con

una asignación Ejemplo:

a = a + 4;a += 4;

Sintaxis:

var = var operador expresión;

var operador = expresión;

Ejercicio

Control de Flujo

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

Sentencias de Salto

if/else

if( Boolean ) {sentencias;}else {sentencias;}

switchswitch( expr1 ) {

case expr2: sentencias;

break;

case expr3: sentencias;

break;

Default: sentencias;

break;

}

Sentencias de Bucle

Bucles for

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

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):

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 );}

También se soporta el operador coma (,) en los bucles for

for( a=0,b=0; a < 7; a++,b+=2 )

Bucles while

while( Boolean ) {sentencias;}

Bucles do/while

do {sentencias;}while( Boolean );

Manejo de memoria y recolección de basura

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.

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.

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(); }}

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.

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).