Java

POO (Programación Orientada a Objetos). Clases. Objetos. Multihilo. Multithread. Applet. JDK (Java Development Kit)

  • Enviado por: Emmanuell Pérez
  • Idioma: castellano
  • País: España España
  • 49 páginas

publicidad
cursos destacados
Diseño Web
Diseño Web
Con este curso serás capaz de:

* Entender y aplicar conceptos clave de HTML5, CSS3 y JQuery
* Estructurar...
Ver más información

Curso de Java desde cero
Curso de Java desde cero
¿Quieres aprender java desde cero? Disfruta con estos videotutoriales destinados a todos los públicos en el que...
Ver más información

publicidad

ÍNDICE

1. Introducción 3

¿Qué es Java? 4

Breve historia de Java 4

2. El Java Developers Kit(JDK) 5

¿Cómo y donde obtener el JDK? 5

¿Qué es el JDK? 5

3. Tecnología de objetos 12

¿Qué son los objetos? 12

¿Cómo crear objetos? 12

¿Cómo usar los objetos? 13

Referencia a variables de los objetos 13

Llamada a los métodos de los objetos 14

Recolector de basura 15

¿Qué son los métodos? 15

¿Qué son las clases? 15

Los objetos son instancias de las clases 16

Manejando datos de objetos 16

Usando los métodos del objeto 17

Subclases, superclases y herencia 17

Sobreescribiendo métodos 18

Ocultamiento y encapsulación de datos 18

Control de acceso a los métodos 19

El método main() 21

4. Sintaxis del lenguaje Java 23

Variables y tipos de datos 23

Operadores aritméticos 23

Operadores de relación 23

Operadores lógicos 24

Arrays 24

Strings 26

Más sobre Import 26

Instrucciones de bloque 27

Condicionales: if 27

Operador condicional 28

Condicionales switch 28

Bucles for 30

Bucle do-while 30

5. Threads (procesos) 34

Cuerpo de un proceso 34

Estados de los procesos 34

6. Introducción a los applets 37

Como introducir un applet en una página HTML 38

Prioridad en la ejecución de tareas. 40

