Conceptos básicos de Java: sobrecarga de métodos, clases abstractas y eventos de ventana, Apuntes de Programación Java

¡Descarga Conceptos básicos de Java: sobrecarga de métodos, clases abstractas y eventos de ventana y más Apuntes en PDF de Programación Java solo en Docsity!

Abraham Otero Quintana

elabra@usc.es

1 JAVA, EL LENGUAJE

1.1 INTRODUCCIÓN

Estamos en unos días en los que cada vez más la informática invade más campos de nuestra vida, estando el ciudadano medio cada vez más familiarizado con términos del mundo informático, entre ellos, como no, los lenguajes de programación. A cualquier persona que haya empleado alguna vez un ordenador le resultará familiar alguno de estos nombres: C, Pascal, Cobol, Visual Basic, Java, Fortran ..... y a una persona ya más introducida en ese mundillo posiblemente haya oído muchos otros: Oak, Prolog, Dbase, JavaScrip, Delphi, Simula, Smalltalk, Modula, Oberon, Ada, BCPL, Common LISP, Scheme... En la actualidad se podrían recopilar del orden de varios cientos de lenguajes de programación distintos, sino miles.

Cabe hacerse una pregunta: ¿Para qué tanto lenguaje de programación?. Toda esta multitud de nombres puede confundir a cualquier no iniciado que haya decidido aprender un lenguaje, quien tras ver las posibles alternativas no sabe cual escoger, al menos entre los del primer grupo, que por ser más conocidos deben estar más extendidos.

El motivo de esta disparidad de lenguajes es que cada uno ha sido creado para una determinada función, está especialmente diseñado para facilitar la programación de un determinado tipo de problemas, para garantizar seguridad de las aplicaciones, para obtener una mayor facilidad de programación, para conseguir un mayor aprovechamiento de los recursos del ordenador... Estos objetivos son muchos de ellos excluyentes: el adaptar un lenguaje a un tipo de problemas hará más complicado abordar mediante este lenguaje la programación de otros problemas distintos de aquellos para los que fue diseñado. El facilitar el aprendizaje al programador disminuye el rendimiento y aprovechamiento de los recursos del ordenador por parte de las aplicaciones programadas en este lenguaje; mientras que primar el rendimiento y aprovechamiento de los recursos del ordenador dificulta la labor del programador.

La pregunta que viene a continuación es evidente: ¿Para qué fue pensado Java?. A esto responderemos en el siguiente apartado.

mientas que bajo Windows lo hace en big endian. Java lo hace siempre en little edian para evitar confusiones.

1.2.7 Arquitectura Neutral

El código generado por el compilador Java es independiente de la arquitectura: podría ejecutarse en un entorno UNIX, Mac o Windows. El motivo de esto es que el que realmente ejecuta el código generado por el compilador no es el procesador del ordenador directamente, sino que este se ejecuta mediante una máquina virtual. Esto permite que los Applets de una web pueda ejecutarlos cualquier máquina que se conecte a ella independientemente de que sistema operativo emplee (siempre y cuando el ordenador en cuestión tenga instalada una máquina virtual de Java).

1.2.8 Rendimiento medio

Pese a todos los esfuerzos hechos por Sun y a haberse logrado grandes progresos desde las primeras versiones, Java sigue siendo un lenguaje que no aprovecha los recursos de la máquina, obteniendo un rendimiento muy inferior al de C. Esto se debe a que esta característica se ha sacrificado para facilitar la programación y sobre todo para conseguir la característica de neutralidad arquitectural. De todos modos, es posible aumentar el rendimiento de Java empleando compiladores just in time, compiladores que traduce los bytecodes de Java en código para una determinada CPU, que no precisa de la máquina virtual para ser ejecutado, y guardan el resultado de dicha conversión, volviéndolo a llamar en caso de volverlo a necesitar. Esta técnica mejora sobre todo el rendimiento de los bucles.

1.2.9 Multithread

Soporta de modo nativo los threads, sin necesidad del uso de de librerías específicas (como es el caso de C++).

1.3 JAVA FRENTE A LOS DEMÁS LENGUAJES

Java es un lenguaje relativamente moderno. Su primer uso en una “tarea seria” de programación fue la construcción del navegador HotJava por parte de la empresa Sun en mayo de 1995, y fue a principios de 1996 cuando Sun distribuye la primera versión de Java. Es esta corta edad lo que hace que Java esté más orientado al mundo web, que no existía cuando, por ejemplo, C fue desarrollado. También es esto lo que ha hecho que soporte de modo nativo (no mediante el uso de librerías, como C) los threads, siendo posible aprovechar las ventajas de los sistemas multiprocesadores.

