¡Descarga Aprende Java desde cero y más Monografías, Ensayos en PDF de Programación Java solo en Docsity!
www.detodoprogramacion.com
- Página
- JAVA DESDE CERO
- QUÉ ES JAVA
- LENGUAJE DE OBJETOS
- INDEPENDIENTE DE LA PLATAFORMA
- ALGUNAS CARACTERÍSTICAS…
- EL JAVA DEVELOPMENT KIT
- EMPECEMOS DE UNA VEZ!
- JAVASCRIPT
- LAS CLASES EN JAVA
- ESTRUCTURA DE UNA CLASE
- ESTRUCTURA DE CLASES
- DECLARACIÓN DE LA CLASE
- EL CUERPO DE LA CLASE
- EL CUERPO DE LOS MÉTODOS
- DECLARACIÓN DE VARIABLES LOCALES
- ASIGNACIONES A VARIABLES
- OPERACIONES MATEMÁTICAS
- LLAMADAS A MÉTODOS
- LAS ESTRUCTURAS DE CONTROL
- IF…[ELSE]
- SWITCH…CASE…BRAKE…DEFAULT
- WHILE
- DO…WHILE
- FOR
- BREAK Y CONTINUE
- OTRAS...
- HAGAMOS ALGO...
- LA CLASE COMPLEJO
- ALGO SOBRE LOS MÉTODOS
- JAVA A TRAVÉS DE LA VENTANA
- NUESTRA PRIMERA VENTANA
- UNA VENTANA CON VIDA
- VIAJANDO CON JAVA
- COMPLETANDO LA VENTANA
- UN PARÉNTESIS DE ENTRADA/SALIDA
- PRIMERA LECTURA
- CAPTURANDO EXCEPCIONES
- LOS APPLETS Y LOS ARCHIVOS
- NUESTRO MODESTO "EDITOR"
- VOLVIENDO AL AWT
- MENÚ A LA JAVA
- DIÁLOGOS
- DIBUJAVA
- CANVAS EN ACCIÓN
- EL APPLET-CONTAINER
- NUESTRO CANVAS A MEDIDA
- DIBUJAVA II
- VECTORES EN ACCIÓN
- FLICKER MOLESTO!
- ANIMATE!
- JAVA EN HEBRAS
- LOS PASOS BÁSICOS
- REUNIÓN DE AMIGOS
- CREANDO THREADS
- Y LOS APPLETS...?
- LA LIEBRE Y LA TORTUGA (Y EL GUEPARDO)
- SINCRONICEMOS LOS RELOJES
- MÁS SINCRONIZACIÓN
- CAPÍTULO XV - SOLUCIÓN AL PROBLEMA PROPUESTO
- MULTIMEDIA!
- PARAMETRIZANDO UN APPLET
- PASEANDO POR LA RED
- LOS SOCKETS
Página 4
de desarrollo y debugging! En Java, inclusive, ni siquiera existen las variables globales! (Aunque parezca difícil de aceptar, esto es una gran ventaja desde el punto de vista del desarrollo). En cuanto a la herencia, simplemente significa que se pueden crear nuevas clases que hereden de otras preexistentes; esto simplifica la programación, porque las clases hijas incorporan automáticamente los métodos de las madres. Por ejemplo, nuestra clase "auto" podría heredar de otra más general, "vehículo", y simplemente redefinir los métodos para el caso particular de los automóviles… lo que significa que, con una buena biblioteca de clases, se puede reutilizar mucho código inclusive sin saber lo que tiene adentro.
Un ejemplo simple
Para ir teniendo una idea, vamos a poner un ejemplo de una clase Java:
public class Muestra extends Frame { // atributos de la clase Button si; Button no; // métodos de la clase: public Muestra () { Label comentario = new Label("Presione un botón", Label.CENTER); si = new Button("Sí"); no = new Button("No"); add("North", comentario); add("East", si); add("West", no); } }
Esta clase no está muy completa así, pero da una idea… Es una clase heredera de la clase Frame (un tipo de ventana) que tiene un par de botones y un texto. Contiene dos atributos ("si" y "no"), que son dos objetos del tipo Button , y un único método llamado Muestra (igual que la clase, por lo que es lo que se llama un constructor ).
Independiente de la plataforma
Esto es casi del todo cierto… En realidad, Java podría hacerse correr hasta sobre una Commodore 64! La realidad es que para utilizarlo en todo su potencial, requiere un sistema operativo multithreading (como Unix, Windows95, OS/2…). Cómo es esto? Porque en realidad Java es un lenguaje interpretado… al menos en principio. Al compilar un programa Java, lo que se genera es un seudocódigo definido por Sun, para una máquina genérica. Luego, al correr sobre una máquina dada, el software de ejecución Java simplemente interpreta las instrucciones, emulando a dicha máquina genérica. Por supuesto esto no es muy eficiente, por lo que tanto Netscape como Hotjava o Explorer, al ejecutar el código por primera vez, lo van compilando (mediante un JIT : J ust I n T ime compiler), de modo que al crear por ejemplo la segunda instancia de un objeto el código ya esté compilado específicamente para la máquina huésped. Además, Sun e Intel se han puesto de acuerdo para desarrollar procesadores que trabajen directamente en Java, con lo que planean hacer máquinas muy baratas que puedan conectarse a la red y ejecutar aplicaciones Java cliente-servidor a muy bajo costo. El lenguaje de dicha máquina genérica es público, y si uno quisiera hacer un intérprete Java para una Commodore sólo tendría que implementarlo y pedirle a Sun la aprobación (para que verifique que cumple con los requisitos de Java en cuanto a cómo interpreta cada instrucción, la seguridad, etc.)
Algunas características…
Entre las características que nombramos nos referimos a la robustez. Justamente por la forma en que está diseñado, Java no permite el manejo directo del hardware ni de la memoria (inclusive no permite modificar
www.detodoprogramacion.com
Página 5
valores de punteros, por ejemplo); de modo que se puede decir que es virtualmente imposible colgar un programa Java. El intérprete siempre tiene el control. Inclusive el compilador es suficientemente inteligente como para no permitir un montón de cosas que podrían traer problemas, como usar variables sin inicializarlas, modificar valores de punteros directamente, acceder a métodos o variables en forma incorrecta, utilizar herencia múltiple, etc. Además, Java implementa mecanismos de seguridad que limitan el acceso a recursos de las máquinas donde se ejecuta, especialmente en el caso de los Applets (que son aplicaciones que se cargan desde un servidor y se ejecutan en el cliente). También está diseñado específicamente para trabajar sobre una red, de modo que incorpora objetos que permiten acceder a archivos en forma remota (via URL por ejemplo). Además, con el JDK (Java Development Kit) vienen incorporadas muchas herramientas, entre ellas un generador automático de documentación que, con un poco de atención al poner los comentarios en las clases, crea inclusive toda la documentación de las mismas en formato HTML!
El Java Development Kit
Todo lo que puedan pedir para desarrollar aplicaciones en Java está en:
- http://java.sun.com/aboutJava/index.html En particular, deberían bajarse el JDK y el API Documentation de:
- http://java.sun.com/java.sun.com/products/JDK/1.0.2/index.html (También les puede interesar en particular el Tool Documentation y alguno de los otros paquetes de la página) Nota: en este site también hay un tutorial de Java, aunque es un poco difícil de seguir para el principiante. El JDK (versión 1.0.2) está disponible para SPARC/Solaris, x86/Solaris, MS-Windows 95/NT, y MacOS. También está disponible el fuente para el que quiera adaptarlo para otro sistema operativo, y he leído por ahí que hay una versión dando vueltas para Linux y HP-UX. Básicamente, el JDK consiste de:
- el compilador Java, javac
- el intérprete Java, java
- un visualizador de applets, appletviewer
- el debugger Java, jdb (que para trabajar necesita conectarse al server de Sun)
- el generador de documentación, javadoc También se puede bajar del mismo site un browser que soporta Java (y de hecho está escrito totalmente en Java), el Hotjava. Para instalarlo simplemente hay que descompactar el archivo (sugiero que creen un directorio java para eso), pero tengan en cuenta NO DESCOMPRIMIR el archivo classes.zip! Importante para los usuarios de Windows95: todas estas aplicaciones deben ejecutarse desde una ventana DOS. En particular, utilizan nombres largos y distinguen mayúsculas de minúsculas, así que tengan en cuenta esto que es fuente de muchos errores. Una cosa muy importante: para que todo ande bien aceitado, agreguen:
- el directorio de los programas en el path (ej: c:\java\bin)
- las variables de entorno:
- CLASSPATH=.;C:\java\lib\classes.zip
- HOMEDRIVE=C:
- HOMEPATH=\
- HOME=C: con los valores adecuados a su entorno. Noten que en CLASSPATH agregué el directorio actual (.), para poder compilar y ejecutar desde cualquier directorio.
Empecemos de una vez!
Bueno, suponiendo que hayan instalado todo, y antes de comenzar a programar en Java, una pequeña aclaración :
www.detodoprogramacion.com
Página 7
La función asigna al valor del campo resultado del form que se le pasa como parámetro ( form.resultado.value ) el resultado de eval uar el valor de la expresión del campo expr de dicho form ( eval(form.expr.value) ). Hay MUCHOS ejemploes de Javascript en:
- http://www.c2.net/~andreww/javascript/ incluyendo decenas de calculadoras, juegos y otras yerbas! Allí también encontrarán la documentación y un tutorial sobre Javascript.
Las clases en Java
Bueno, antes que nada conviene saber que en Java hay un montón de clases ya definidas y utilizables. Éstas vienen en las bibliotecas estándar:
- java.lang - clases esenciales, números, strings, objetos, compilador, runtime, seguridad y threads (es el único paquete que se incluye automáticamente en todo programa Java)
- java.io - clases que manejan entradas y salidas
- java.util - clases útiles, como estructuras genéricas, manejo de fecha, hora y strings, número aleatorios, etc.
- java.net - clases para soportar redes: URL, TCP, UDP, IP, etc.
- java.awt - clases para manejo de interface gráfica, ventanas, etc.
- java.awt.image - clases para manejo de imágenes
- java.awt.peer - clases que conectan la interface gráfica a implementaciones dependientes de la plataforma (motif, windows)
- java.applet - clases para la creación de applets y recursos para reproducción de audio. Para que se den una idea, los números enteros, por ejemplo, son "instancias" de una clase no redefinible, Integer , que desciende de la clase Number e implementa los siguientes atributos y métodos:
public final class java.lang.Integer extends java.lang.Number { // Atributos public final static int MAX_VALUE; public final static int MIN_VALUE; // Métodos Constructores public Integer(int value); public Integer(String s); // Más Métodos public double doubleValue(); public boolean equals(Object obj); public float floatValue(); public static Integer getInteger(String nm); public static Integer getInteger(String nm, int val); public static Integer getInteger(String nm, Integer val); public int hashCode(); public int intValue(); public long longValue(); public static int parseInt(String s); public static int parseInt(String s, int radix); public static String toBinaryString(int i); public static String toHexString(int i); public static String toOctalString(int i); public String toString(); public static String toString(int i);
www.detodoprogramacion.com
Página 8
public static String toString(int i, int radix); public static Integer valueOf(String s); public static Integer valueOf(String s, int radix); } Mucho, no? Esto también nos da algunas ideas:
- la estructura de una clase
- caramba, hay métodos repetidos! De la estructura enseguida hablaremos; en cuanto a los métodos repetidos (como parseInt por ejemplo), al llamarse al método el compilador decide cuál de las implementaciones del mismo usar basándose en la cantidad y tipo de parámetros que le pasamos. Por ejemplo, parseInt("134") y parseInt("134",16), al compilarse, generarán llamados a dos métodos distintos.
Estructura de una clase
Una clase consiste en:
algunas_palabras class nombre_de_la_clase [algo_más] { [lista_de_atributos] [lista_de_métodos] } Lo que está entre [ y ] es opcional… Ya veremos qué poner en "algunas_palabras" y "algo_más", por ahora sigamos un poco más. La lista de atributos (nuestras viejas variables locales) sigue el mismo formato de C: se define primero el tipo y luego el nombre del atributo, y finalmente el ";". public final static int MAX_VALUE ; También tenemos "algunas_palabras" adelante, pero en seguida las analizaremos. En cuanto a los métodos, también siguen la sintaxis del C; un ejemplo:
public int incContador() { // declaración y apertura de { cnt++; // instrucciones, separadas por ";" return(cnt); } // cierre de } Finalmente, se aceptan comentarios entre /* y */, como en C, o bien usando // al principio del comentario (el comentario termina al final de la línea). Veamos un ejemplo:
// Implementación de un contador sencillo // GRABAR EN UN ARCHIVO "Contador.java" (OJO CON LAS MAYUSCULAS!) // COMPILAR CON: "javac Contador.java" (NO OLVIDAR EL .java!) // ESTA CLASE NO ES UNA APLICACION, pero nos va a servir enseguida
public class Contador { // Se define la clase Contador
// Atributos int cnt; // Un entero para guardar el valor actual
// Constructor // Un método constructor… public Contador() { // …lleva el mismo nombre que la clase cnt = 0; // Simplemente, inicializa (1) }
// Métodos
www.detodoprogramacion.com
Página 10
// Applet de acción similar a la aplicación Ejemplo // GRABAR EN ARCHIVO: "Ejemplo2.java" // COMPILAR CON: "javac Ejemplo2.java" // PARA EJECUTAR: Crear una página HTML como se indica luego import java.applet.; import java.awt.;
public class Ejemplo2 extends Applet { static int n; static Contador laCuenta;
// Constructor… public Ejemplo2 () { laCuenta = new Contador(); }
// El método paint se ejecuta cada vez que hay que redibujar // NOTAR EL EFECTO DE ESTO CUANDO SE CAMBIA DE TAMAÑO LA // VENTANA DEL NAVEGADOR! public void paint (Graphics g) { g.drawString ("Cuenta...", 20, 20); g.drawString (String.valueOf(laCuenta.getCuenta()), 20, 35 ); n = laCuenta.incCuenta(); g.drawString (String.valueOf(n), 20, 50 ); laCuenta.incCuenta(); g.drawString (String.valueOf(laCuenta.getCuenta()), 20, 65 ); g.drawString (String.valueOf(laCuenta.incCuenta()), 20, 80 ); } }
Ahora es necesario crear una página HTML para poder visualizarlo. Para esto, crear y luego cargar el archivo ejemplo2.htm con un browser que soporte Java (o bien ejecutar en la ventana DOS: "appletviewer ejemplo2.htm"):
Ejemplo 2 - Applet Contador
Para terminar este capítulo, observemos las diferencias entre la aplicación standalone y el applet:
- La aplicación usa un método main, desde donde arranca
- El applet, en cambio, se arranca desde un constructor (método con el mismo nombre que la clase) Además:
- En la aplicación utilizamos System.out.println para imprimir en la salida estándar
- En el applet necesitamos "dibujar" el texto sobre un fondo gráfico, por lo que usamos el método g.drawString dentro del método paint (que es llamado cada vez que es necesario redibujar el applet) Con poco trabajo se pueden combinar ambos casos en un solo objeto, de modo que la misma clase sirva para utilizarla de las dos maneras:
www.detodoprogramacion.com
Página 11
// Archivo: Ejemplo3.java // Compilar con: javac Ejemplo3.java import java.applet.; import java.awt.; import java.io.*;
public class Ejemplo3 extends Applet { static int n; static Contador laCuenta;
public Ejemplo3 () { laCuenta = new Contador(); }
public static void main(String args[]) { laCuenta = new Contador(); paint(); }
public static void paint () { System.out.println ("Cuenta..."); System.out.println (laCuenta.getCuenta()); n = laCuenta.incCuenta(); System.out.println (n); laCuenta.incCuenta(); System.out.println (laCuenta.getCuenta()); System.out.println (laCuenta.incCuenta()); } public void paint (Graphics g) { g.drawString ("Cuenta...", 20, 20); g.drawString (String.valueOf(laCuenta.getCuenta()), 20, 35 ); n = laCuenta.incCuenta(); g.drawString (String.valueOf(n), 20, 50 ); laCuenta.incCuenta(); g.drawString (String.valueOf(laCuenta.getCuenta()), 20, 65 ); g.drawString (String.valueOf(laCuenta.incCuenta()), 20, 80 ); } } Esta clase puede ejecutarse tanto con "java Ejemplo3" en una ventana DOS, como cargarse desde una página HTML con:
Notar que conviene probar el applet con el appletviewer ("appletviewer ejemplo3.htm"), ya que éste indica en la ventana DOS si hay algún error durante la ejecución. Los browsers dejan pasar muchos errores, simplemente suprimiendo la salida a pantalla del código erróneo.
Notar que en todo este desarrollo de las clases Ejemplo1, Ejemplo2 y Ejemplo3, en ningún momento volvimos a tocar la clase Contador!
www.detodoprogramacion.com
Página 13
[ public ] [ fina l | abstract ] class Clase [ extends ClaseMadre] [ implements Interfase1 [, Interfase2 ]…] o bien, para interfaces: [ public ] interface Interfase [ extends InterfaseMadre1 [, InterfaseMadre2 ]…] Como se ve, lo único obligatorio es class y el nombre de la clase. Las interfases son un caso de clase particular que veremos más adelante.
Public, final o abstract
Definir una clase como pública ( public ) significa que puede ser usada por cualquier clase en cualquier paquete. Si no lo es, solamente puede ser utilizada por clases del mismo paquete (más sobre paquetes luego; básicamente, se trata de un grupo de clases e interfaces relacionadas, como los paquetes de biblioteca incluídos con Java). Una clase final ( final ) es aquella que no puede tener clases que la hereden. Esto se utiliza básicamente por razones de seguridad (para que una clase no pueda ser reemplazada por otra que la herede), o por diseño de la aplicación. Una clase abstracta ( abstract ) es una clase que puede tener herederas, pero no puede ser instanciada. Es, literalmente, abstracta (como la clase Number definida en java.lang). ¿Para qué sirve? Para modelar conceptos. Por ejemplo, la clase Number es una clase abstracta que representa cualquier tipo de números (y sus métodos no están implementados: son abstractos); las clases descendientes de ésta, como Integer o Float , sí implementan los métodos de la madre Number , y se pueden instanciar. Por lo dicho, una clase no puede ser final y abstract a la vez (ya que la clase abstract requiere descendientes…) ¿Un poco complejo? Se va a entender mejor cuando veamos casos particulares, como las interfases (que por definición son abstractas ya que no implementan sus métodos).
Extends
La instrucción extends indica de qué clase desciende la nuestra. Si se omite, Java asume que desciende de la superclase Object. Cuando una clase desciende de otra, esto significa que hereda sus atributos y sus métodos (es decir que, a menos que los redefinamos, sus métodos son los mismos que los de la clase madre y pueden utilizarse en forma transparente, a menos que sean privados en la clase madre o, para subclases de otros paquetes, protegidos o propios del paquete). Veremos la calificación de métodos muy pronto, a no desesperar!
Implements
Una interfase ( interface ) es una clase que declara sus métodos pero no los implementa; cuando una clase implementa ( implements ) una o más interfases, debe contener la implementación de todos los métodos (con las mismas listas de parámetros) de dichas interfases. Esto sirve para dar un ascendiente común a varias clases, obligándolas a implementar los mismos métodos y, por lo tanto, a comportarse de forma similar en cuanto a su interfase con otras clases y subclases.
Interface
Una interfase ( interface ), como se dijo, es una clase que no implementa sus métodos sino que deja a cargo la implementación a otras clases. Las interfases pueden, asimismo, descender de otras interfases pero no de otras clases. Todos sus métodos son por definición abstractos y sus atributos son finales (aunque esto no se indica en el cuerpo de la interfase). Son útiles para generar relaciones entre clases que de otro modo no están relacionadas (haciendo que implementen los mismos métodos), o para distribuir paquetes de clases indicando la estructura de la interfase pero no las clases individuales (objetos anónimos). Si bien diferentes clases pueden implementar las mismas interfases, y a la vez descender de otras clases, esto no es en realidad herencia múltiple ya que una clase no puede heredar atributos ni métodos de una interface; y las clases que implementan una interfase pueden no estar ni siquiera relacionadas entre sí.
www.detodoprogramacion.com
Página 14
El cuerpo de la clase
El cuerpo de la clase, encerrado entre { y }, es la lista de atributos (variables) y métodos (funciones) que constituyen la clase. No es obligatorio, pero en general se listan primero los atributos y luego los métodos.
Declaración de atributos
En Java no hay variables globales; todas las variables se declaran dentro del cuerpo de la clase o dentro de un método. Las variables declaradas dentro de un método son locales al método; las variables declaradas en el cuerpo de la clase se dice que son miembros de la clase y son accesibles por todos los métodos de la clase. Por otra parte, además de los atributos de la propia clase se puede acceder a todos los atributos de la clase de la que desciende; por ejemplo, cualquier clase que descienda de la clase Polygon hereda los atributos npoints , xpoints e ypoints. Finalmente, los atributos miembros de la clase pueden ser atributos de clase o atributos de instancia ; se dice que son atributos de clase si se usa la palabra clave static : en ese caso la variable es única para todas las instancias (objetos) de la clase (ocupa un único lugar en memoria). Si no se usa static, el sistema crea un lugar nuevo para esa variable con cada instancia (o sea que es independiente para cada objeto). La declaración sigue siempre el mismo esquema: [ private | protected | public ] [ static ] [ final ] [ transient ] [ volatile ] Tipo NombreVariable [ = Valor] ;
Private, protected o public
Java tiene 4 tipos de acceso diferente a las variables o métodos de una clase: privado, protegido, público o por paquete (si no se especifica nada). De acuerdo a la forma en que se especifica un atributo, objetos de otras clases tienen distintas posibilidades de accederlos:
Acceso desde: private protected public (package) la propia clase S S S S subclase en el mismo paquete
N S S S
otras clases en el mismo paquete
N S S S
subclases en otros paquetes N^ X^ S^ N otras clases en otros paquetes N^ N^ S^ N
S: puede acceder N: no puede acceder X: puede acceder al atributo en objetos que pertenezcan a la subclase, pero no en los que pertenecen a la clase madre. Es un caso especial ; más adelante veremos ejemplos de todo esto.
Static y final
Como ya se vio, static sirve para definir un atributo como de clase , o sea único para todos los objetos de la clase. En cuanto a final , como en las clases, determina que un atributo no pueda ser sobreescrito o redefinido. O sea: no se trata de una variable, sino de una constante.
Transient y volatile
Son casos bastante particulares y que no habían sido implementados en Java 1.0. Transient denomina atributos que no se graban cuando se archiva un objeto, o sea que no forman parte del estado permanente del mismo.
www.detodoprogramacion.com
Página 16
Básicamente, los métodos son como las funciones de C: implementan, a través de funciones, operaciones y estructuras de control, el cálculo de algún parámetro que es el que devuelven al objeto que los llama. Sólo pueden devolver un valor (del tipo TipoDevuelto ), aunque pueden no devolver ninguno (en ese caso TipoDevuelto es void ). Como ya veremos, el valor de retorno se especifica con la instrucción return , dentro del método. Los métodos pueden utilizar valores que les pasa el objeto que los llama ( parámetros ), indicados con tipo nombre1, tipo2 nombre2 … en el esquema de la declaración. Estos parámetros pueden ser de cualquiera de los tipos ya vistos. Si son tipos básicos, el método recibe el valor del parámetro; si son arrays, clases o interfases, recibe un puntero a los datos ( referencia ). Veamos un pequeño ejemplo:
public int AumentarCuenta(int cantidad) { cnt = cnt + cantidad; return cnt; }
Este método, si lo agregamos a la clase Contador , le suma cantidad al acumulador cnt. En detalle:
- el método recibe un valor entero ( cantidad )
- lo suma a la variable de instancia cnt
- devuelve la suma ( return cnt ) ¿Cómo hago si quiero devolver más de un valor? Por ejemplo, supongamos que queremos hacer un método dentro de una clase que devuelva la posición del mouse. Lo siguiente no sirve:
void GetMousePos(int x, int y) { x = ….; // esto no sirve! y = ….; // esto tampoco! } porque el método no puede modificar los parámetros x e y (que han sido pasados por valor, o sea que el método recibe el valor numérico pero no sabe adónde están las variables en memoria). La solución es utilizar, en lugar de tipos básicos, una clase:
class MousePos { public int x, y; } y luego utilizar esa clase en nuestro método:
void GetMousePos( MousePos m ) { m.x = ……; m.y = ……; }
El resto de la declaración
Public , private y protected actúan exactamente igual para los métodos que para los atributos, así que veamos el resto. Los métodos estáticos ( static ), son, como los atributos, métodos de clase ; si el método no es static es un método de instancia. El significado es el mismo que para los atributos: un método static es compartido por todas las instancias de la clase. Ya hemos hablado de las clases abstractas; los métodos abstractos ( abstract ) son aquellos de los que se da la declaración pero no la implementación (o sea que consiste sólo del encabezamiento). Cualquier clase que contenga al menos un método abstracto (o cuya clase madre contenga al menos un método abstracto que no esté implementado en la hija) es una clase abstracta. Es final un método que no puede ser redefinido por ningún descendiente de la clase.
www.detodoprogramacion.com
Página 17
Las clases native son aquellas que se implementan en otro lenguaje (por ejemplo C o C++) propio de la máquina. Sun aconseja utilizarlas bajo riesgo propio, ya que en realidad son ajenas al lenguaje. Pero la posibilidad de usar viejas bibliotecas que uno armó y no tiene ganas de reescribir existe!. Las clases synchronized permiten sincronizar varios threads para el caso en que dos o más accedan concurrentemente a los mismos datos. De nuevo, más detalles habrá en el futuro, cuando hablemos de threads. Finalmente, la cláusula throws sirve para indicar que la clase genera determinadas excepciones.
El cuerpo de los métodos
Otra vez recordaremos nuestra vieja clase Contador:
// Implementación de un contador sencillo public class Contador { ……………….. public int incCuenta() { cnt++; return cnt; } ………………… }
Dentro de los métodos pueden incluirse:
- Declaración de variables locales
- Asignaciones a variables
www.detodoprogramacion.com
Página 19
Por ejemplo: cnt + 2; // debuelve la suma de ambos. promedio + ( valor / 2); // como se ve, se pueden usar paréntesis. horas / hombres; // división. acumulado % 3; // resto de la división entera entre ambos. Nota: + sirve también para concatenar cadenas de caracteres; hablaremos de String y StringBuffer pronto. Cuando se mezclan Strings y valores numéricos, éstos se convierten automáticamente a cadenas: "La frase tiene " + cant + " letras" se convierte en: "La frase tiene 17 letras" // suponiendo que cant = 17
Precedencia de operadores en Java
La siguiente es la precedencia de los operadores en expresiones compuestas. De todos modos, como en todos los lenguajes, se recomienda usar paréntesis en caso de duda. Posfijos []. (params) expr++ expr-- Operadores unarios ++expr --expr +expr -expr ~! Creación y "cast" new (type) Multiplicativos * / % Aditivos + - Desplazamiento << >> >>> Relacionales < > <= >= instanceof Igualdad == != AND bit a bit & OR exclusivo bit a bit ^ OR inclusivo bit a bit | AND lógico && OR lógico || Condicional? : Asignación = += -= *= /= %= ^= &= |= <<= >>= >>>= Algunos ejemplos: [] define arreglos: int lista[]; (params) es la lista de parámetros cuando se llama a un método: convertir(valor, base); new permite crear una instancia de un objeto: new Contador(); (type) cambia el tipo de una expresión a otro: (float)(total % 10); >> desplaza bit a bit un valor binario: base >> 3; <= devuelve "true" si un valor es menor o igual que otro: total <= maximo; instanceof devuelve "true" si el objeto es una instancia de la clase: papa instanceof Comida; || devuelve "true" si cualquiera de las expresiones es verdad: (a<5) || (a>20)
Llamadas a métodos
Se llama a un método de la misma clase simplemente con el nombre del método y los parámetros entre paréntesis, como se ve, entre otros, en el ejemplo en negrita:
// Archivo: Complejo.java // Compilar con: javac Complejo.java public final class Complejo extends Number { // atributos: private float x; private float y; // constructor: public Complejo(float rx, float iy) { x = rx; y = iy; } // métodos:
www.detodoprogramacion.com
Página 20
public float Norma() { return (float)Math.sqrt(xx+yy); } // obligatorios (son abstractos en Number): public double doubleValue() { return (double)Norma( ); } public float floatValue() { return Norma() ; } public int intValue() { return (int)Norma(); } public long longValue() { return (long)Norma(); } public String toString() { return "("+x+")+i("+y+")"; } }
Pueden probar la clase (mínima) con el siguiente ejemplo de aplicación; la línea en negrita es un ejemplo de un llamado a un método de un objeto de otra clase. Notar que es este caso, es necesario llamar al método sobre un objeto (instancia) existente, por lo que se indica:
Nombre_del_ObjetoNombre_del_Método(parámetros)
// Archivo: Ejemplo4.java // Compilar con: javac Ejemplo4.java // Ejecutar con: java Ejemplo import java.io.*;
public class Ejemplo4 { public static void main(String args[]) { Complejo numComp = new Complejo(4,-3); System.out.println( numComp.toString() ); System.out.println(numComp.Norma()); } }
En la clase Complejo tenemos también un ejemplo de un llamado a un método de clase , o sea static: return (float) Math.sqrt(xx+yy)** ; Como el método es de clase, no hace falta llamarlo para un objeto en particular. En ese caso, en lugar del nombre de un objeto existente se puede utilizar directamente el nombre de la clase: Nombre_de_la_ClaseNombre_del_Método(parámetros)
www.detodoprogramacion.com