Procesos demonios (threads daemon) 41

  • Las Excepciones 43

  • ¿Qué es una excepción? 43

    El bloque try 43

    El bloque catch 44

    El bloque finally 45

    Control de eventos 50

    INTRODUCCIÓN

    Internet, la red de redes mas grande del planeta ha venido evolucionando a ritmos muy acelerados, en sus inicios el correo electrónico fue la sensación. En la actualidad sigue siendo una herramienta fundamental en las comunicaciones, pero se han venido desarrollando otras herramientas y tecnologías como el hipertexto, los cuales vienen a ser objetos de información los cuales pueden contener textos, gráficos, audio, vídeo además de vínculos a otros hipertextos.

    La World Wide Web se encarga de la transferencia de los hipertextos utilizando el protocolo HTTP, hasta aquí Internet había crecido y madurado un poco, cada vez eran mas los sites donde se podían encontrar paginas web mostrando información de todo tipo, pero había un detalle: las paginas eran estáticas, y de pronto Sun Microsystems anuncia un nuevo producto asegurando que JAVA, así se llamaba, iba revolucionar Internet, las paginas Web se convertirían en dinámicas e interactivas.

    El avance de la tecnología informática y de las telecomunicaciones ha hecho posible que estemos viviendo tiempos en donde la globalización de la información, nos permita alcanzar uno de los grandes sueños de la humanidad: “Tener igualdad de condiciónes para acceder al conocimiento”, y esto se ha venido logrando gracias a Internet.

    ¿QUÉ ES JAVA?

    Java es un nuevo lenguaje de programación orientado a objetos desarrollado por Sun Microsystems. Sun describe al lenguaje Java de la siguiente manera: Simple, orientado a objetos, distribuido, interpretado, robusto, seguro, de arquitectura neutral, portable, de alto rendimiento, multitarea y dinámico.

    Sun admite totalmente que lo dicho anteriormente es una cadena de halagos por parte suya, pero el hecho es que todo ello describe al lenguaje Java.

    Java permite hacer cosas excitantes con las paginas Web que antes no eran posibles. De manera que en este momento la gran interactividad que proporciona Java marca la diferencia en las paginas Web. Imagina un Web donde puedes jugar a un juego, como el fútbol, tú y otras personas que están en lugares remotos forman parte de un equipo y otras mas del contrario, verías a los jugadores animados en la pantalla obedeciendo las instrucciones de las personas que están jugando al juego desde sitios remotos.

    Además las puntuaciones quedarían registradas. O un Web con una aplicación en donde el usuario pueda hacer transacciones y estas se actualicen en tiempo real. O un sitio que ofrezca pequeñas aplicaciones como hojas de calculo o calculadoras para uso de los visitantes. O uno que muestre figuras 3D, tales como moléculas o dinosaurios que pueden ser rotados con un click del ratón.

    Java también aumenta el contenido multimedia de un sitio, ofreciendo animaciones fluidas, gráficos mejorados, sonido y vídeo, fuera de lo necesario para enganchar aplicaciones de ayuda dentro de sus navegadores Web.

    BREVE HISTORIA DE JAVA

    A finales de la década de los 80 Sun Microsystems inicia un proyecto de investigación encabezado por James Gosling con el propósito de desarrollar un lenguaje de programación para dispositivos electrónicos como tostadoras, hornos microondas y asistentes digitales personales. Gosling y su equipo de investigación llegaron a la conclusión de que el software para dispositivos de consumo tiene algunos requerimientos de diseño únicos.

    Por ejemplo, el software necesita ser capaz de trabajar en nuevos chips de computadora. Cuando los chips son introducidos, los fabricantes más de una vez los cambian por otros por ser más baratos o introducir nuevos mecanismos. El software también necesita ser extremadamente inteligente, porque cuando un producto del consumidor falla, el fabricante usualmente tiene que reemplazar todo el dispositivo y no el componente que originó el fallo.

    Gosling y su equipo también descubrieron que existían lenguajes de programación como C y C++ con los cuales no se podía realizar la tarea de hacer un software que fuera independiente de la arquitectura en donde se este ejecutando. Un programa escrito en C o C++ debe ser compilado para un chip de computadora particular. Cuando se cambia de chip el programa debe ser recompilado. La complejidad de C y C++ también hace extremadamente dificultoso escribir software fiable.

    Como resultado de lo dicho anteriormente, en 1990 Gosling comenzó a diseñar un nuevo lenguaje de programación que fuera mas apropiado para dispositivos que utilizan software electrónico. Este lenguaje fue conocido originalmente como Oak. Fue pequeño, de fiar e independiente de la arquitectura. En 1993 cuando el equipo de Java continuaba trabajando en el diseño del nuevo lenguaje, la Word Wide Web apareció y tomó a todos por sorpresa. El equipo de Java pensó que un lenguaje de arquitectura neutral sería ideal para programar en la Internet, porque un programa correría en todos los diferentes tipos de computadoras conectadas a Internet. Y fue un hecho; todas las metas alcanzadas con las investigaciónes anteriores coincidentemente sirvieron idealmente para la programación en Internet.

    En ese momento el desarrollo de Java se tornó en un asunto de mayor importancia para Sun. El equipo escribió un navegador Web llamado HotJava, que fue el primero en soportar applets de Java. Un applet es un pequeño programa que puede ser incrustado en una página Web. Puedes incluir un applet en un documento HTML para proporciónar interactividad y dar vida a una página Web. HotJava demostró el poder del lenguaje Java y lo puso de moda entre los programadores y el resto de la gente. Y lo demás es historia.

    Los programadores comenzaron con la versión Alpha de Java que Sun puso a disposición de toda la gente, creando las clasificaciónes de applets más maravillosas. La experiencia de Sun y la retroalimentación por parte de los usuarios ayudaron a refinar el lenguaje y la interfaz de programación de aplicaciónes (API). Al mismo tiempo que Sun sacó la versión Beta de el lenguaje, Netscape anunció que la version 2.0 del Web browser, Netscape Navigator soportaría applets de Java. Esto sivió para incrementar el fuerte interés en la tecnología Java, en el mundo de la computación y en Internet.

    Con compañías como IBM, SGI y Oracle licenciando la tecnología Java de Sun se puede estar seguro de que más productos de software y hardware incorporarán la tecnología Java.

    EL JAVA DEVELOPERS KIT (JDK)

    ¿CÓMO Y DÓNDE OBTENER EL JDK?

    El primer paso será descargar(download) el JDK (Java Developers Kit), el cual esta disponible para las

    siguientes plataformas:

    • SPARC Solaris (2.3 o superior)

    • Intel x86 Solaris

    • Windows NT/95 (Intel x86)

    • Macintosh 7.5

    en la siguiente URL: http://Java.sun.com/devcorner.html

    Si su plataforma de desarrollo es Windows 95, pueden bajarse el JDK desde:

    ftp://ftp.rcp.net.pe/pub/networks/win95/webedit

    Ahora si tienen alguna plataforma como AIX, OS2, Windows 3.x, pueden revisar la documentación de la URL: http://ncc.hursley.ibm.com/Javainfo

    en donde encontraran mayor información sobre compiladores (Just in Time -JIT)

    ¿QUÉ ES EL JDK?

    El JDK, es un conjunto de herramientas de desarrollo el cual consta de:

    appletviewer.exe

    • Descripción: Es el visor de applets de Java. El appletviewer descarga uno o mas documentos HTML especificados por la URL en la línea de comando. Descarga todos los applets referenciados en cada documento y muestra estos. Cada uno en su propia ventana. Si ninguno de los documentos mostrados tiene una marca <APPLET>, appletviewer no hace nada.

    • Opciónes:

    -debug Inicia el Java debugger jdb, permitiéndote depurar el applet en el documento.

    Java.exe

    • Descripción: Es el intérprete de Java ejecuta byte-codes creados por Javac, el compilador de Java. El argumento nombre_de_clase es el nombre de la clase a ser ejecutada y argumentos son los parámeros pasados a la clase.

    • Sintaxis:

    Java [opciónes] nombre_de_clase <argumentos>

    Java_g [opciónes] nombre_de_clase <argumentos>

    • Opciónes:

    -debug Permite que el jdb (Java debugger) se conecte a si mismo a la sesión de Java.

    Cuando -debug es especificado en la línea de comandos, Java muestra una contraseña, la cual debe ser usada cuando comienza la sesión de depuración.

    -cs, Compara la fecha de modificación del archivo de la clase.

    -checksource Con la del archivo fuente. Cuando la clase es cargada, si el archivo fuente tiene

    una fecha mas reciente que la del archivo de la clase entonces el archivo fuente

    es recompilado y los byte-codes resultantes vueltos a cargar.

    -classpath Especifica el camino que Java usa para buscar las clases.

    -path Sobreescribe el establecido por defecto o la variable de entorno CLASSPATH

    si esta ha sido establecida anteriormente.

    Los Directorios en la variable CLASSPATH son separados con punto y coma

    (;). Hasta aquí el formato general para el path es:

    .;<tu_camino>

    Por ejemplo :

    .;C:\users\avh\classes\;C:\jdk\classes

    -mx x Establece el tamaño máximo de la memoria del colector de basura para x. El

    valor por defecto es 16 megabytes de memoria. x debe ser mayor que 1000 bytes.

    Por defecto, x es menciónado en bytes, pero se puede especificar en kilobytes o megabytes poniendo después de x la letra k para kilobytes y m para megabytes.

    -ms x Establece el tamaño de inicio de la memoria del colector de basura para x. El

    valor por defecto es 1 megabyte de memoria. x debe ser mayor que 1000 bytes.

    Por defecto, x es menciónado en bytes, pero se puede especificar en kilobytes o megabytes poniendo después de x la letra k para kilobytes y m para megabytes.

    -noasyncgc Apaga el colector asíncrono de basura. Cuando el colector está activado no

    actúa a menos que este sea explícitamente llamado o el programa corra fuera de memoria. Normalmente el colector de basura se ejecuta como una tárea síncrona en paralelo con otras táreas.

    -ss x Cada tárea en Java tiene dos pilas: una para el código de Java y otra para el

    código de C. La opción -ss establece el tamaño máximo de la pila mediante el valor x que puede ser usada por el código de C en una tárea. Todas las táreas

    que resultan de la ejecución del programa pasado a Java tienen a x como tamaño de pila para C. La unida por defecto para x son bytes. x debe ser mayor que 1000 bytes.

    Puedes modificar el significado de x adiciónando la letra k para kilobytes o la letra m para megabytes. El tamaño por defecto de la pila es 128 kilobytes (-ss 128k).

    -oss x Cada tárea en Java tiene dos pilas: una para el código de Java y otra para el

    código de C. La opción -oss establece el tamaño máximo de la pila mediante el valor x que puede ser usada por el código de Java en una tárea. Todas las táreas

    que resultan de la ejecución del programa pasado a Java tienen a x como tamaño de pila para Java. La unidad por defecto para x son bytes. x debe ser mayor que 1000 bytes.

    Puedes modificar el significado de x adiciónando la letra k para kilobytes o la letra m para megabytes. El tamaño por defecto de la pila es 400 kilobytes (-oss 400k).

    -t Imprime el rastro de las instrucciónes ejecutadas (sólo Java_g)

    -v, -verbose Hace que Java imprima un mensaje en la salida estándar cada vez que un

    archivo de clase es cargado.

    -verify Ejecuta el verificador de todo el código.

    -verify Ejecuta el verificador de todo el código que es cargado en remote el sistema via

    un classloader. verifyremote es el valor por defecto para el interprete.

    -verbosegc Hace que el colector de basura imprima mensajes cada que este libera memoria.

    -Dproperty Redefine el valor de una propiedad. propertyName es el Name(nombre) de la

    propiedad cuyo valor se quiere cambiar y newValue es valor a ser asignado. Por ejemplo, este comando de línea

    Java -Dawt.button.color=green ...

    establece el valor de la propiedad awt.button.color a green(verde). Java acepta cualquier numero de opciónes -D en la línea de comandos.

    • Entorno:

    CLASSPATH Esta variable de entorno es usada para indicar al sistema la ruta de las clases

    definidas por el usuario.

    Por ejemplo :

    .;C:\users\avh\classes;C:\jdk\classes

    Javac.exe

    • Descripción: Javac, es el compilador del lenguaje Java, es decir compila los archivos (*.Java) en byte-codes Java archivos (*.class), el compilador Javac ha sido escrito en el mismo Java.
      Por defecto Javac, genera los archivos (*.class), en el mismo directorio del archivo fuente (*.Java)
      Cuando un archivo fuente de Java hace referencia a una clase que no esta definida en alguno de los archivos fuente del comando de línea, entonces Javac hace uso del Classpath, por defecto el Classpath, solo contiene las clases del sistema.

    • Sintaxis:

    Javac [opciónes] archivos

    • Opciónes:

    -classpath ruta Aquí ruta, le dice a classpath a donde tiene que ir a buscar las clases

    especificadas en el código fuente. Esta opción elimina el path por defecto y cualquier otra ruta especificada en classpath la ruta especificada puede ser una lista de directorios separados por (;) para sistemas Windows y (.) para sistemas Unix

    -d directorio Directorio, especifica el lugar donde usted desea se guarden sus clases, por

    defecto las clases se guardan en el mismo directorio que las fuentes (*.Java)

    Javac -d [ruta de clases] [ruta de fuentes]

    Ejemplo:

    Javac -d c:\Java\clases c:\Java\fuentes\work1.Java

    -g Esta opción permite al Javac adiciónar numero de línea y la información de

    variables locales a los archivos de clases, esto sólo podrá ser visualizado cuando use el Jdb (Java debuggers)

    -nowarn Permite que el Javac no muestre los mensajes de error en la compilación.

    -verbose permite al compilador mostrar los mensajes

    Javadoc.exe

    • Descripción: Javadoc genera documentación API en formato HTML para el paquete especificado o para los archivos fuentes individuales en Java en la línea de comandos.

    • Sintaxis:

    Javadoc [opciónes] nombre_de_paquete

    Javadoc [opciónes] nombre_de_archivo

    • Opciónes:

    -classpath path El path que Javap usa para encontrar las clases nombradas en la línea de comandos.

    -d directory Especifica un directorio en donde Javadoc almacena los archivos HTML que

    genera. Por defecto es el directorio actual.

    -verbose Hace que Javadoc imprima mensajes acerca de lo que esta haciendo.

    Javah.exe

    • Descripción: Javah genera archivos fuentes y de cabecera en C (archivos .h y .c) que describen las clases especificadas. Estos archivos de C proveen la información necesaria para implementar métodos nativos para las clases especificadas en C.

    • Sintaxis:

    Javah [opciónes] nombre_de_clase

    • Opciónes:

    -classpath path El path que Javah usa para encontrar las clases nombradas en la línea de

    comandos.

    -d directory Especifica un directorio en donde Javah almacena los archivos que genera. Por

    defecto los almacena en el directorio actual.

    -o outputfile Combina todos los archivos .h o .c en un simple archivo, outputfile.

    -stubs Genera archivos .c stub para la clase o clases, y no genera archivos de cabecera

    .h.

    -td directory El directorio donde Javah almacena los archivos temporales. Por defecto es

    /tmp.

    -v Hace que Javah imprima mensajes acerca del trabajo que está realizando.

    Javap.exe

    • Descripción: Javah desensambla el archivo de clases especificado por los nombres de clases en la línea de comandos e imprime una versión humanamente comprensible de esas clases.

    • Sintaxis:

    Javap [opciónes] nombre de_clase

    • Opciónes:

    -c Imprime las instrucciónes de la maquína virtual de Java para cada uno de los

    métodos en cada una de las clases especificadas. Esta opción desensambla todos los métodos incluyendo los privados y protegidos.

    -classpath path El path que Javap usa para encontrar las clases nombradas en la línea de

    comandos.

    -l Imprime números de línea y tablas de variables locales además de los campos

    públicos de las clases. Note que los números de línea y la información de

    variables es incluida para usar con debuggers. La información de variables locales esta disponible sólo si una clase fue compilada con la opción -g de Javac, la información de números de línea esta disponible sólo si una clase fue compilada con la opción -O.

    -p Imprime métodos privados y protegidos y variables de la clase especificada

    ademá de las publicas.

    jdb.exe

    • Descripción: jdb es un depurador para clases de Java. Este esta basado en una línea de comandos de texto y tiene una sintaxis de comandos como la del dbx en UNIX o depuradores gdb.

    • Sintaxis:

    jdb [opciónes de Java] class

    jdb [-host hostname] -password password

    • Opciónes:

    -host hostname

    -password password

    • Comandos:

    !!

    catch [clase de excepción]

    classes

    clear [class:line]

    cont

    down [n]

    dump id(s)

    exit (o quit)

    gc

    help o ?

    ignore clase de excepción

    list [numero de línea]

    load classname

    locals

    memory

    methods class

    print id(s)

    resume [thread(s)]

    run [class] [args]

    step

    stop [at class:line]

    stop [in class.method]

    suspend [threads(s)]

    thread thread

    threadgroup name

    threadgroups

    threads [threadgroups]

    up [n]

    use [ruta_archivo_fuente]

    where [thread] [all]

    TECNOLOGIA DE OBJETOS

    La tecnología de objetos es una colección de análisis, diseño y metodologías de programación.

    Para que un lenguaje de programación sea considerado "Orientado a Objetos" debe soportar como mínimo cuatro características importantes.

    Encapsulación:

    Esto es, el lenguaje deberá implementar información escondida y modular.

    Polimorfismo:

    En un mensaje enviado a diferentes objetos, el efecto dependerá de la naturaleza del objeto que haya recibido el mensaje.

    Herencia:

    La herencia hace que se pueden definir clases nuevas y conductas basadas en clases existentes para reutilizar código.

    Enlace Dinámico:

    Los objetos podrían venir desde cualquier sitio, como a través de la red Entonces es necesario enviar mensajes a los objetos sin tener conocimiento del tipo de objeto en el momento de escribir el código. El enlace dinámico provee un máximo de flexibilidad mientras un programa esta en ejecución.

    ¿QUÉ SON LOS OBJETOS?

    Los objetos son modelos de programación, con los cuales se pueden crear botones, listas, menús, etc., en las aplicaciones de software.

    En la programación e implementación de un objeto los estados se guardan como variables, las cuales son privadas para los objetos, a menos que en la creación se especifiquen como publicas, las variables son inaccesibles desde fuera de los objetos.

    Las conductas de los objetos están definidos en los métodos. Los métodos se encargan de modificar las variables para cambiar los estados o crear nuevos objetos.

    ¿CÓMO CREAR OBJETOS?

    En Java, se puede crear un objeto al crear una instancia de una clase. Cuando una clase es llamada para crear un objeto, se dice entonces que el objeto es una instancia de la clase.

    Por ejemplo:

    new Rectangle(x,y,width,height);

    new Rectangle(0,0,60,100);

    Aquí Rentangle(0,0,60,100), es una llamada al constructor para la clase Rectangle.

    Los constructores son métodos especiales provistos en cada clase Java que permiten a los programadores crear e inicializar objetos de este tipo. En este caso (new) muestra como inicializar el nuevo objeto Rectangle para ser localizado en el origen (0,0), con un ancho de 60 y un alto de 100.

    Un Constructor es un método invocado automáticamente, cuando la instancia de una clase es creada los constructores utilizan los mismos nombres que las clases y son usados para inicializar las variables de los objetos recientemente creados.

    Como ya mencionamos los constructores tienen el mismo nombre que la clase, y una clase puede tener cualquier numero de constructores con el mismo nombre, estos se diferencian por el número y tipo de argumentos.

    Por ejemplo la clase: Java.awt.Rectangle tiene los siguientes constructores, los cuales se diferencian por los argumentos:

    Rectangle()

    Rectangle(int x,int y,int width,int height)

    Rectangle(int width,int height)

    Rectangle(Point p,Dimension d)

    Rectangle(Point p)

    Rectangle(Dimension d)

    más adelante trataremos acerca de la clase Rectangle.

    ¿CÓMO USAR LOS OBJETOS?

    Una vez creado el objeto, por ejemplo el Rectángulo, necesitamos moverlo por la pantalla de la computadora es decir imaginemos 2 variables x,y que definen la posición del objeto, las cuales van cambiando esto originará el movimiento de nuestro rectángulo.

    Si recordamos un poco, la clase Rectangle, tiene 2 variables x,y que definen la posición del objeto Rectangle y además tiene un método, llamado move(), el cual permite mover el rectángulo: move(int x,int y)

    REFERENCIA A VARIABLES DE LOS OBJETOS

    Se puede hacer referencia a las variables de los objetos de la siguiente manera:

    Referencia_del_objeto.variable

    Esto permite ver o modificar las variables de los objetos, por ejemplo en el caso de la clase Rectangle, si cuadro es la referencia al objeto y (x,y) las variables entonces con:

    cuadro.x

    cuadro.y

    pueden ser usadas para hacer referencia a las variables del objeto, en la sentencias y expresiones en Java.

    Para cambiar los valores de x,y podemos usar lo siguiente:

    cuadro.x = 10; /// x ahora tiene el valor 10

    cuadro.y = 20; /// y ahora tiene el valor 20

    No olvidemos que la clase Rectangle, tiene otras 2 variables (Width,Height)

    cuadro.width

    cuadro.Height

    Entonces si se nos pide calcular el área del rectángulo, tendríamos:

    área = cuadro.Width * cuadro.Height;

    LLAMADA A LOS MÉTODOS DE LOS OBJETOS

    Para hacer referencia a los métodos de un objeto se coloca la referencia del objeto separada por un punto con el método y los argumentos necesarios encerrados entre paréntesis si no hubiese argumentos los paréntesis deberán ir vacíos:

    Referencia_al_objeto.nombre_del_método(argumentos);

    o

    Referencia_al_objeto.nombre_del_método();

    Por ejemplo, para mover el rectángulo, necesitamos hacer uso del método move(), que ya menciónamos unas líneas atrás. Lo hacemos de la siguiente manera:

    cuadro.move(10,20);

    Esta instrucción llama al método move, con 2 valores enteros 10 y 20 pasados como parámetros, para que el objeto referenciado como cuadro, se mueva según las coordenadas x,y.

    Las llamadas a los métodos son también conocidas como Mensajes.

    RECOLECTOR DE BASURA

    Otros lenguajes de programación orientada a objetos, requieren que se guarde la pista de los objetos que se han venido creando para más adelante si no se usan sean destruidos, esto trae como consecuencia realizar un trabajo tedioso y con posibilidad

    de cometer muchos errores.

    En Java, no es necesario preocuparse de los objetos que se van creando ya que si existe un objeto en tiempo de ejecución que ya ha dejado de usarse Java lo elimina. Este proceso es conocido como el Recolector de Basura.

    El Recolector de Basura se ejecuta en prioridad baja, dependiendo de la situación y del sistema en el que se este ejecutando Java, puede correr sincronizada o desincronizadamente.

    Se ejecuta sincronizadamente cuando el sistema corre fuera de memoria o en respuesta a un requerimiento de un programa Java. Se ejecuta desincronizadamente cuando el sistema está ocioso, es decir tiene ratos libres entre tárea y tárea, como (Windows 95).

    ¿QUÉ SON LOS MÉTODOS?

    En conclusión los métodos son usados en la programación orientada a objetos para referirse a un procedimiento o una función.

    ¿QUÉ SON LAS CLASES?

    Las clases representan el modelo clásico de la programación orientada

    a objetos.

    Ellas soportan abstracción de datos y la implementación dada a los datos. En Java, cada nueva clase crea un nuevo tipo.

    En conclusión una clase es una colección de datos y métodos. Los datos y los métodos juntos usualmente sirven para definir el contenido y las capacidades de algunos tipos de objetos.

    Ejemplo de la estructura de una clase:

    class Nombre_de_clase {

    . . .

    Declaración de variables

    . . .

    Declaración de métodos

    . . .

    }

    public class Circle{

    public double x, y; // las coordenadas del centro

    public double r; // el radio

    // métodos que retornan la circunferencia y el área de circulo.

    public double circumference() {return 2 * 3.14159 * r;}

    public double area() {return 3.14159 * r * r;}

    }

    Más adelante explicaremos acerca del ámbito de las clases y los tipos de datos por ahora este ejemplo tiene la intención de mostrarle como esta

    organizada una clase.

    LOS OBJETOS SON INSTANCIAS DE LAS CLASES

    Ahora que hemos definido parcialmente la clase Circle, haremos algunas cosas con esta. Nosotros no podemos hacer nada con la propia clase Circle, necesitamos una instancia de la clase, un simple objeto de tipo Circle.

    Al definir la clase Circle en Java nosotros hemos creado un nuevo tipo de dato y por lo tanto podemos declarar variables de ese tipo por ejemplo:

    Circle c;

    Pero esta variable c es simplemente un nombre que se refiere a un objeto Circle, esta (la variable) todavía no es un objeto. En Java todos los objetos deben ser creados dinámicamente.

    Esto es casi siempre hecho con la palabra new :

    Circle c;

    c = new Circle();

    Ahora hemos creado una instancia de nuestra clase Circle (un objeto circle) y tenemos asignado este a la variable c, la cual es de tipo Circle.

    MANEJANDO DATOS DE OBJETOS

    Ahora que hemos creado un objeto podemos usar sus campos de datos. La siguiente sintaxis le debe ser familiar a los programadores de C:

    Circle c = new Circle();

    // inicializamos nuestro circulo para tener centro (2,2) y radio 1.0.

    c.x = 2.0;

    c.y = 2.0;

    c.r = 1.0;

    USANDO LOS MÉTODOS DEL OBJETO

    Aquí comienzan a tornarse interesantes las cosas. Para acceder al método de un objeto usamos la misma sintaxis que si accedieramos a los datos de un objeto :

    Circle c = new Circle();

    double a;

    c.r = 2.5;

    a = c.area();

    Chequea la ultima línea, nosotros no decimos a = area(c); sino a = c.area();

    Esta es la razón por la que se llama programación orientada al objeto, es decir el objeto es el foco aquí y no la llamada a la función. Este es probablemente el mecanismo simple más importante de el paradigma orientado a objetos.

    SUBCLASES, SUPERCLASES Y HERENCIA

    Para crear una nueva clase, el programador debe basar esta en una clase existente. La nueva clase es derivada de la clase existente. La clase derivada es también llamada una subclase de la otra, la cual es conocida como la superclase. La derivación de clases es transitiva: si B es una subclase de A, y C es una subclase de B, entonces C es una subclase de A.

    Para declarar que una clase es subclase de otra, se deberá indicar lo siguiente:

    class MouseEvent extends Event {

    . . .

    }

    Para crear una subclase se debe incluir la clausula (extends) en la declaración de la clase. Esta declaración, por ejemplo, indica que la clase mouseEvent es una subclase de la clase Event.

    Una subclase hereda variables y métodos de la superclase, la herencia es uno de los paradigmas mas potentes de la programación orientada a objetos.

    SOBREESCRIBIENDO MÉTODOS

    Cuando una clase define un método usando el mismo nombre, retorna tipos y argumentos como un método en la superclase, el método en la clase sobreescribe el método en la superclase. Cuando el método es invocado en la clase la nueva definición del método es llamada, no la antigua definición que está en la superclase.

    La técnica de sobreescribir métodos es importante en la programación orientada al objeto. Supongamos que definimos una subclase Elipse de nuestra clase Circle y definimos nuestras propias versiones de las funciónes área y circunferencia para Elipse puesto que las que heredamos de la clase Circle no se aplican para elipses.

    Cabe resaltar que esto no debe confundirse con la sobrecarga de métodos que significa tener varios métodos con el mismo nombre dentro de una clase, pero diferenciados por los argumentos de cada uno.

    OCULTAMIENTO Y ENCAPSULACIÓN DE DATOS

    Anteriormente describimos una clase como “una colección de datos y métodos”. Una de las mas importantes técnicas que no hemos tocado hasta este momento es el ocultamiento de datos dentro de una clase, y hacer que estén disponibles (los datos ocultados) solamente a través de los métodos. Esta técnica es usualmente conocida a menudo como ENCAPSULACIÓN por que este cierra herméticamente los datos de la clase dentro de la cápsula de seguridad, los cuales solo pueden ser accedidos por usuarios que tengan derechos -de acceso- para los métodos de la clase.

    Aquí algunas de las razones para ocultar datos :

    Una clase contiene un numero de variables que son interdependientes y deben

    tener un estado consistente.

    Si permites a un programador (que puedes ser tu mismo) manipular esas variables directamente la clase puede entrar en un estado inconsistente y funcionar inapropiadamente.

    Cuando todas las variables de la clase están ocultas y los métodos son la única posibilidad para cambiar los valores de las variables ocultas en objetos de la clase, todo funciona bien. Por que si mediante un método tratamos de cambiar un valor para una variable y el valor no es correcto el método tiene la facultad para rechazarlo.

    Si nosotros permitimos que las variables sean directamente manipuladas, sin intervención de los métodos de la clase, el numero de posibilidades que tienes que comprobar se vuelve inmanejable.

    Si una variable es visible en tu clase, entonces debes documentar esta. Una manera de ahorrar tiempo en la documentación es ocultar esta al usuario de la clase.

    CONTROL DE ACCESO A LOS MÉTODOS

    Cuando se declara un método, dentro de una clase Java, usted puede permitir o bloquear que otras clases y objetos puedan llamar a los métodos para esto tendrá que hacer uso de los especificadores de acceso.

    Java soporta 5 diferentes niveles de acceso para los métodos los cuales son:

    private

    private protected

    protected

    public, y ademas "friendly"

    veamos la siguiente tabla:

    Clases

    Subclases

    Paquete

    Todas

    private

    X

    private protected

    X

    X

    protected

    X

    X*

    X

    public

    X

    X

    X

    X

    friendly

    X

    X

    La X de la primera columna indica que la clase misma puede llamar al método definido con el especificador private.

    La X de la segunda columna indica que la subclase de la clase puede llamar al método especificado como private protected.

    La tercera columna indica que la clase como las clases del mismo paquete pueden llamar al método.

    Y la cuarta columna indica que cualquier clase puede llamar al método.

    Private:

    En este nivel de acceso, sólo la clase que contiene al método puede llamarlo para declarar un método privado utilizamos la palabra reservada private ejemplo:

    class prueba {

    private void texto1() {

    System.out.println("como se ve..");

    }

    }

    Los objetos de tipo prueba, pueden llamar al método texto1, pero los

    objetos de otro tipo no pueden hacerlo.

    Private Protected:

    Este nivel de acceso incluye el acceso private, además permite que cualquier subclase de la clase pueda llamar al método.

    La siguiente clase esta definida como private protected:

    class prueba2 {

    private protected void texto2() {

    System.out.println("y ahora como se ve..");

    }

    }

    Los objetos del tipo prueba2, pueden llamar al método texto2(), ademas las subclases de prueba2, también tienen acceso a texto2().

    Por instancia, la subclase de prueba2, subprueba puede llamar al método texto2() de un objeto prueba2.

    class subprueba extends prueba2 {

    void maspruebas(prueba2 a) {

    a.texto2();

    }

    }

    Protected:

    Este nivel permite que la clase, las subclases y todas las clases en el mismo paquete puedan llamar al método.

    Veamos un ejemplo:

    package curso;

    class lección3 {

    protected void contenido() {

    System.out.println("Imprimiendo..baaa");

    }

    }

    Ahora supongamos que otra clase, llamada lección4, será declarada miembro del paquete curso la clase lección4, puede llamar al método contenido() declarado dentro de la clase lección3, porque está dentro del mismo paquete.

    package curso;

    class lección4 {

    void Métododeacceso() {

    lección3 a = new lección3();

    a.contenido();

    }

    }

    Public:

    Cuando los métodos son públicos todas las clases tienen acceso a ellos.

    package curso;

    class lección3 {

    public void contenidopub() {

    System.out.println("todos pueden ver los

    contenidos");

    }

    }

    package html;

    class lección4 {

    void métododeacceso() {

    lección3 a = new lección3();

    a.contenidopub();

    }

    }

    Como se ve podemos llamar al método contenidopub() en la clase lección3.

    Friendly:

    Veamos un ejemplo:

    package curso;

    class A {

    void invitado() {

    System.out.println("Como estan amigos");

    }

    }

    La clase A, puede llamar al método invitado(), pero además todas las clases declaradas dentro del mismo paquete curso, pueden llamar al método invitado().

    EL MÉTODO main()

    Escriba este código en cualquier editor de textos, guárdelo como fecha.Java

    import Java.util.Date;

    class fecha {

    public static void main(String args[]) {

    Date hoy = new Date();

    System.out.println(hoy);

    }

    }

    Explicando........

    public static void main(String args[])

    Como se podra ver el método main() contiene tres modificadores:

    public:

    Indica que el método main(), puede ser llamado por cualquier objeto, ya lo explicamos arriba.

    static:

    Indica que el método main() es una clase método.

    void:

    Indica que el método main(), no retorna valores.

    En Java cuando se ejecuta una aplicación el interprete de Java (Java.exe) inicia con el método main(), el método main(), llama entonces todos los otros métodos requeridos por la aplicación.

    Utilice el compilador Javac, con su archivo fecha.Java, luego si todo está correcto, con el interprete de Java escriba: Java classname (sin extensión) para visualizar el resultado.

    Argumentos del método main()

    public static void main(String args[])

    Este arreglo de cadenas es el mecanismo mediante el cual el sistema, en tiempo de ejecución pasa información a la aplicación cada cadena en el arreglo es llamada como un comando de línea. mas abajo explicaremos acerca de cadenas y arreglos.

    SINTAXIS DEL LENGUAJE JAVA

    VARIABLES Y TIPOS DE DATOS

    Todas las variables del lenguaje Java, soportan un tipo de dato, en los que se incluyen: enteros, punto flotante, carácter, y boolean.

    Tipo

    byte 8-bit

    short 16-bit

    int 32-bit

    long 64-bit

    float 32-bit

    double 64-bit

    char 16-bit

    OPERADORES ARITMÉTICOS

    Java soporta varios operadores aritméticos incluyendo Adición(+), Substracción(-), Multiplicación(*), Division(/) y Resto(%) por ejemplo:

    x++ <==> Si a=1 y se efectúa y=a++, luego y=1, a=2

    y-- <==> Si a=1 y se efectúa y=a--, luego y=1, a=0

    ++x <==> Si a=1 y se efectúa y=++a, luego y=2, a=2

    --y <==> Si a=1 y se efectúa y=--a, luego y=0, a=0

    otras operaciones también son:

    y*=a + 1 que es lo mismo que: y = y * a + 1

    y/=a*3/4 que es lo mismo que: y = y / (a * 3 / 4)

    El orden de evaluación de operadores en expresiones es:

    se evalúan multiplicaciones y divisiones, luego sumas y restas.

    OPERADORES DE RELACIÓN

    Los operadores de relación comparan 2 valores y determinan la relación entre ellos, por ejemplo:

    a != b (a diferente de b?)

    a > b, a >= b (a mayor que b, a mayor o igual que b)

    a < b, a <= b

    a = b

    OPERADORES LÓGICOS

    Los operadores lógicos tienen 2 valores que representan las operaciones lógicas entre dichos operadores tenemos:

    && ==> Y Logico

    || ==> O Logico

    Por ejemplo:

    if (0 < edad && edad < Edad_Max)

    Verifica la edad de una persona entre el rango <0,Edad_Max>

    ARRAYS

    Mucho de lo que se ha aprendido en lo que se refiere a tipos de datos y objetos es aplicable a los arreglos en Java.

    • Los arrays son manipulados por referencia.

    • Son creados con new.

    • Son enviados automaticamente al colector de basura cuando dejan de ser usados.

    Creando y destruyendo Arrays:

    Hay dos maneras de crear arrays en Java. La primera usa new, y especifica el tamaño del array:

    byte buffer_octetos[] = new byte[1024];

    Button botones[] = new Buttons[10];

    Cuando se crea un aray de esta forma no se crean los objetos que son almacenados en el array, no hay un constructor para llamar, y la lista de argumentos es omitida con la palabra new. Los elementos de un array creados de esta manera con el valor por defecto del tipo. Los elementos de un array de int son inicializados a 0, por ejemplo, y los de un array de objetos a null (no apuntan a nada).

    La otra manera de crear un array es mediante un inicializador estatico que tiene la misma apariencia que en C:

    int tabla[] = {1,2,4,8,16,32,64,128};

    Esta sintaxis crea un array dinámicamente e inicializa sus elementos a los valores especificados. Los elementos especificados en la inicialización de un array deben ser expresiones arbitrarias. Esto es diferente que en C, donde deben ser expresiones constantes.

    Accediendo a elementos de un Array:

    El acceso a elementos de un array en Java es similar a C, se accede a un elemento del array poniendo una expresión de valor entero entre corchetes (nombre_array[valor_entero]) despues del nombre del array:

    int a[] = new int[100];

    a[0] = 0;

    for (int i = 1; i < a.length; i++)

    a[i] = i + a[i - 1];

    En todas las referencias a los elementos del array el índice es chequeado constantemente. Este no debe ser menor que cero ni mayor que el numero de elementos del array menos 1.

    En el ejemplo anterior los elementos de a estarian en el rango (0..99).

    Si el índice especificado no esta en el rango se genera un error de excepción (ArrayIndexOfBoundsException) pero no interrumpe la ejecución del programa sino que ejecuta una sección de código previamente escrita para tratar este error y luego continua con la ejecución. Esta es una de las maneras en que Java trabaja para prevenir bugs (errores) y problemas de seguridad.

    Arrays multidimensionales:

    Java también soporta arrays multidimensionales. Estos son implementados como arrays de arrays, similar a C. Se especifica una variable como un tipo de array multidimensional simplemente agregando un segundo par de corchetes al final del par anterior. La dimensión de los arrays se especifica entre los corchetes con un valor para cada dimensión.

    Ejemplo:

    byte ArrayDosDim[][] = new byte[256][16];

    Cuando creas un array multidimensional es opcional especificar el numero de elementos contenidos en cada dimensión, por ejemplo :

    int ArrayTresDim = new int[10][][];

    Este array contiene 10 elementos, cada uno de tipo int[][]. Esto quiere decir que es un array de una sola dimensión, cuando los elementos del array sean inicializados pasará a ser multidimensional. La regla para este tipo de arrays es que las primeras n dimensiones (donde n es al menos una) debe tener el numero de elementos especificado, y esas dimensiones deben ser seguidas por m dimensiones adiciónales que no tengan un tamaño de dimensión especificado.

    La siguiente Declaración se considera legal :

    String conjunto_strings[][][][] = new String[5][3][][];

    Esta Declaración no se considera legal :

    double temperature_data[][][] = new double[100][][10];

    Ejemplo de creación e inicialización de un array multidimensional:

    short triangle[][] = new short[10][];

    for (int i = 0; i < triangle.length; i++) {

    triangle[i] = new short[i+ 1];

    for (int j = 0; j < i + 1; j++)

    triangle[i][j] = i + j;

    }

    Asi mismo se pueden declarar y inicializar arrays de esta manera :

    static int[][] DosDim = {{1,2},{3,4,5},{5,6,7,8}}

    ¿Son los Arrays objetos?

    La evidencia sugiere que los arrays son, en realidad objetos. Java define bastante sintaxis especial para arrays, no obstante, para referenciar arrays y objetos se utilizan maneras distintas.

    STRINGS

    Los strings en Java no son arrays de caracteres terminados en null como en C. En vez de ello son instancias de la clase Java.lang.String. Un string es creado cuando el compilador de Java encuentra una cadena entre comillas(“”).

    Toda la teoria especificada para la creación de tipos de objetos dicha anteriormente es aplicada aquí mismo.

    MAS SOBRE IMPORT

    Para utilizar los objetos contenidos en un paquete, bien sea creado por ustedes o incluido con el entorno de programación de Java, es necesario importar dichos paquetes.

    Por ejemplo para importar un objeto similar a “Applet” del paquete de clases “Java.applet” se deberá utilizar la siguiente instrucción:

    import Java.applet.Applet;

    Y para importar todos los objetos del paquete entonces se escribe:

    import Java.applet.*;

    Al importar todos los objetos o solamente uno del paquete de clases, estamos creando la definición e implementación disponible para el paquete actual, supongamos:

    class NuestroApplet extends Applet {

    . . .

    }

    Ahora si ustedes intentan compilar este applet sin importar la clase:

    Java.applet.Applet

    Entonces, el compilador se “molestara” y enviara un mensaje de error con algo similar a:

    "Super class Applet of class NuestroApplet not found"

    INSTRUCCIONES DE BLOQUE

    Un bloque es un conjunto de sentencias encerradas por ({}) por ejemplo:

    void bloque() {

    int a = 20;

    { // Aquí empieza el bloque, Ah esto es un comentario.

    int b = 30;

    System.out.println(“Aquí estamos dentro del bloque:”);

    System.out.println(“a:” + a);

    System.out.println(“b:” + b);

    } // Fin del bloque.

    }

    CONDICIONALES: IF

    La sentencia condicional (if) permite ejecutar código Java de manera muy similar a la sentencia (if) en el lenguaje C, (if) es la palabra reservada de esta condicional seguido por una expresión_booleana y una sentencia o bloque de sentencias, las cuales serán ejecutadas si la expresión_booleana es verdadera.

    if (edad < 18)

    System.out.println("No se admiten menores de edad.");

    Además existe la palabra reservada else, que permite ejecutar una sentencia o un bloque de sentencias si la expresión_booleana es falsa.

    if (edad < 18)

    System.out.println("No se admiten menores de edad.");

    else System.out.println("Bienvenido, pase adelante.");

    OPERADOR CONDICIONAL

    Otro modo de utilizar la condiciónal (if)..(else) es usar el operador conciónal (?) el cual tiene la siguiente sintaxis:

    Expresión_booleana ? Valor_True : Valor_False

    En una sentencia de este tipo el operador condicional sólo permite retornar un valor si al evaluar la expresión_booleana es verdadera, entonces el operador condicional retorna el Valor_true, de lo contrario retorna Valor_False. Este operador es usado para condicionales pequeñas.

    Ejemplo, el mayor de 2 numeros a y b:

    int mayor = a > b ? a : b;

    CONDICIONALES SWITCH

    Para evitar el uso repetido de la sentencia (if), al evaluar el valor de algunas variables por ejemplo:

    if (evento == MouseClick)

    Sentencia o bloque;

    else if (evento == Drop)

    Sentencias o bloque;

    else if (evento == Fail)

    Sentencias o bloque;

    else if (evento == Complete)

    Sentencias o bloque;

    Este tipo de sentencias (if), es conocida como los (if) anidados.

    En Java existe un forma mas abreviada de de manejar los (if) anidados, usando la sentencia (switch), cuya sintaxis es:

    switch (Evaluar) {

    case valor1:

    Sentencia o bloque;

    break;

    case valor2:

    Sentencia o bloque;

    break;

    case valor3:

    Sentencia o bloque;

    break;

    ...

    default: Sentencia o bloque por defecto;

    }

    En la sentencia (switch), el testeo es comparado con cada uno de los valores (case) si se encuentra una coincidencia la sentencia o sentencias después del case es ejecutada.

    Si no se encuentran coincidencias, la sentencia (default) es ejecutada. La sentencia (default) es opcional.

    Como varia el ejemplo del (if) anidado con la sentencia (switch):

    switch (evento) {

    case MouseClick:

    Sentencia o bloque;

    break;

    case Drop:

    Sentencia o bloque;

    break;

    case Fail:

    Sentencia o bloque;

    break;

    case Complete:

    Sentencia o bloque;

    break;

    default: Sentencia o bloque por defecto;

    }

    Por ejemplo en el siguiente ejemplo:

    (Num, es un numero par) sera impreso si Num, tiene como valor: 2,4,6 o 8 cualquier otro valor de Num, imprimira (Num, es un numero impar)

    switch (Num) {

    case 2:

    case 4:

    case 6:

    case 8:

    System.out.println("Num, es un numero par");

    break;

    default: System.out.println("Num, es un numero impar");

    }

    BUCLES FOR

    El bucle (for) en Java, funciona de manera similar que en C, repite una sentencia o bloque de sentencias un numero de veces hasta que alguna condición se cumpla.

    for (Valor_de_inicio; Expresion_booleana; Incremento) {

    sentencias o bloque;

    }

    Explicando las secciónes:

    Valor_de_inicio:

    Aquí deberá indicar cual es el valor con el que comenzara el bucle

    por ejemplo: int cont = 0

    Las variables que se declaren en esta sección del bucle seran locales

    para el bucle estas dejan de existir cuando el bucle a terminado.

    Expresion_booleana:

    Aquí se chequea la expresión_booleana después de cada paso por el

    bucle por ejemplo: cont < 50 ,si el resultado es verdadero entonces se

    ejcuta el bucle. si es falso para la ejecución.

    Incremento:

    El incremento permite cambiar el valor del índice del bucle.

    Revise, ¿qué es lo que hace este código e intente explicarlo?

    String strArray[] = new String[15];

    int Num; // Índice del bucle

    for (Num = 0; Num < strArray.length; Num++)

    strArray[Num] = "";

    BUCLE DO WHILE:

    do {

    cuerpo

    } while (condición)

    El bucle do {cuerpo} while (condición) es similar a un bucle while (condición) {cuerpo} puesto que ejecutan una sentencia o bloque de sentencias (cuerpo) hasta que la condición sea falsa. La principal diferencia es que while (condición) {cuerpo} testea la condición antes de ejecutar el bloque sentencias (cuerpo), mientras que do {cuerpo} while (condición) lo hace al final del bloque de sentencias. De esta manera siempre se ejecutaran al menos una vez las sentencias en un bucle do {cuerpo} while (condición) aunque la condición sea falsa; puesto que primero se ejecuta el bloque de sentencias y luego se evalua la condición.

    Ejemplo :

    int a = 1;

    do {

    System.out.println("Iteración: " + a);

    a++;

    } while (a <= 10);

    Este código de programa se ejecuta en los siguientes pasos :

  • Primero se crea e inicializa la variable a con el valor 1.

  • Se ejecuta la instrucción System.out.println("Iteración : " + a); que hace que se imprima en la salida estándar (pantalla por defecto) Iteración: (Valor de a).

  • Se incrementa la variable a en 1.

  • Se evalúa la condición (a <= 10) que produce un valor verdadero o falso. Si esta condición es verdadera se ejecuta nuevamente el paso 2; de lo contrario continua con la siguiente instrucción debajo del do..while.

  • La salida que produciría seria :

    Iteración: 1

    Iteración: 2

    Iteración: 3

    Iteración: 4

    Iteración: 5

    Iteración: 6

    Iteración: 7

    Iteración: 8

    Iteración: 9

    Iteración: 10

    Breaking Out of Loops (Ruptura del bucle)

    En todos los bucles (for, while y do), el bucle finaliza cuando la condición no se cumple. Algunas veces puede ocurrir que se quiera salir del bucle antes de evaluarse la condición, es decir romper el bucle. Para esto se usan las sentencias break y continue.

    Si se esta usando break como parte de una sentencia switch; este para la ejecución del switch y el programa continua. Cuando se usa la sentencia break en un loop, para la ejecución del loop actual y ejecuta la siguiente sentencia luego del loop. Cuando se usa en bucles anidados el programa salta a la siguiente instrucción al final del bucle y ejecuta las instrucciones del bucle anterior.

    Por ejemplo :

    int contador = 0;

    while (contador < array1.length) {

    if (array1[contador] == 0) {

    break;

    }

    array2[contador] = (float) array1[contador++];

    }

    En este ejemplo se copian elementos del array1 (array de enteros) al array2 (array de floats) hasta que todos los elementos del array1 sean copiados o que el valor al que se hace referencia para copiar del array1 sea 0.

    El primer valor del array1 que coincida con 0 no es copiado al array2 y la sentencia break hace que la ejecución del programa se traslade a la siguiente instrucción luego del bucle.

    Continue es similar a break excepto que en vez de romper la ejecución del bucle hace que la ejecución del programa se traslade a la evaluación de la condición del bucle y comience una nueva iteración, dejando sin efecto la ejecución de las instrucciones que están debajo de la instrucción continue.

    Ejemplo :

    int contador1 = 0;

    int contador2 = 0;

    while (countador1 < array1.length) {

    if (array1[contador1] == 0) {

    contador1++;

    continue;

    }

    array2[contador2++] = (float)array1[contador1++];

    }

    En este ejemplo se copian solo los elementos del array1 (array de enteros) que no sean 0 al array2, la sentencia continue en este caso nos sirve para que la ejecución del programa se traslade nuevamente a la evaluación de la condición y el elemento del array1 no se copie al array2

    Labeled Loops (Bucles etiquetados)

    Break y Continue pueden opcionalmente contener etiquetas, estas le dicen a Java donde debe saltar la ejecución del programa.

    Para usar un bucle etiquetado, adicionar la etiqueta seguida de dos puntos (:) antes del comienzo del bucle. Luego cuando uses break o continue con el nombre de esta etiqueta, la ejecución se trasladara a la instrucción que esta luego de la etiqueta.

    Por ejemplo:

    fuera:

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

    While (x < 50) {

    if (i * x == 400)

    break fuera;

    ...

    }

    ...

    }

    Cuando este fragmento de código se ejecute y se cumpla que la multiplicación de i * x sea igual a 400 la ejecución del programa se trasladará a la instrucción que le sigua a la etiqueta fuera que viene a ser el bucle for.

    Aquí otro ejemplo:

    fuera:

    for (int i = 1; i <= 5; i++)

    for (int j = 1; j <= 3; j++) {

    System.out.println("i es " + i + ", j es " + j);

    if ((i + j) > 4)

    break fuera;

    }

    System.out.println("Final de bucles");

    Aquí la salida que produciria el programa :

    i es 1, j es 1

    i es 1, j es 2

    i es 1, j es 3

    i es 2, j es 1

    i es 2, j es 2

    i es 2, j es 3

    Final de bucles

    THREADS (PROCESOS )

    Un proceso es similar a una secuencia de programas que tiene un inicio y un fin sin embargo los procesos por si mismos no son programas, en otras palabras, un proceso es un flujo secuencial de control dentro de un programa.

    Los procesos en Java están implementados en la clase (Thread) la cual es parte del paquete (Java.lang).

    EL CUERPO DE UN PROCESO

    Utilizando el método run() seguido de un proceso que previamente a sido creado e inicializado, es como se define básicamente el cuerpo de un proceso,

    luego en tiempo de ejecución el sistema llamará al método run().

    Un ejemplo de un simple proceso.

    class proceso1 extends Thread {

    public proceso1(String str) {

    super(str);

    }

    public void run() {

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

    System.out.println(i + " " + getName());

    try {

    sleep((int)(Math.random() * 1000));

    } catch (InterruptedException e) {}

    }

    System.out.println("Listo " + getName());

    }

    }

    ESTADOS DE LOS PROCESOS

    New Thread

    Para crear un nuevo proceso utilizamos la siguiente sentencia:

    Thread procesonuevo = new ProcesosClass();

    Luego de esta sentencia el proceso no se inicia, se queda en el estado (New Thread) , con este estado un proceso es equivalente a un objeto proceso vacío, y solo puede ser iniciado start() o stop().

    Runnable

    Consideremos ahora las siguientes líneas de código:

    Thread proceso1 = new procesoClass();

    proceso1.start();

    El método start() crea los recursos necesarios para ejecutar el proceso, calcula el proceso a ejecutar y llama al método run(), en este momento el proceso se encuentra en el estado (Runnable).

    No Runnable

    Un proceso se encuentra en el estado “No Runnable” cuando ocurre alguno de estos eventos:

    • Se llamó al método sleep()

    • Se llamó al método suspend()

    • El proceso usa el método wait(), para poner en pausa baja alguna condición.

    • El proceso es bloqueado por I/O.

    Por ejemplo en el siguiente código:

    Thread proceso1 = new procesoClass();

    proceso1.start();

    try {

    proceso1.sleep(5000);

    } catch (InterruptedException e) {

    }

    La línea: proceso1.sleep(5000); envía a dormir al proceso1 por 5 segundos.

    Dead

    Un proceso puede ser eliminado de 2 formas:

    • por muerte natural ;-))

    • por el método stop()

    por ejemplo:

    public void run() {

    int j = 0;

    while (j < 50) {

    j++;

    System.out.println("j = " + j);

    }

    }

    Aquí el bucle while, itera 50 veces luego termina, un proceso con el método run() tiene muerte natural cuando el bucle a terminado.

    Ahora, también se puede eliminar un proceso en cualquier momento al llamar al método stop(), por ejemplo:

    Thread proceso1 = new procesoClass();

    proceso1.start();

    try {

    Thread.currentThread().sleep(5000);

    } catch (InterruptedException e) {

    }

    proceso1.stop();

    Aquí, se inicia proceso1 con proceso1.start(); luego el proceso activo, es enviado a dormir por 5 segundos, luego de los cuales proceso1, muere con proceso1.stop()

    IllegalThreadStateException

    En tiempo de ejecución se genera una IllegalThreadStateException cuando usted llama a un método en un proceso y el estado del proceso no le permite llamar al método, por ejemplo si el método suspend(), es invocado cuando el proceso es “No Runnable”

    INTRODUCCIÓN A LOS APPLETS

    Los applets de Java son miniprogramas que pueden ejecutarse desde un navegador World Wide Web usando marcas especiales, cuando el browser carga una página que contiene un applet, el browser descarga el applet desde el servidor Web y lo ejecuta en el sistema local.

    El mensaje que aparece en la parte inferior del browser cuando carga una página que contiene un Applet, es similar al siguiente: "initializing... starting...", esto indica que el applet, se esta cargando. Entonces, ¿qué está pasando?

    • Una instancia de la clase applet es creada.

    • El applet se inicializa a si mismo.

    • El applet empieza a ejecutarse.

    Cuando el usuario se encuentra en una página web, que contiene un applet y salta a otra página entonces el applet se detiene (stopping) a si mismo, y si el usuario retorna a la pagina el applet, vuelve a ejecutarse (start) nuevamente.

    Cuando el usuario sale del browser el applet, tiene un tiempo para detenerse y hacer una limpieza final antes de salir del browser.

    Estructura de un Applet.

    public class Miapplet extends Applet {

    ........

    ........

    public void init() {

    .......}

    public void start() {

    .......}

    public void stop() {

    .......}

    public void destroy() {

    .......}

    .........

    }

    init() permite inicializar el applet cada vez que este es cargado o recargado.

    start() inicia la ejecución del applet una vez cargado o cuando el usuario regresa a la pagina.

    stop() detiene la ejecución del applet como cuando se sale del browser.

    destroy() antes de salir del browser hace la limpieza final.

    Veamos algunos ejemplos:

    class Applet1 extends Applet {

    ............

    public void paint(Graphics g) {

    ........}

    ...........

    }

    El método paint() es el método básico para imprimir información, y el método update() puede ser usado con paint() para un mejor rendimiento en el pintado.

    Aquí el famoso programa HelloWorld, escrito como un applet de Java.

    import Java.awt.Graphics;

    import Java.applet.Applet;

    public class HelloWorld extends Applet{

    public void paint(Graphics g){

    g.drawString("Helloworld",50,25);

    }

    }

    Explicando....

    En primer lugar recuerde que debe guardar el programa como: HelloWorld.Java, luego utilizar el compilador (Javac) para compilar HelloWorld.Java. Si todo es correcto le devolverá HelloWorld.class

    drawString es un método de la clase Graphics del paquete Java.awt

    drawString(String str, int x, int y) permite dibujar una cadena de caracteres usando los

    siguientes parametros:

    str La cadena a ser dibujada

    x La coordenada x

    y La coordenada y

    COMO INCLUIR UN APPLET EN UNA PAGINA HTML

    <APPLET>

    Usamos este tag especial el cual es una extensión HTML, de la siguiente forma:

    <HTML>

    <HEAD>

    <TITLE>A ver como nos va..</TITLE>

    </HEAD>

    <BODY>

    <BR>

    <APPLET CODE="HelloWorld.class" WIDTH=200

    HEIGHT=50>

    </APPLET>

    </BODY>

    </HTML>

    Explicando....

    CODE

    El atributo code indica el nombre de la clase, es decir el archivo que contiene el applet, incluyendo la extensión (class) en este caso el archivo class debe estar en el mismo directorio que el archivo HTML.

    Si desea almacenar sus clases en un directorio diferente al directorio donde se almacenan sus archivos HTML, entonces deberá usar CODEBASE, CODE contiene solamente el nombre de la clase (applet) mientras que CODEBASE contiene la ruta

    donde se encuentran sus clases.

    WIDTH y HEIGHT establecen el tamaño para el applet.

    Un segundo ejemplo:

    import Java.awt.Graphics;

    import Java.applet.Applet;

    public class Applet2 extends Applet{

    String texto;

    public void init(){

    texto=getParameter(“text”);

    }

    public void paint(Graphics g){

    g.drawString(texto,50,25);

    }

    }

    Como es de esperar este archivo deberá guardarse como Applet2.Java luego de ser compilado les devolverá el applet, Applet2.class

    Explicando....

    getParameter es un método de la clase Applet del paquete Java.applet la sintaxis:

    getParameter(String str)

    retorna el valor del parametro str en el tag HTML,

    por ejemplo:

    <applet code=”Constru.class” width=50 height=50>

    <param name=speed value=5>

    </applet>

    Al llamar a getParameter(“speed”) retorna el valor 5

    Código HTML:

    <HTML>

    <HEAD>

    <TITLE>A ver como nos va..</TITLE>

    </HEAD>

    <BODY>

    <BR>

    <HTML>

    <HEAD>

    <TITLE>y Ahora que sigue...</TITLE>

    </HEAD>

    <BODY>

    <BR>

    <applet code=Applet2.class WIDTH=100 Height=40>

    <PARAM NAME=”text” VALUE=”Estan viendo mi 2do. Applet!!”>

    </applet>

    </BODY>

    </HTML>

    PRIORIDAD EN LA EJECUCIÓN DE TAREAS

    Anteriormente se dijo que los procesos se ejecutan concurrentemente. Conceptualmente esto es verdadero, pero en la práctica no ocurre así. Muchas

    computadoras tienen un simple CPU (nos estamos refiriendo específicamente al microprocesador) por lo tanto este solo puede ejecutar una instrucción a la

    vez y esta instrucción a su vez corresponde a un programa cargado en la memoria.

    Pueden haber muchos programas cargados en la memoria. Quien decide que programa debe ejecutarse es el planificador de procesos que asigna un tiempo

    de CPU a cada una de los procesos en espera de acuerdo a su una prioridad.

    Cuando se vence el tiempo de ejecución de un proceso y esta no se ha completado se guarda la posición en donde se quedo la ejecución de programa para

    ser usada luego cuando se tenga que retomar la ejecución de este proceso. Seguidamente la CPU ejecuta el siguiente proceso en espera. Todo este esquema

    de ejecución le da la ilusión al usuario de la computadora que esta está ejecutando varios procesos concurrentemente.

    El ejecutor de programas de Java soporta este modelo de manera muy simple, con un planificador determinístico. Que utiliza un algoritmo conocido como

    planificador de prioridad fija. Este algoritmo planificador de procesos se basa en la prioridad del proceso pero tomando en cuenta también los otros procesos

    de tipo Runnable.

    Cuando un proceso en Java es creado, esta hereda la prioridad del proceso que lo creo (hereda la prioridad de su padre). Se puede modificar la prioridad de los procesos en cualquier momento luego de su creación usando el método setpriority(). La prioridad del proceso se expresa en números que están en van desde MIN_PRIORITY hasta MAX_PRIORITY (constantes definidas en la clase Thread). El proceso que tiene el número mas alto es la que se ejecuta primero.

    Cuando varios procesos están listos para se ejecutadas el planificador de Java elige aquella que es del tipo Runnable.

    Este código fuente de Java implementa un applet que anima una carrera entre dos procesos runner con diferentes prioridades. Cuando se clickea el mouse

    sobre el applet comienza la carrera. El primer proceso tiene una prioridad de 2 y el segundo proceso 3.

    Este es el método run() para ambos runners :

    public int tick = 1;

    public void run() {

    while (tick < 400000) {

    tick++;

    }

    }

    Este metodo run() simplemente cuenta desde 1 a 400,000. La variable de instancia tick es publica porque el applet usa este valor para determinar que tanto ha progresado el runner. Adicionalmente a los dos procesos runner este applet tiene un tercer proceso que se encarga de dibujar. El metodo run() del proceso que dibuja contiene un loop infinito; durante cada interacción del loop, este dibuja una línea por cada runner. La tarea que dibuja tiene una prioridad de 4.

    PROCESOS DEMONIOS (THREADS DAEMON)

    Cualquier proceso en Java puede ser un demonio. Los procesos demonio son servicios provistos por otros procesos ejecutándose desde el mismo proceso como proceso demonio. Por ejemplo el navegador HotJava usa hasta cuatro procesos demonio de nombre "Image Fetchar" para traer imágenes desde el sistema de ficheros del host remoto cuando los procesos lo requieran.

    El método run() para un proceso demonio es típicamente un loop infinito que espera por el requerimiento de un servicio.

    Para especificar que un proceso es un demonio llama al método setDaemon() con el argumento true. Para determinar si un thread es un demonio usar el método isdaemon().

    LAS EXCEPCIONES

    ¿QUÉ ES UNA EXCEPCIÓN?

    El termino excepción es conocido de manera corta como un “evento excepcional” y puede ser definido de la siguiente manera: Una excepción es un evento

    que ocurre durante la ejecución de un programa que desbarata o desorganiza el normal funcionamiento del flujo de las instrucciones de un programa. Visto desde el lenguaje Java una excepción es cualquier objeto que es una instancia de la clase Throwable (o cualquiera de sus subclases)

    Las excepciones causan muchos tipos de errores, desde problemas serios de hardware, como caídas de disco duro a simples errores de programa, tales como acceso a elementos de un array que no han sido declarados lo que produce una invasión de memoria que puede estar ocupada por otros programas. Cuando tales errores ocurren el método crea un objeto de tipo excepción y este actúa como una mano milagrosa que salva al programa de la caída, luego de tratarse el error la ejecución del programa continúa desde la siguiente línea de código que produjo el error.

    EL BLOQUE TRY:

    El primer paso en la construcción de un manejador de excepción es encerrar las declaraciones que tengan la posibilidad de generar un error de excepción durante

    la ejecución del programa. En general un bloque try es de la siguiente manera:

    try {

    // Declaraciones Java

    }

    El segmento de código llamado `Declaraciones Java' esta compuesto de una o mas declaraciones legales que podrían generar una excepción.

    El siguiente programa usa una declaración try para el método entero por que el código es fácil de leer.

    PrintStream pstr;

    try {

    int i;

    System.out.println("Entrando a la declaracion try");

    pStr = new PrintStream(

    new BufferedOutputStream(

    new FileOutputStream("ArchivoSalida.txt")));

    for (i = 0; i < size; i++)

    pStr.println("Valor en : " + i + " = " +

    victor.elementAt(i));

    }

    La declaración try gobierna las sentencias encerradas con este y define el campo de acción de esta. Una declaración try debe ser acompañada por al menos un bloque catch o un bloque finally.

    EL BLOQUE CATCH:

    Como se explicó anteriormente, la sentencia try define el alcance del manejador de excepción. Se asocia el manejador con una declaración try poniendo uno o mas

    bloques catch directamente después que el bloque try :

    try {

    . . .

    } catch ( . . . ) {

    . . .

    } catch ( . . . ) {

    . . .

    } . . .

    Cabe resaltar que no puede haber código entre el final de la declaración try y el comienzo de la declaración catch. La forma general de la declaración catch de Java es:

    catch (AlgunObjectoThrow Nombrevariable) {

    // Declaraciones Java

    }

    Como se puede observar la declaración catch requiere un argumento simple. El argumento para la declaración catch es un argumento como si lo fuera para la declaración de un método. El tipo de argumento AlgunObjetoThrow declara el tipo de excepción que el manejador puede manejar y debe ser el mismo de la clase que hereda de la clase definida en el paquete java.lang; NombreVariable es el nombre por el cual el manejador puede referirse a la excepción que esta comprometida por el manejador.

    El bloque catch contiene una serie de declaraciones Java. Esas declaraciones son ejecutadas cuando el manejador de excepción es invocado.

    Aqui un ejemplo:

    El método writeList() de la clase ListOfNumbers usa dos manejadores de excepción para la declaración try, con un manejador para cada tipo de excepción que están en el ámbito del try.

    try {

    int a[10];

    int c;

    c = a[11];

    } catch (ArrayIndexOutOfBoundsException e) {

    System.err.println("Tratamiento de

    ArrayIndexOutOfBoundsException: " + e.getMessage());

    } catch (IOException e) {

    System.err.println("Tratamiento de IOException: " +

    e.getMessage());

    }

    EL BLOQUE FINALLY:

    El paso final en el establecimiento de un manejador de excepción es proveer un mecanismo para borrar el estado del método después (posiblemente) permitiendo que el control sea pasado a una parte diferente del programa. Hacemos esto encerrando el código a limpiar con un bloque finally.

    try {

    . . . .

    } finally {

    if (pStr != null) {

    System.out.println("Cerrando PrintStream");

    pStr.close();

    } else {

    System.out.println("PrintStream no abierto");

    }

    }

    Aquí algunos ejemplos :

    SomeFileClass f = new SomeFileClass();

    if (f.open("/a/file/name/path")) {

    try {

    someReallyExceptionalMethod();

    } finally {

    f.close();

    }

    }

    El uso del finally en el código anterior se comporta como el siguiente:

    SomeFileClass f = new SomeFileClass();

    if (f.open("/a/file/name/path")) {

    try {

    someReallyExceptionalMethod();

    } catch (Throwable t) {

    f.close();

    throw t;

    }

    }

    Aqui una compleja demostracion con finally :

    public class MiClaseExcepcional extends ClaseContexto {

    public static void main(String argv[]) {

    int EstadoMisterioso = getContext();

    while (true) {

    System.out.print("Quien ");

    try {

    System.out.print("es ");

    if (EstadoMisterioso == 1)

    return;

    System.out.print("ese ");

    if (EstadoMisterioso == 2)

    break;

    System.out.print("extrano ");

    if (EstadoMisterioso == 3)

    continue;

    System.out.print("pero amable ");

    if (EstadoMisterioso == 4)

    throw new UncaughtException();

    System.out.print("en absoluto ");

    } finally {

    System.out.print("y divertido?\n");

    }

    System.out.print("Yo quiero reunirme con ese sujeto");

    }

    System.out.print("Por favor llamame!\n");

    }

    }

    CONTROL DE EVENTOS

    Se llaman eventos a aquellas acciones que realizan los usuarios cuando presionan una tecla, arrastran el ratón o presionan el botón izquierdo del ratón, etc.

    Los eventos en Java se encuentran especificados en el paquete AWT (Abstract Windowing Toolkit),

    Los Objetos Eventos

    Son el resultado de un evento, estos incluyen la siguiente informacion:

    • El tipo de evento Por ejemplo, keypress, mouse click, etc.

    • El objeto que ha generado el evento

    • El Momento en el que ocurrio el evento.

    • La coordenada (x,y) donde ocurrio el evento

    • La tecla que se ha presionado (para eventos keypress)

    • Un argumento, asociado con el evento

    • El estado del modificador de tecla Shift y Control cuando el evento ocurre.

    Implementar un manejador de eventos

    La clase Component, define muchos manejadores cada método manejador de eventos puede ser usado solo para un tipo particular de evento excepto handleEvent()

    La clase Component define los siguientes métodos para manejar eventos:

    action() (Event.ACTION_EVENT)

    mouseEnter() (Event.MOUSE_ENTER)

    mouseExit() (Event.MOUSE_EXIT)

    mouseMove() (Event.MOUSE_MOVE)

    mouseDown() (Event.MOUSE_DOWN)

    mouseDrag() (Event.MOUSE_DRAG)

    mouseUp() (Event.MOUSE_UP)

    keyDown() (Event.KEY_PRESS o Event.KEY_ACTION)

    keyUp() (Event.KEY_RELEASE o

    Event.KEY_ACTION_RELEASE)

    gotFocus() (Event.GOT_FOCUS)

    lostFocus() (Event.LOST_FOCUS)

    handleEvent() (todos los tipos de eventos)

    Cuando un evento ocurre, el método manejador de evento que coincida con el evento que ha ocurrido es llamado, siendo un poco mas explícito, cuando ocurre un evento el evento pasa primero al método handleEvent(), el cual se encarga de llamar al método apropiado para el tipo de evento.

    El método action() tiene una importancia especial ya que controla componentes básicos como Pushbutton, Checkboxes, Lists, MenuItem y objetos de entrada de texto TextField, todos ellos producen el evento action, todos los metodos manejadores de eventos tienen al menos un argumento (Event) y retornan un valor booleano, al retornar un valor FALSE, el manejador del evento indica que el evento debe continuar hasta alcanzar una jerarquía mas alta.

    Un valor TRUE indica que el evento no debe ser enviado mas alla.

    El método handleEvent() casi siempre retorna el método super.handleEvent(), para asegurarse que todos los eventos son enviados al método manejador de

    eventos apropiado.

    Eventos Mouse-click

    Esto ocurre cuando el usuario hace click, con en el ratón en el cuerpo de un applet usted puede interceptar los eventos click, por ejemplo para pasar de una

    URL a otra, para cambiar el estado de un archivo de audio de on a off, etc.

    MouseDown y mouseUp

    Cuando usted hace un click con el ratón una sola vez, el AWT genera 2 eventos uno es el evento mouseDown que ocurre cuando el botón izquierdo del ratón es presionado y el otro mouseUp que ocurre cuando el botón es liberado.

    Usted ya habrá notado la importancia de manejar 2 eventos UP y DOWN, con el ratón, un ejemplo claro es al seleccionar una opción de un menú.

    Ejemplo de uso del evento mouseDown

    public boolean mouseDown(Event evt, int x, int y) {

    ...

    }

    El metodo mouseDown() y el metodo mouseUp() toman 3 parametros:

    • El evento mismo

    • Las coordenadas x,y donde el evento ocurrio

    El argumento “event” es una instancia de la clase “Event” el cual contiene información acerca de cuando el evento se generó y el tipo de evento.

    Los argumentos x,y le indican dónde ocurrió el click del mouse, veamos por ejemplo este método que imprime la coordenada x,y

    public boolean mouseDown(Event evt, int x, int y) {

    System.out.println("Mouse down aqui fue.. " + x + "," + y);

    return true;

    }

    La otra parte del evento mouse es el método mouseUp() el cual es llamado cuando el botón del ratón es liberado veamos la sintaxis del evento mouseUp.

    public boolean mouseUp(Event evt, int x, int y) {

    ....

    }

    Veamos un ejemplo usando los eventos del mouse

    ---Guardar este archivo como Textmove.java---

    import java.awt.Graphics;

    import java.applet.Applet;

    import java.awt.Event;

    public class Textmove extends Applet implements Runnable{

    String text_in;

    int xpos=0;

    Thread killme=null;

    boolean suspended = false;

    public void init(){

    text_in=getParameter("text");

    }

    public void paint(Graphics g){

    g.drawString(text_in,xpos,100);

    }

    public void start(){

    if(killme==null){

    killme=new Thread(this);

    killme.start();

    }

    }

    public void set_x(){

    xpos =xpos-5;

    if(xpos<-120){

    xpos=size().width;

    }

    }

    public void run(){

    while(killme != null){

    try {Thread.sleep(100);}catch(InterruptedException e){}

    set_x();

    repaint();

    }

    }

    public boolean handleEvent(Event evt) {

    if (evt.id == Event.MOUSE_DOWN) {

    if (suspended) {

    killme.resume();

    } else {

    killme.suspend();

    }

    suspended = !suspended;

    }

    return true;

    }

    public void stop(){

    if(killme != null)

    killme.stop();

    killme=null;

    }

    }

    ---Compilar usando el javac del JDK---

    Agregar el siguiente código para su documento HTML:

    <HTML>

    <TITLE> Eventos del Mouse </TITLE>

    <BODY>

    <H1> Abajo el Applet</H1><HR>

    <APPLET CODE="Textmove.class" WIDTH=150 HEIGHT=100>

    </APPLET>

    </BODY>

    </HTML>

    De preferencia todos los archivos en la misma carpeta.

    51