Las ventajas fundamentales de Java frente a otros lenguajes son el menor periodo de aprendizaje por parte del programador, llegando a ser un programador productivo en menos tiempo (sencillez) y siendo posible desarrollar aplicaciones más rápido que en otros lenguajes (sencillez y robustez), lo cual se traduce en el mundo empresarial en un ahorro de costes.

Sus cualidades de distribuido, seguro e independencia de la plataforma lo hacen ideal para aplicaciones relacionadas con el mundo web; precisamente a esto es a lo que Java debe su gran difusión y fama. El hecho de que sea independiente de la máquina y del sistema operativo permite que distintas máquinas con distintos sistemas operativos se conecten a una misma página web y ejecuten los mismos applets. Además la seguridad que garantiza Java para los applets impiden que alguien trate de averiguar información sobre los usuarios que se conectan a la página web o intente dañar sus máquinas. En cuanto a su capacidad de soporte de threads y su capacidad de sacarle partido a sistemas multiprocesador lo convierten en un lenguaje más “orientado hacia el futuro “. Estas cualidades podrían dar pie a que algún día los rendimientos computacionales de Java sean comparables con los de C++ y otros lenguajes que hoy son computacionalmente más eficientes.

2.3 APPLETVIEWER

Se trata de un comando que verifica el comportamiento de un applet. La entrada del comando ha de ser una página web que contenga una referencia al applet que deseamos probar. Su sintaxis es:

Appletviewer mipagina.html

El comando ignora todo el contenido de la página web que no sean applets y se limita a ejecutarlos. Un ejemplo de página web “mínima” para poder probar un applet llamado myapplet.class sería:

2.4 JAVADOC

Este útil comando permite generar documentación en formato html sobre el contenido de ficheros con extensión .Java. Su sintaxis es:

Javadoc ejemplo.Java

En la documentación generada por este comando se puede ver que métodos y constructores posee una determinada clase, junto con comentarios sobre su uso, si posee inner classes, la versión y el autor de la clase.... Una explicación detallada de la sintaxis de los comentarios de javadoc, que aquí no abordaremos, se encuentra el capítulo 2 página 122 del libro Thinking in Java de Bruce Eckel

( http://www.bruceeckel.com/ ).

A continuación suministramos el código Java de un ejemplo

//: c02:HelloDate.Java

import java.util.*;

/**Displays a string and today's date.

* @author Bruce Eckel

* @author www.BruceEckel.com

* @version 2.

public class HelloDate {

/** Sole entry point to class & application

* @param args array of string arguments

* @return No return value

* @exception exceptions No exceptions thrown

public static void main(String[] args) {

//Esta línea imprime por consola la cadena de caracteres

//“Hello it’s”

System.out.println("Hello, it's: ");

//Esta sentencia imprime la fecha actual del equipo

System.out.println(new Date());

3.1.2 Reales

Almacenan número reales, es decir números con parte fraccionaria. Hay dos tipos:

Tabla 2: tipos de datos reales en Java

Tipo (^) Tamaño (bytes) Rango

Float (^4) + 3.40282347E+

Double 8 + 179769313486231570E+

Si queremos indicar que una constante es flotante: ej: 2.3 hemos de escribir: 2.3F, sino por defecto será double.

3.1.3 Caracteres

En Java hay un único tipo de carácter: char. Cada carácter en Java esta codificado en un formato denominado Unicode, en este formato cada carácter ocupa dos bytes, frente a la codificación en ASCII, dónde cada carácter ocupaba un solo byte. Unicode es una extensión de ASCII, ya que éste último al emplear un byte por carácter sólo daba acogida a 256 símbolos distintos. Para poder aceptar todos los alfabetos (chino, japonés, ruso...) y una mayor cantidad de símbolos se creó el formato Unicode. En Java al igual que en C se distingue la representación de los datos char frente a las cadenas de caracteres. Los char van entre comillas simples: char ch = ‘a’, mientras que las cadenas de caracteres usan comillas dobles.

3.1.4 Boolean

Se trata de un tipo de dato que solo puede tomar dos valores: “true” y “false”. Es un tipo de dato bastante útil a la hora de realizar chequeos sobre condiciones. En C no hay un dato equivalente y para suplir su ausencia muchas veces se emplean enteros con valor 1 si “true” y 0 si “false”. Otros lenguajes como Pascal sí tiene este tipo de dato.

3.2 VARIABLES

Al igual que C, Java requiere que se declaren los tipos de todas las variables empleadas. La sintaxis de iniciación es la misma que C:

int i;

Sin embargo, y a diferencia que en C, se requiere inicializar todas las variables antes de usarlas, si no el compilador genera un error y aborta la compilación. Se puede inicializar y asignar valor a una variable en una misma línea:

int i = 0;

Asignación e inicialización pueden hacerse en líneas diferentes:

int i ; i = 0;

Es posible iniciar varias variables en una línea:

int i, j,k;

Después de cada línea de código, bien sea de iniciación o de código, al igual que en C va un ;.

En Java, al igual que en todo lenguaje de programación hay una serie de palabras reservadas que no pueden ser empleadas como nombres de variables (if, int, char, else, goto....); alguna de estas se emplean en la sintaxis del lenguaje, otras, como goto no se emplean en la actualidad pero se han reservado por motivos de compatibilidad por si se emplean en el futuro. Los caracteres aceptados en el nombre de una variable son los comprendidos entre “A-Z”, “a- z”, _, $ y cualquier carácter que sea una letra en algún idioma.

3.3 CONVERSIÓN ENTRE TIPOS NUMÉRICOS

Las normas de conversión entre tipos numéricos son las habituales en un lenguaje de programación: si en una operación se involucran varios datos numéricos de distintos tipos todos ellos se convierten al tipo de dato que permite una mayor precisión y rango de representación numérica; así, por ejemplo:

3.4 OPERADORES

Los operadores básicos de Java son + , - , * , / para suma, resta, producto y división. El operador / representa la división de enteros si ambos operandos son enteros. Su módulo puede obtenerse mediante el operador %. Además existen los operadores decremento e incremento: -- y ++ respectivamente. La operación que realizan son incrementar y decrementar en una unidad a la variable a la que se aplican. Su acción es distinta según se apliquen antes (++a) o después (a++) de la variable. El siguiente programa ilustra estos distintos efectos:

public class ejemplo2{

public static void main(String[] args) {

int i = 1;

prt("i : " + i);

prt("++i : " + ++i); // Pre-incremento, primero

//incrementa y luego imprime por consola

prt("i++ : " + i++); // Post-incremento, primero imprime

//“2” por consola y luego incrementa i.

prt("i : " + i);//i por lo tanto vale 3

prt("--i : " + --i); // Pre-decremento, primero

//decrementa i y luego lo imprime por consola

prt("i-- : " + i--); // Post-decremento, primero imprime

//i por consola y luego de decrementa.

prt("i : " + i);//Ahora i vale 1

//esto nos ahorrara teclear. Invocando a prt podremos

//imprimir por consola la cadena de caracteres que le pasemos

static void prt(String s) {

System.out.println(s);

3.4.1 Exponenciación

En Java a diferencia que en otros lenguajes no existe el operador exponenciación. Tampoco existen los operadores Seno o Coseno. Si se desea realizar una operación de exponenciación

se deberá invocar el método correspondiente de la clase Math de Java.lang. Estos métodos son estáticos, por lo que no es necesario crear un objeto de dicha clase. Su sintaxis general es:

Math.metodo(argumentos);

En el siguiente código aparecen ejemplos. Si alguna vez deseamos realizar algún otro tipo de operación y queremos ver si la soporta Java podemos hacerlo consultando la ayuda on-line de la clase Math.

public class ejemplo3 {

public static void main(String[] args) {

int i = 45,j=2;

//Imprime por consola la cadena de caracteres “Cos i : “

//concatenado con el resultado de calcular el coseno de i

prt("Cos i : " + Math.cos(i));

prt("Sen i : " + Math.sin(i));

prt("j^i : " + Math.pow(j,i));

//esto nos ahorrara teclear

static void prt(String s) {

System.out.println(s);

3.4.2 Operadores lógicos

En la tabla a continuación recogemos los operadores lógicos disponibles en Java:

Tabla 3: operadores lógicos

Operador Operación que realiza ! Not lógico == Test de igualdad != Test de desigualdad

prt("(i < 10) || (j < 10) es "

+ ((i < 10) || (j < 10)) );

static void prt(String s) {

System.out.println(s);

Una posible salida de este programa es:

i = 85

j = 4

i > j es true

i < j es false

i >= j es true

i <= j es false

i == j es false

i != j es true

//true && false = false

(i < 10) && (j < 10) es false

//true || false = true

(i < 10) || (j < 10) es true

3.5 CADENAS DE CARACTERES

En Java no hay un tipo predefinido para cadenas de caracteres, en su lugar hay una clase, String, que es la que soporta las distintas operaciones con cadenas de caracteres. La definición de un String es:

String e ; //no inicializado String e =””; //cadena vacía String e = “Hola”; //inicialización y asignación juntas. A continuación veremos algunas operaciones básicas soportadas por la clase String:

3.5.1 Concatenación

La concatenación en Java es increíblemente sencilla: se realiza con el operador +, es decir “sumando” cadenas de caracteres obtenemos la concatenación de estas. Lo ilustraremos con un ejemplo:

String saludo = “hola”; String nombre = “Pepe”; String saluda_pepe = “”; saluda_pepe = saludo + nombre;// saluda_pepe toma el valor holaPepe

La sencillez de Java en el manejo de cadenas de caracteres llega incluso más alla: si una cadena la intentamos encadenar con otro tipo de variable automáticamente se convierte la otra variable a String, de tal modo que es perfectamente correcto:

String saludo = “hola”; int n = 5; saludo = saludo + “ “ + n;// saludo toma el valor “hola 5”

3.5.2 Subcadenas

En la clase String hay un método que permite la extracción de una subcadena de caracteres de otra. Su sintaxis es:

Nombre_String.substring((int)posición_inicial,(int)posición_final);

Donde posición_inicial y posición_final son respectivamente la posición del primer carácter que se desea extraer y del primer carácter que ya no se desea extraer.

String saludo = “hola”; String subsaludo = “”; Subsaludo = saludo.substring(0,2);// subsaludo toma el valor “ho”

Puede extraerse un char de una cadena, para ello se emplea el método charAt(posición), siendo posición la posición del carácter que se desea extraer.

3.6 ÁMBITO DE LAS VARIABLES

En este apartado vamos a tratar de ver cual es el ámbito de validez de una variable. Éste en Java viene dado por los corchetes: {}; una vez definida una variable en un código dejará de existir cuando se acabe el bloque de código en el que se definió. Los bloques de código empiezan con “{“ y acaban en “}”, por lo que la variable dejará de existir cuando se cierre el corchete que esté justo antes que ella en el código. Veámoslo con un ejemplo:

int x = 12;

/* solo x disponible */

int q = 96;

/* x y q disponible */

/* solo x disponible */

/* q “fuera de ámbito” */

Por otro lado si intentamos hacer lo siguiente:

int x = 12;

int x = 96; /* ilegal en Java, no en C++ */

El compilador se nos quejará diciendo que la variable x ya ha sido definida. En C++ esto si es posible, pero los diseñadores de Java decidieron no permitir este tipo de estructuras para lograr más claridad en el código.

3.7 ARRAYS

En Java los arrays son un objeto. Como tales se crean mediante el comando new (se verá su uso en el tema 5). La sintaxis en la definición de un array es la siguiente:

Tipo_datos[] nombre_array = new Tipo_datos[tamaño_array];

Tipo_datos es el tipo de los datos que se almacenarán en el array (int, char, String... o cualquier objeto). Tamaño_array es tamaño que le queremos dar a este array. Veamos un ejemplo:

Int[] edades = new int[10];

En este ejemplo hemos definido un array llamado edades, en el que podremos almacenar 10 datos tipo entero. El primer elemento de un array se sitúa en la posición 0, exactamente igual que en C. Si quisiésemos realizar un bucle que recorriese los elementos de este array escribiríamos un código del tipo:

for(int i= 0; i< 10; i+){

System.out.println(“Elemento “ + i + edades[i]);

3.8 JAVA NO ES PERFECTO

Ya hemos hecho hincapié en que Java esta diseñado para facilitar la labor del programador, disminuyendo los tiempos de aprendizaje y de programación gracias a su sencillez y a su capacidad de detectar errores; sin embargo, Java también tiene sus bugs: Java deja hacer overflow sin dar error ni en tiempo de compilación ni tan siquiera en tiempo de ejecución. Aquí tenéis la prueba

public class ejemplo6 {

public static void main(String[] args) {

//0x significa que el número está en formato hexadecimal.

// 0x7 = 0111 en binario

// 0xf = 1111 en binario