Manual del Curso Java Básico

Programa de Tecnología en Cómputo

UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO FACULTAD DE INGENIERÍA
DIVISIÓN DE INGENIERÍA ELÉCTRICA

PROGRAMA DE TECNOLOGÍA EN CÓMPUTO

MANUAL DEL CURSO: JAVA BÁSICO

AUTORES: CAMACHO PÉREZ HUGO CASTAÑEDA MUÑOZ RICARDO VARGAS MEJÍA ISAAC

1

Manual del Curso Java Básico

Programa de Tecnología en Cómputo

TABLA DE CONTENIDO
1:Programación Orientada a Objetos.......................................................................................3 Introducción: .......................................................................................................................3 La Crisis del Software .........................................................................................................3 La metodología orientada a objetos ....................................................................................4 Clases y objetos...................................................................................................................4 Mensajes y métodos ............................................................................................................5 Encapsulamiento. ................................................................................................................5 Herencia ..............................................................................................................................5 Polimorfismo.......................................................................................................................6 Abstracción..........................................................................................................................7 2:La Tecnología Java...............................................................................................................8 La Plataforma Java. .............................................................................................................8 Tipos de programas en java...............................................................................................10 Compilación y Ejecución de Programas ...........................................................................10 Tipos de datos primitivos. .................................................................................................12 El recolector de basura ......................................................................................................13 3: Clases y objetos .................................................................................................................14 Atributos y métodos ..........................................................................................................16 Constructores, la palabra reservada this ............................................................................18 Variables y métodos de clase ............................................................................................25 Clases envolventes o wrappers..........................................................................................27 Arreglos.............................................................................................................................28 Arrays de dos dimensiones ...........................................................................................30 Java archivos (JAR) ..........................................................................................................30 Limpieza: Finalización y recolección de basura. ..............................................................31 La condición de Muerto ................................................................................................34 Comentarios y documentación ..........................................................................................35 Sintaxis..........................................................................................................................35 HTML empotrado .........................................................................................................36 4:La Clase String ...................................................................................................................38 Comparación de Strings ....................................................................................................39 5: Herencia ............................................................................................................................42 La palabra reservada super................................................................................................43 Sobrecarga y sobreescritura de métodos ...........................................................................45 Sobrescritura de Métodos..................................................................................................46 Conversión hacia arriba (upcasting)..................................................................................47 La palabra clave final ........................................................................................................48 Para Datos .....................................................................................................................48 Constantes Blancas. ......................................................................................................50 Métodos Constantes ......................................................................................................51 Clases Constantes..........................................................................................................51 6: Polimorfismo .....................................................................................................................53 Clases y métodos abstractos..............................................................................................57 Interfaces y clases internas................................................................................................59 Extender una interfaz con herencia. ..............................................................................61 Clases Internas: .................................................................................................................61 7:Paquetes..............................................................................................................................64 Apéndice A: Breve historia de Java ......................................................................................69

2

Manual del Curso Java Básico

Programa de Tecnología en Cómputo

1:Programación Orientada a Objetos.
Introducción:
Los lenguajes de programación son técnicas que permiten expresar instrucciones que deben ser ejecutadas por la computadora. Este lenguaje de programación sirve de nexo entre la parte humana y la computadora. Una de estas técnicas es la programación estructurada, en la cual se considera a un dato como pasivo y existe para ser manipulado dentro del programa durante el desarrollo del mismo. La variedad de sistemas hoy en día (y desde hace 20 años) ha demostrado que esta idea de estructuras de datos simples no es adecuada para soportar grandes cambios o cambios graduales. Tales cambios surgieron cuando aumentaron las expectativas de lo que se podía hacer con un sistema informático, ocurrió entonces lo que se conoce como “crisis del software”, en la que no fue suficiente la mano de obra para mantener los sistemas actuales.

La Crisis del Software
La crisis del software es el hecho de que el software que se construye no solamente no satisface los requerimientos ni las necesidades pedidos por el cliente, sino que además excede los presupuestos y los horarios de tiempos. Como alternativas de esta crisis se plantearon varias propuestas: La parametrización: Se trato de ubicar en datos externos al programa el conjunto de alternativas posibles para que durante la ejecución del proceso se determine que política utilizar para resolver un problema. Esta técnica no alcanzó a cubrir siquiera las necesidades inmediatas. La Modularización: Se comenzó por la década de los 60’s, con Pascal, al definirse una nueva alternativa a la parametrización que estaba basada en encapsular comportamiento en módulos. El advenimiento de lenguajes como Modula II y Ada, en los 70’s, fueron muy promisorios para la construcción de sistemas de software “grande”. El gran esfuerzo en la escritura de código como consecuencia del poco análisis y diseño del sistema originó una nueva técnica llamada Metodología Orientada a Objetos. En el paradigma de objetos, no es necesario el concepto de programa, pues cada objeto tiene una razón de ser para el ambiente que lo contiene y su comportamiento viene dado por su naturaleza.

3

por ejemplo piense en 5 plumones como los que se muestran a continuación: De estos 5 plumones podemos decir que pertenecen a la misma clase de objetos pero cada uno de ellos tiene las características necesarias que lo identifican como un objeto de la clase plumones y no con otros objetos como podría ser los objetos de tipo automóvil. Clases y objetos En la metodología orientada a objetos la esencia es el objeto. se quedó atrás por lo que empezaron a surgir diferentes métodos de análisis y diseño orientado a objetos. diseño y programación de sistemas. Por esta razón y en base a nuestra experiencia de la vida diaria podemos identificar grupos o clases de objetos. Como su mismo nombre indica. sin embargo. 4 . OOSE (Object Oriented Software Engineering) y OMT (Object Modeling Technique). intenta simular el mundo real a traves del significado de objetos que contiene caracteristicas y funciones. La metodología orientada a objetos presenta características que lo hacen idóneo para el análisis. la metodología orientada a objetos comenzaba a madurar como un enfoque de desarrollo de software. que es la relación entre la asignación de software al nivel del sistema y el diseño del software. Para poner fin a la "guerra de métodos" que se presentó en ese momento. una silla. se creó el Lenguaje Unificado de Modelado (UML). la programación orientada a objetos se basa en la idea de un objeto.Manual del Curso Java Básico Programa de Tecnología en Cómputo La metodología orientada a objetos A medida que se acercaban los años 80. A partir de aquí podemos decir que un objeto tiene características propias que llamaremos atributos y comportamientos o acciones propios de esa clase de objetos que llamaremos métodos. entre los que destacan los métodos Booch. Un objeto en el mundo real viene a representar cualquier cosa: un plumón. Empezamos a crear diseños de aplicaciones de todo tipo utilizando la forma de pensar orientada a los objetos e implementamos (codificamos) programas utilizando lenguajes y técnicas orientadas a los objetos. etc. una caja. que es una combinacion de variables locales y procedimientos llamados metodos que juntos conforman una entidad de programación. un automóvil. el análisis de requisitos. Los lenguajes orientados a objetos se clasifican como lenguajes de quinta generacion. La programación orientada a objetos.

Cuando un objeto necesita interactuar con otro lo hace a través de un método. es decir el código fuente puede ser escrito y darle mantenimiento de forma independiente al resto del programa y de los objetos que interactúan con él. Un método se implementa dentro la clase que defina al objeto. Encapsulamiento.1 Cuando un objeto A necesita que un objeto B ejecute alguno de sus métodos lo hace a través de sus métodos. en la herencia múltiple una clase puede heredar de una o mas clases. Figura 1. Un buen diseño de clases hace que los atributos solo sean modificados mediante el acceso a un método. a su vez los métodos también pueden ser restringidos de cierta forma. Hay diferentes tipos de herencia: los más importantes son simples y múltiples. El concepto de herencia está presente en nuestras vidas diarias donde las clases se dividen en subclases.2 El encapsulamiento provee una idea poderosa: la modularidad. De esta manera si queremos acceder a un atributo lo tenemos que hacer a través de alguno de sus métodos. La Herencia simple consiste en que una clase sólo puede heredar de otra clase llamada clase padre o superclase. 5 . Herencia La herencia es propiedad que permite a los objetos construirse a partir de otros objetos. Un objeto lo hemos representado de la siguiente manera: En donde se puede ver que loas datos (variables) y las acciones (métodos) se reúnen de tal forma que se oculte al mundo exterior parte de su información.Manual del Curso Java Básico Programa de Tecnología en Cómputo Mensajes y métodos Como ya hemos dicho un método es una acción que puede realizar un objeto. Figura 1.

3 muestra un ejemplo de herencia simple. que a su vez es la superclase de B y C. pero la 6 .4 Polimorfismo El polimorfismo es otra característica esencial de los lenguajes de POO. la clase B y la clase C son subclases de la clase A. en esta figura la Clase C y la Clase B heredan de la Clase A. La figura 1. la que se le asigna cuando es creado. Con la Herencia se obtienen múltiples beneficios.Manual del Curso Java Básico Programa de Tecnología en Cómputo Figura 1. al heredar una clase de otra la se obtienen todos sus atributos y métodos que compone la clase padre. Figura 1. Con la herencia y con un buen diseño Orientado a Objetos podemos llevar a la práctica la reutilización de código. Un objeto solo tiene una forma. ya que si una clase es muy parecida a una anterior.3 La figura 1.4 muestra un ejemplo del uso de la herencia. podemos programar únicamente la diferencia entre estas y aplicar la herencia.

por ejemplo nuestro diagrama de clases de la figura 1. en nuestro diagrama de clases anterior: • • Una referencia a objeto de la clase Empleado también puede ser una referencia a objeto de la clase Trabajador. Diseñar una clase de una manera muy general para varias clases que hereden de ella nos proveerá de un mejor diseño como se verá mas adelante en este curso en el apartado de clases abstractas. de esta forma el diseño de clases lo podemos considerar como una abstracción de datos. conforme descendemos en el árbol las clases se convierten en algo mas concreto.4 presenta una abstracción de datos en la parte superior y esta abstracción desminuye conforme se desciende del árbol. Una referencia a objeto de la clase Consultor también puede ser una referencia a objeto de la clase Trabajador. Abstracción Como mencionamos anteriormente en la POO para poder utilizar o crear un objeto es necesaria la clase del objeto. Para que esta referencia sea polimorfica debe haber necesariamente una relación de herencia entre las clases. hablar de un trabajador resulta mas abstracto que hablar de un empleado o bien un consultor. es decir. Por ejemplo. 7 . a esa clase de objeto la podemos definir como aquello que se desea abstraer.Manual del Curso Java Básico Programa de Tecnología en Cómputo referencia a ese objeto es polimorfita ya que puede referirse a objetos de diferentes clases.

En general. . El lenguaje de programación Java consiste en un lenguaje de programación y una plataforma. Una plataforma es el ambiente de hardware o software en el cual se ejecutan los programas.Manual del Curso Java Básico Programa de Tecnología en Cómputo 2:La Tecnología Java. La mayoría de los lenguajes se caracterizan por ser interpretados (por ejemplo: Basic) o bien por ser compilados (por ejemplo C) esto determina la manera en que serán ejecutados por la computadora.1 La Plataforma Java. Solaris. Algunas de las plataformas más populares son Windows. Figura 2. 8 . la mayoría de las plataformas pueden ser descritas como una combinación de hardware y sistema operativo. La plataforma Java difiere de las anteriores en que ésta es una plataforma basada únicamente en software que corre por encima de las plataformas basadas en hardware. Linux y MacOS. La plataforma Java consta de dos componentes: • • La Máquina Virtual de Java (JVM) La Interfaz de Programación de Aplicaciones de Java (API Java) A continuación se muestra una representación de los elementos que forman parte de la plataforma Java. Java tiene la característica de ser al mismo tiempo compilado e interpretado. El compilador es el encargado de convertir el código fuente de un programa en un código intermedio llamado bytecode que es independiente de la plataforma en que se trabaje y que es ejecutado por el intérprete de Java que forma parte de la Máquina Virtual de Java.

9 .com y descargarlo. esto quiere decir que la maquina virtual es la única que cambia de una plataforma a otra y es la encargada de interpretar y ejecutar los archivos Bytecode de nuestro programa. Se utiliza en la elaboración de programas standalone comúnmente utilizados para ser ejecutados de manera local en una PC..sun. La Interfaz de Programación de Aplicaciones (API) es el conjunto de paquetes y herramientas que nos ayudan a realizar la implementación de nuestro programa. • • • • • J2SE: Java Standard Edition. JavaCard: Con este API podemos incrustarnos en el mundo de la programación de las llamadas smartCards (como las tarjetas de telefono) a través del lenguaje java. Nos permite enlazar programas Java con directorios de información como un directorio de información LDAP. Para detalles de la instalación revisar el apéndice C. a continuación se muestran varios API (todos ellos bajo la tecnología Java) y una breve descripción de cada uno. La elección del API a utilizar depende del tipo de programa que queremos realizar. Existen numerosos API’s.2 La figura anterior muestra un aspecto importante: 1. PDA’s. Este API provee de las clases necesarias para la programación de dispositivos móviles tales como: Celulares. los cuales podemos mezclar en su mayoría para lograr aplicaciones robustas y facilitar su implementación y mantenimiento. J2EE: Java Enterprise Edition. Para obtener el J2SE que utilizaremos a lo largo del curso basta con entrar a la pagina de java: http://java. Son programas para ser ejecutados en una arquitectura cliente – servidor. J2ME: Java Micro Edition. JNDI: Java Naming and Directory Interface. Los programas de carácter general usan un API denominado J2SE (Java 2 Estándar Edición) y será el API que se use a lo largo de este manual.Manual del Curso Java Básico Programa de Tecnología en Cómputo Figura 2. etc. PALM.Como puede verse la máquina virtual esta por encima de la plataforma del Hardware.

escribirlo en un editor de texto plano como puede ser el block de notas de windows o bien el editor vi de unix. Aplicaciones: Las aplicaciones son programas standalone de propósito general que normalmente se ejecutan desde la línea de comandos del sistema operativo.3 muestra un esquema del proceso de construcción de una aplicación.Manual del Curso Java Básico Programa de Tecnología en Cómputo Tipos de programas en java. para entender su funcionamiento pasaremos a ejecutar un ejemplo directamente. Con Java se puede realizar cualquier programa que normalmente se crearía con algún otro lenguaje de programación. Servlets: Los servlets al contrario de los applets son programas que están pensados para trabajar en el lado del servidor y desarrollar aplicaciones Web que interactúen con los clientes. 10 . Los programas en Java suelen estar en una de las siguientes categorías: • Applets : Los applets son pequeños programas que se incorporan en una página Web y que por lo tanto. Los servlets son una alternativa de la programación CGI tradicional.3 Nuestro primer programa consiste en el tradicional hola mundo. A menudo los applets se descargan junto con una página HTML desde un Servidor Web y se ejecutan en la máquina cliente. Figura 2. • • Compilación y Ejecución de Programas La figura 2. necesitan de un Navegador Web compatible con Java para poder ejecutarse.

Java es un lenguaje sensitivo lo cual quiere decir que hace una distinción entre mayúsculas y minúsculas. Para nombrar métodos se usa la misma convención que para nombrar variables.out. la diferencia es que los métodos van seguidos por paréntesis. println(): método del atributo out. dicha convención se muestra a continuación y será la que adoptemos a lo largo de este manual: • Para nombrar clases se usa la letra en mayúscula al inicio de cada palabra. System: clase out: atributo de la clase System.println("Mi primer programa en java"). ejemplos: o miVariable o nombreDeVariable. } } Para ejecutar nuestro programa tenemos que seguir algunas reglas: El nombre del archivo debe tener el nombre de la clase publica. además la extensión siempre debe ser *. Hasta este momento tenemos listo el código fuente de nuestro programa en un archivo llamado HolaMundo.java. podemos identificar clases.java. métodos y variables.Manual del Curso Java Básico Programa de Tecnología en Cómputo public class HolaMundo { public static void main(String arg[]) { System.java este archivo esta listo para ser enviado al compilador de java: javac (de Java Compiler) Para invocar al compilador abrir una ventana de comandos (inicio. en este caso el nombre del archivo corresponde a HolaMundo. variables y métodos en el programa anterior: HolaMundo: es clase String: es clase main(): método main de la clase. ejemplos: o nombreDeMetodo() o realizarSuma() • • De esta forma. ejemplos: o NombreDeClase o HolaMundo Para nombrar variables o atributos se usa la primer palabra en minúsculas y en mayúscula la primer letra de las siguientes palabras que compongan el nombre. Java sigue ciertas convenciones en la asignación de nombres a clases. ejecutar y escribir cmd en sistemas Windows 2000 y XP) e invocar al compilador de la siguiente manera: 11 .

class) en las rutas especificadas por la variable de entorno CLASSPATH.4 muestra la ejecución del programa.java Si la compilación tuvo éxito el compilador nos devolverá el prompt del sistema operativo y nos generará un nuevo archivo en el directorio actual con el nombre: HolaMundo. de no existir la clase o no encontrarla java nos regresará un mensaje con el error encontrado. esto es por que Java busca la clase (el archivo ByteCode o .4 Tipos de datos primitivos. Java determina el tamaño de cada tipo primitivo. a pesar de ser un lenguaje orientado a objetos. en vez de crear un objeto. para estos tipos Java vuelve al enfoque de C y C++. 12 .Manual del Curso Java Básico Programa de Tecnología en Cómputo C:\> javac HolaMundo. La figura 2. Estos tamaños no varían de una plataforma a otra como ocurre en la mayoría de los lenguajes. y se coloca en la pila para que sea más eficiente. En el lenguaje de programación Java. Como siguiente paso hay que invocar a la maquina virtual de java (JVM) para que se encargue de interpretarlo. La razón para el tratamiento especial es que crear un objeto. se crea una variable “automática” que no es una referencia. Es decir. La variable guarda el valor. no todo es un objeto. esto se hace mediante la siguiente instrucción: C:\> java HolaMundo Nótese la ausencia de la extensión del archivo en este comando.class. Hay un grupo de tipos que tiene un tratamiento especial: se trata de los tipos “primitivos”. Figura 2. que será el archivo byteCode. para variables pequeñas y simples no es eficiente. que se usaran frecuentemente en los programas.

Precisión doble: bit de signo +11 bits de exponente + 52 bits de mantisa. es decir de los cuales se ha perdido su referencia. Java tiene un recolector de basura para recuperar la memoria de los objetos que ya no se usan. esta envoltura será vista a detalle en el capitulo 3: clases envolventes.Manual del Curso Java Básico Programa de Tecnología en Cómputo Tipo primitivo bolean char byte short int long float double void Tamaño 16 bits 8 bits 16 bits 32 bits 64 bits 32 bits 64 bits - Mínimo Unicode 0 -128 -215 -231 -263 IEEE754 IEEE754 - Máximo Unicote 216-1 +127 +215-1 +231-1 +263-1 IEEE754 IEEE754 - Envoltura Boolean Character Byte Short Integer Long Float Double Void El estándar IEEE754 especifica básicamente lo siguiente: Precisión sencilla: bit de signo + 8 bits de exponente + 23 bits de mantisa. Sin embargo puede existir la necesidad de realizar alguna acción cuando un objeto es destruido. El recolector de basura Los programadores conocen la importancia de la inicialización. El recolector de basura se ejecuta en un proceso en segundo plano cada determinado tiempo. Todos los tipos primitivos tienen asociada una envoltura o wrapper que se muestra en la última columna de la tabla anterior. pero a menudo se les olvida la importancia de la limpieza. verifica que objetos han dejado de usarse y libera esa porción de memoria al sistema operativo para su nueva reasignación. por ejemplo hacer uso de un destructor similar al de C++. 13 . Java soluciona este problema por medio del método finalize() que será visto en el siguiente capitulo.

println("Nombre: "+alumno1.println("Carrea: "+alumno1.apellidoMaterno). tenemos el siguiente código: public class Alumno { //Atributos de la clase String nombre. } } 14 . String numeroDeCuenta. Para poder crear un objeto es necesario que exista previamente la clase de ese objeto. esto es.out. int edad. alumno1. La siguiente es la definición más simple de una clase: class NombreClase { /* Declaración de la clase */ /* Aquí va la definición de variables y métodos */ } Veamos un ejemplo.println("Numero de cuenta: "+alumno1.out. String carrera.edad=20.apellidoPaterno+" "+alumno1.out.edad).semestre=4.out.numeroDeCuenta).out.numeroDeCuenta="03021458".nombre+" "+alumno1.carrera). // creamos un nuevo objeto de tipo alumno. System. alumno1. Ahora codificando esa clase. String apellidoMaterno. alumno1. String apellidoPaterno.apellidoPaterno="Hernandez". alumno1. alumno1.semestre). alumno1.carrera="Computacion". System. crearemos una clase llamada Alumno de esa clase vamos a crear un objeto.Manual del Curso Java Básico Programa de Tecnología en Cómputo 3: Clases y objetos Como hemos mencionado Java asume que se desea llevar a cabo exclusivamente programación orientada a objetos.nombre="Juan".apellidoMaterno="Lopéz". de que variables y de que métodos constarán. int semestre. System. public static void main(String args[]) { Alumno alumno1=new Alumno().println("Edad: "+alumno1. La definición de una clase especifica cómo serán los objetos de dicha clase. System. System.println("Semestre: "+alumno1. alumno1.

15 .println("Numero de cuenta: "+alumno1. String apellidoPaterno. alumno2. Al compilar y ejecutar este programa se obtendrá la siguiente salida: Numero de cuenta: 03021458 Nombre: Juan Hernandez Lopéz Edad: 20 Carrea: Computacion Semestre: 4 Ahora vamos a crear otro objeto de la clase Alumno. este contiene una copia de todos los atributos declarados en la clase siempre y cuando no estén declarados como static.apellidoPaterno="Hernandez". String apellidoMaterno.//inicializamos sus atributos.//inicializamos sus atributos.apellidoMaterno="Lopéz".semestre=1.carrera="Computacion". alumno1.Manual del Curso Java Básico Programa de Tecnología en Cómputo Veremos que es lo que esta pasando en este programa. public static void main(String args[]) { Alumno alumno1=new Alumno().// creamos un nuevo objeto de tipo alumno Alumno alumno2= new Alumno().numeroDeCuenta="040012548".println("Datos del alumno1:").). String carrera. alumno2.nombre="Juan". Electrica".apellidoPaterno="Rodriguez". En el ejemplo también es interesante resaltar el uso de operador + para concatenar cadenas. Esta sentencia crea un nuevo objeto. Una vez creado el objeto. int edad. alumno2. En el método main de la clase creamos un nuevo objeto de tipo Alumno en la sentencia: Alumno alumno1=new Alumno(). este nuevo alumno tendrá como referencia: alumno2. alumno2.edad=18. alumno1.numeroDeCuenta="03021458". y lo asigna a la referencia alumno1. con la palabra reservada new. alumno2. alumno2. alumno2.nombre="Pedro".semestre=4. alumno1.// creamos otro nuevo objeto alumno1.out. String numeroDeCuenta.out. public class Alumno { // atributos de la clase String nombre.numeroDeCuenta). alumno1.carrera="Ing. System. alumno1. Cuando ya esta creado el objeto podemos acceder a un atributo mediante el operador punto (. int semestre. System.apellidoMaterno="Rodriguez". alumno1.edad=20.

println("Edad: "+alumno1.Manual del Curso Java Básico Programa de Tecnología en Cómputo System. System.out.nombre+" "+alumno1.println("Nombre: "+alumno1.println("Carrea: "+alumno2.semestre).println("\nDatos del alumno2:").apellidoMaterno). La salida de este programa es la siguiente: Datos del alumno1: Numero de cuenta: 03021458 Nombre: Juan Hernandez Lopéz Edad: 20 Carrea: Computacion Semestre: 4 Datos del alumno2: Numero de cuenta: 040012548 Nombre: Pedro Rodriguez Rodriguez Edad: 18 Carrea: Ing. sin embargo el código propuesto hasta el momento resulta un tanto ineficiente ya que si quisiéramos crear 40 alumnos de un salón de clase e imprimir sus datos repetiríamos bastante el código que hasta ahorita tenemos y esto va en contra de la POO en donde la reutilización de código es algo primordial. System. System.println("Nombre: "+alumno2.out.out. System.println("Semestre: "+alumno2.semestre).apellidoMaterno).out.out. contiene una copia de los atributos de la clase los cuales almacenan valores de forma independiente. System.apellidoPaterno+" "+alumno1.println("Edad: "+alumno2. System. en este caso la acción ha realizar será imprimir el valor de sus 16 .println("Semestre: "+alumno1.out.println("Carrea: "+alumno1. Electrica Semestre: 1 Atributos y métodos En la versión 2 de nuestra clase Alumno hemos creado 2 objetos de esta clase.edad). entonces ¿Podemos unir esas líneas en una sola que permitan imprimir los datos de cualquier objeto tipo Alumno creado?. System. La respuesta es sí y esto se hará a través de un método.out. de esta forma podemos darnos cuenta de que cada objeto.out.out.apellidoPaterno+" "+alumno2. tanto alumno1 como alumno2.nombre+" "+alumno2. } } En este ejemplo hemos creado el nuevo objeto el cual tiene la referencia alumno2.carrera). System.edad).out. System. un método es una acción que puede ejecutar un objeto. Como ya se dijo en el capitulo 1.carrera). Si observamos las líneas de código en donde se imprimen los datos de cada alumno encontraremos que son prácticamente las mismas.numeroDeCuenta).println("Numero de cuenta: "+alumno2.

alumno1.//inicializamos sus atributos. alumno2.println("Carrea: "+carrera).edad=18.apellidoPaterno="Rodriguez".imprimirDatos(). alumno1.out. public class Alumno2 { // atributos de la clase String nombre.println("Numero de cuenta: "+numeroDeCuenta). System.apellidoMaterno="Lopéz".out. String carrera.apellidoMaterno="Rodriguez". alumno1.edad=20.println("Edad: "+edad).semestre=1. System.nombre="Juan".imprimirDatos(). System. public void imprimirDatos() { System.imprimirDatos(). para imprimir el valor de los atributos.// creamos un nuevo objeto de tipo alumno Alumno2 alumno2= new Alumno2(). int semestre. cuando es llamado 17 .apellidoPaterno="Hernandez". alumno1. System. imprime el valor de los atributos de este objeto. alumno2. alumno2. se muestra en la siguiente versión de la clase Alumno que renombraremos como Alumno2 para notar de mejor manera la evolución de nuestra clase.Manual del Curso Java Básico Programa de Tecnología en Cómputo atributos.out. alumno2. int edad. } } Hemos agregado el método imprimirDatos.semestre=4.carrera="Computacion".out. alumno2. este método es llamado por los dos objetos creados en las instrucciones: alumno1. alumno2. alumno1. alumno2. alumno1.numeroDeCuenta="03021458". es decir de alumno1. al ser ejecutado por alumno1.//inicializamos sus atributos.// creamos otro nuevo objeto alumno1.nombre="Pedro". Electrica". alumno1. String apellidoPaterno.carrera="Ing. String apellidoMaterno.out.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno). } public static void main(String args[]) { Alumno2 alumno1=new Alumno2(). alumno2. Cada objeto ejecuta este método el cual.println("Semestre: "+semestre).imprimirDatos(). La implementación del método. alumno2.numeroDeCuenta="040012548". String numeroDeCuenta.

alumno2.nombre="Pedro". Los constructores son métodos especiales que se ejecutan cuando un objeto es creado.carrera="Computacion". El constructor por default es agregado automáticamente por Java siempre y cuando la clase no contenga ningún constructor. Otra característica del constructor por default es que es un constructor que no tiene argumentos.edad=20. alumno2.//inicializamos sus atributos. 18 .semestre=1. Tiene el mismo nombre de la clase. su principal función es inicializar los atributos de un objeto y cuentan con las siguientes características: • • • Son llamados una sola vez cuando es creado el objeto.// creamos otro nuevo objeto alumno1. Hasta este momento no hemos definido ningún constructor para nuestra clase Alumno. Ahora agregaremos un constructor a nuestra clase Alumno2 que ahora la renombraremos por Alumno3.apellidoPaterno="Rodriguez".semestre=4.nombre="Juan".//inicializamos sus atributos. En la siguiente línea estamos utilizando el constructor por default. alumno2.carrera="Ing. ¿Podemos unir estas líneas en un método como se hizo con el método de imprimirDatos?. alumno2. alumno2.edad=18. alumno1.apellidoMaterno="Lopéz". alumno1.numeroDeCuenta="03021458". Podemos notar que la inicialización de los atributos de cada objeto vuelve a ser prácticamente la misma. es decir del que lo mando llamar. alumno1.apellidoMaterno="Rodriguez".// creamos un nuevo objeto de tipo alumno Alumno2 alumno2= new Alumno2(). Electrica". alumno2.apellidoPaterno="Hernandez". Alumno2 alumno1=new Alumno2(). La respuesta de nueva cuenta es sí. alumno1. alumno1. Constructores. pero sin embargo hemos estado haciendo uso del constructor por default. Alumno2 alumno2= new Alumno2(). No regresa ningún valor de retorno. Cuando se crea un objeto se manda llamar un método que recibe el nombre de constructor.Manual del Curso Java Básico Programa de Tecnología en Cómputo por alumno2 el método imprimirDatos busca el valor de los atributos de ese objeto. alumno2. la palabra reservada this En nuestra clase Alumno2 revisemos las siguientes líneas: Alumno2 alumno1=new Alumno2(). alumno1. La sentencia new Alumno2() constituye la llamada al constructor por default.numeroDeCuenta="040012548".

// creamos otro nuevo objeto alumno1. alumno1. int semestre. alumno1.. } } En este ejemplo hemos sobrescrito el constructor por default.out. alumno1..apellidoMaterno="Rodriguez". System.carrera="Ing.out.imprimirDatos().out. alumno2. esta nueva implementación solo imprime un mensaje cuando el constructor es invocado. alumno1. Creando un nuevo Alumno.// creamos un nuevo objeto de tipo alumno Alumno3 alumno2= new Alumno3().Manual del Curso Java Básico Programa de Tecnología en Cómputo public class Alumno3 { // atributos de la clase String nombre..println("Edad: "+edad).out.apellidoPaterno="Hernandez". System. String apellidoPaterno. alumno1. String apellidoMaterno. Numero de cuenta: 03021458 19 .println("Semestre: "+semestre). alumno2.edad=18.apellidoPaterno="Rodriguez".numeroDeCuenta="03021458". String carrera.out.semestre=4. System. alumno2. alumno2.edad=20.println("Creando un nuevo Alumno. la salida del programa quedará de la siguiente forma: Creando un nuevo Alumno.println("Numero de cuenta: "+numeroDeCuenta). alumno2.numeroDeCuenta="040012548".out. Electrica".apellidoMaterno="Lopéz".//inicializamos sus atributos.semestre=1.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno). alumno1. int edad. } public static void main(String args[]) { Alumno3 alumno1=new Alumno3().").nombre="Pedro".println("Carrea: "+carrera).nombre="Juan". alumno1... alumno2. String numeroDeCuenta. alumno2.imprimirDatos().//inicializamos sus atributos. alumno2.. public Alumno3() { System. } public void imprimirDatos() { System. System.carrera="Computacion".

para esta cambiaremos a firma del constructor de la siguiente manera: public Alumno3(String nom. semestre=sem. nombre=nom.println("Numero de cuenta: "+numeroDeCuenta). numeroDeCuenta=cuenta. Con esta modificación al constructor nuestro programa quedará de la siguiente manera: public class Alumno4 { // atributos de la clase String nombre. int edad. int semestre. int sem. System. String apellidoPaterno. String carrera. String apeMat. String numeroDeCuenta. String car.Manual del Curso Java Básico Programa de Tecnología en Cómputo Nombre: Juan Hernandez Lopéz Edad: 20 Carrea: Computacion Semestre: 4 Numero de cuenta: 040012548 Nombre: Pedro Rodriguez Rodriguez Edad: 18 Carrea: Ing. Electrica Semestre: 1 Lo que demuestra que el constructor es invocado cada vez que se crea un nuevo objeto de la clase.println("Edad: "+edad).out.println("Carrea: "+carrera). } 20 . apellidoPaterno=apePat.out. es seguida explicaremos la razón.println("Creando un nuevo Alumno. System.out.. String car.out.out. } public void imprimirDatos() { System. int sem. String cuenta) { System. int anios. System. int anios. String apeMat. String apePat. String apePat.. Ahora adecuaremos la firma del constructor para que pueda recibir argumentos e inicialice los atributos del objeto. carrera=car.out. String apellidoMaterno. String cuenta) { … } Observa que hemos cambiado intencionalmente el nombre de las variables para que no concidan con el nombre de los atributos.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno).println("Semestre: "+semestre). apellidoMaterno=apeMat."). public Alumno4(String nom. edad=anios. System.

imprimirDatos(). edad=edad."computacion". el código se encuentra en el archivo Alumno5.18. Electrica". } } Al correr este código veremos que se obtiene el mismo resultado. cambiemos en nombre de las variables de los argumentos del constructor por el mismo nombre que tienen los atributos. //creamos otro nuevo objeto Alumno4 alumno2= new Alumno4("Pedro".java en el cual se hizo el siguiente cambio en el constructor. Creando un nuevo Alumno.out. Numero de cuenta: null Nombre: null null null Edad: 0 Carrea: null Semestre: 0 Numero de cuenta: null Nombre: null null null Edad: 0 Carrea: null Semestre: 0 Como puede verse los atributos de cada objeto no fueron inicializados."03021458"). apellidoPaterno=apellidoPaterno."Hernadez". esto ocurre debido a que la asignación de variables en el constructor es únicamente de forma local."Rodriguez". semestre=semestre.Manual del Curso Java Básico Programa de Tecnología en Cómputo public static void main(String args[]) { //creamos un nuevo objeto de tipo alumno Alumno4 alumno1=new Alumno4("Juan". alumno2.20. } El resultado de realizar estos cambios se muestra a continuación: Creando un nuevo Alumno."Rodriguez". String numeroDeCuenta) { System."). carrera=carrera.imprimirDatos().. int semestre."040012548").. int edad. public Alumno4(String nombre."Lopez"..println("Creando un nuevo Alumno.4.. String apellidoPaterno. el resultado podría ser inesperado. apellidoMaterno=apellidoMaterno. alumno1. es decir la sentencia: nombre=nombre.. nombre=nombre. String carrera. numeroDeCuenta=numeroDeCuenta."Ing.. String apellidoMaterno. Ahora revisemos de nueva cuenta el constructor.1. 21 .

semestre=semestre. nunca se afecta al atributo del objeto. int semestre. podemos mejorar nuestro código de la siguiente manera: public class Alumno6 { // atributos de la clase String nombre.out. public Alumno6(String nombre.Manual del Curso Java Básico Programa de Tecnología en Cómputo La variable nombre del lado derecho hace referencia a la variable nombre declarada en los argumentos del constructor siendo la misma variable la del lado derecho.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno). String numeroDeCuenta) { System. System.out.imprimirDatos().."Rodriguez". this.18.out. int edad."040012548").edad=edad.out. int edad. int semestre.out. alumno1."Lopez". this. String apellidoPaterno.numeroDeCuenta=numeroDeCuenta. System.out.4.println("Numero de cuenta: "+numeroDeCuenta). String apellidoMaterno.println("Semestre: "+semestre)."03021458"). } } 22 ."Rodriguez". String carrera."computacion". Con el uso de la palabra reservada this. Electrica". String apellidoPaterno.apellidoMaterno=apellidoMaterno. es decir es una asignación entre la misma variable. this.println("Creando un nuevo Alumno.nombre=nombre."). String apellidoMaterno.println("Edad: "+edad). this. } public void imprimirDatos() { System..apellidoPaterno=apellidoPaterno. String carrera. alumno2. //creamos otro nuevo objeto Alumno6 alumno2= new Alumno6("Pedro". this.20. this."Ing. System. String numeroDeCuenta. Para poder hacer una distinción de una variable local y un atributo del objeto con el mismo nombre se usa la palabra reservada this.imprimirDatos().println("Carrea: "+carrera). System."Hernadez".carrera=carrera.1. this. } public static void main(String args[]) { //creamos un nuevo objeto de tipo alumno Alumno6 alumno1=new Alumno6("Juan".

Flor y= new Flor("Rosa". //No se pueden invocar dos this.println("Numero de petalos: "+numeroPetalos+" texto= "+texto). } public void print() { //this(11). } 23 .Manual del Curso Java Básico Programa de Tecnología en Cómputo En este ejemplo. Invocando a Constructores desde Constructores. String texto=null.out.print().out. texto= "+ss). x.out.println("Constructor: Parametro cadena y entero"). } public Flor() { this("Hola". podemos decir que la palabra reservada this hace referencia al objeto que mando llamar el método. System.texto=ss.out. texto=ss. petalos= "+petalos).println("Constructor por defecto (Sin parametros)"). // No se puede invocar this dentro de un no-constructor System. Esto se puede lograr utilizando la palabra reservada this. hay veces en las que uno quisiera invocar a un constructor desde otro para evitar la duplicación de código. en esta caso el constructor. que produce la misma salida de las versiones anteriores de Alumno.20).println("Constructor: Parametro cadena solo. } public Flor(String ss) { System. La palabra clave this toma un significado diferente cuando se le da una lista de parámetros: hace una llamada explícita al constructor que coincida con la lista de parámetros. //! this(ss). System. Cuando se escriben varios constructores para una clase.print(). Por consiguiente.18). int petalos) { this(petalos). } public Flor(String ss. } public static void main(String args[]) { Flor x= new Flor().println("Constructor: Parametro entero solo. public Flor(int petalos) { numeroPetalos=petalos.out. System. y. hay una manera directa de llamar otros constructores. Ejemplo: public class Flor { int numeroPetalos=0.

carrera=carrera. es decir por un lado en un archivo la clase Alumno que renombraremos por Alumno7 y por el otro una clase llamada escuela en un archivo distinto. int edad. String carrera.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno).out.println("Carrea: "+carrera).numeroDeCuenta=numeroDeCuenta. petalos= 20 Constructor: Parametro cadena y entero Constructor por defecto (Sin parametros) Numero de petalos: 20 texto= Hola Constructor: Parametro entero solo. debe ser la primer cosa que se haga o se obtendrá un mensaje de error del compilador. String carrera. Estos dos archivos deberán encontrarse en el mismo directorio por el momento. this.apellidoMaterno=apellidoMaterno.. } public void imprimirDatos() { System. this.java public class Alumno7 { // atributos de la clase String nombre. String apellidoPaterno.println("Edad: "+edad). String apellidoMaterno. es decir como llamada al constructor. System. this.nombre=nombre. String numeroDeCuenta.. System.println("Creando un nuevo Alumno. } } 24 . public Alumno7(String nombre.println("Semestre: "+semestre).out.out. this."). this.edad=edad. String numeroDeCuenta) { System. int semestre. La salida del programa anterior es la siguiente: Constructor: Parametro entero solo. System.semestre=semestre.apellidoPaterno=apellidoPaterno.out. System. petalos= 18 Constructor: Parametro cadena y entero Numero de petalos: 18 texto= Rosa Para terminar con este apartado mostraremos un ejemplo final de la clase Alumno hasta ahora modificada pero esta vez en archivos distintos. int edad. this. Además el uso de this con parámetros. this. //Alumno7.println("Numero de cuenta: "+numeroDeCuenta).out. String apellidoMaterno. String apellidoPaterno. int semestre.out.Manual del Curso Java Básico Programa de Tecnología en Cómputo } En el ejemplo anterior podemos observar el uso de varios constructores para crear objetos.

independientemente de cuántos objetos se creen. Con los datos y métodos ordinarios no estáticos."Ing. } } Se comprobará que la salida no cambia en relación a programas anteriores.imprimirDatos(). La sintaxis recomendada de llamar a una variable o método de clase es la siguiente: 25 ."Hernadez". estos métodos y datos que necesitan un objeto para poder ser utilizados reciben el nombre de variables y métodos de instancia. por ejemplo: public class PruebaEstatica { static int i=47. se necesita un método al que se puede invocar incluso si no se ha creado ningún objeto. alumno2."040012548"). momento en el que se crea el espacio de almacenamiento y los métodos pasan a estar disponibles.4. Pero hay dos situaciones en las que este enfoque no es suficiente. Para declarar un dato o un método static."Rodriguez". } Ahora."03021458"). incluso si se construyen dos objetos de tipo PruebaEstatica. Variables y métodos de clase Generalmente. La otra es si se necesita un método que no esté asociado con ningún objeto particular de esa clase. Una es cuando se desea tener solamente un fragmento de espacio de almacenamiento para una parte concreta de datos.java public class Escuela { public static void main(String args[]) { //creamos un nuevo objeto de tipo alumno Alumno7 alumno1=new Alumno7("Juan". No se tiene nada hasta crear un objeto de ese clase con new.18. Electrica". Al decir que algo es estático se está indicando que el dato o método no está atado a ninguna instancia de objeto de esa clase. o incluso aunque no se cree ninguno. es necesario crear un objeto para poder utilizarlos. sólo habrá un espacio de almacenamiento.imprimirDatos().1. es decir ambos objetos compartirán la misma i. Ambos efectos se pueden lograr con la palabra clave static.20. Es decir. //creamos otro nuevo objeto Alumno7 alumno2= new Alumno7("Pedro". alumno1."Lopez"."Rodriguez".Manual del Curso Java Básico Programa de Tecnología en Cómputo //Escuela. al crear una clase se está describiendo qué apariencia tienen sus objetos y cómo se comportan. basta con colocar la palabra clave static antes de la definición."computacion".

numeroDeCuenta=numeroDeCuenta. int semestre. NombreDeClase. numeroDeAlumnos++. this. no se crean copias para cada objeto.apellidoMaterno=apellidoMaterno.java public class Alumno8 { // atributos de la clase String nombre. int semestre. int edad. } } Hemos agregado un método y una variable estática. //Escuela2. int edad.semestre=semestre. System. System. cada que creas un objeto se crea un copia para cada objeto String apellidoPaterno. String numeroDeCuenta.out. String carrera. //nombre="Paco".out.println("Edad: "+edad). public Alumno8(String nombre.out.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno). this. String carrera.// modificamos una variable de clase } public static String metodoDeClase() { String mensaje="Metodo de clase".. Modifiquemos nuestro ejemplo de la clase Alumno para ver un ejemplo: //Alumno8.println("Numero de cuenta: "+numeroDeCuenta).out. this. static int numeroDeAlumnos=0.carrera=carrera.nombre=nombre. this..println("Semestre: "+semestre). ahora modifiquemos el archivo Escuela para mandar llamar las variables estáticas.nombreDeAtributo. String numeroDeCuenta) { System.// variable de clase. this.println("Carrea: "+carrera).out. System.nombreDeMétodo(). String apellidoMaterno. } public void imprimirDatos() { System. this.java public class Escuela2 { public static void main(String args[]) 26 . // variable de instancia. this.edad=edad. System. es fija.println("Creando un nuevo Alumno.out.apellidoPaterno=apellidoPaterno. String apellidoMaterno. String apellidoPaterno.Manual del Curso Java Básico Programa de Tecnología en Cómputo NombreDeClase. //Un método de clase o puede modificar variables de instancia return mensaje.").

out. public static void main(String args[]) La referencia args es un arreglo de objetos tipo String. Numero de Alumnos: "+alumno1.out. //creamos un nuevo objeto de tipo alumno Alumno8 alumno1=new Alumno8("Juan".18. mostrando el resultado en pantalla. Pero esto ocasionará un problema: los datos estarán en un objeto String lo que dificultara la operación de suma que queremos realizar. Esto quiere decir que si se desea hacer un objeto no primitivo para representar ese tipo primitivo. para acceder al primer parámetro utilizaremos el índice 0 del arreglo y 1 para el segundo.println("Mensaje del metodo de clase: "+Alumno8."Rodriguez".1. Numero total de Alumnos: 2 Desde alumno1. Por ejemplo: char c= ‘x’. //Los objetos tambien pueden modificar las variables estaticas directamente: alumno2. } } { La salida de este programa deberá ser la siguiente: Numero total de Alumnos: 0 Mensaje del metodo de clase: Metodo de clase Creando un nuevo Alumno. la variable estatica se ha modificado System.out.."Hernadez".20.out..println("Desde alumno1. System. que veremos más adelante en este capitulo. Numero de Alumnos: 2 Numero total de Alumnos: 3 Clases envolventes o wrappers Los tipos de datos primitivos tienen asociado una clase “envoltura”.numeroDeAlumnos).println("Numero total de Alumnos: "+Alumno8."03021458"). //creamos otro nuevo objeto Alumno8 alumno2= new Alumno8("Pedro".4..numeroDeAlumnos). //Despues de crear dos objetos."computacion". Para utilizar los parámetros de la línea de comandos utilizamos el arreglo de String que viene en la firma del método main. System.metodoDeClase())."Lopez".Manual del Curso Java Básico Programa de Tecnología en Cómputo //Las variables y métodos de clase se pueden usar sin crear un objeto System.out. //Los objetos tambien pueden accesar a las variables y metodos estaticos System. queremos realizar un programa que reciba desde la línea de comandos dos números y que los sume. para solucionar esto utilizaremos la clase envolvente Integer 27 .numeroDeAlumnos)."Rodriguez".println("Numero total de Alumnos: "+Alumno8. se hace uso del envoltorio asociado.println("Numero total de Alumnos: "+Alumno8."Ing..numeroDeAlumnos++.numeroDeAlumnos). Electrica"."040012548"). Charácter C = new Character(c) Veamos un ejemplo más práctico. Creando un nuevo Alumno.

sino agrupados en una colección de información. Para declara un array basta escribir: int[] suma.out. El array es una secuencia lineal simple. pero se paga por esa velocidad: cuando se crea un objeto array su tamaño es limitado y no puede variarse.Manual del Curso Java Básico Programa de Tecnología en Cómputo que nos provee de un método para realizar esta conversión de un String a un int.parseInt(args[1]).java C:\ java SumaDeNumeros 1 2 Arreglos. o bien: 28 . desempeñando funciones útiles en los programas.parseInt(args[0]). en la vida tratamos con datos que no están aislados. como contadores. Existen muchas otras formas de guardar objetos. System. El array es la forma más eficiente que proporciona Java para almacenar y acceder al azar a una secuencia de objetos (verdaderamente. El siguiente ejemplo ilustra lo anterior. String nombre. int c= a+b. sumas o lo que sea. hemos descrito datos (variables) individuales y aislados. Podemos pensar en estas variables como posiciones en memoria que tienen asignados nombres individuales. public class SumaDeNumeros { public static void main(String args[]) { int a= Integer. Estos datos trabajan por su cuenta. int b= Integer.println("El resultado de la suma es: "+c). Hasta ahora. suma. Por ejemplo: int contador. En contraste. Para solucionar este problema contamos con un tipo de almacenamiento que son los arrays. pero como se verá a continuación el array tiene dos aspectos especiales con respecto a otros tipos de contenedores: la eficiencia y el tipo. que hace rápidos los accesos a elementos. referencias a objetos). } } para ejecutar este programa hay que hacerlo de la siguiente manera: C:\ javac SumaDeNumeros.

out.print(enteros[i] + " "). primero se declara el tamaño y luego se inicializa el array cabe destacar que para especificar el 29 .out. "Antonio". Un ejemplo de un primer array de cadenas es el siguiente: public class PrimerArray{ public static void main(String arg[]){ String nombres[] ={ "Juan". System.length. // crea el objeto que alamcenara 10 enteros // inicializa los elementos del arreglo y lo imprime for (int i = 0.length). si no que guarda directamente el valor de cada elemento. nombres[2]="Alejandro".Manual del Curso Java Básico Programa de Tecnología en Cómputo int suma[]: Son exactamente la misma sentencia. System.println(nombres[0]). He aquí la salida del programa: Numero de elementos en el array: 4 Juan Maria Alejandro Victoria También podemos realizar array de tipos primitivos.out. } } } Este ejemplo muestra otra forma de inicializar el array. "Victoria" }. Ejemplo: public class ArrayDeEnteros { public static void main(String[] args) { int[] enteros. } } Java permite varias formas de inicializar los array. que declara que la referencia suma será un array de objetos. la diferencia es que el objeto array no guarda referencias como array con objetos.println(nombres[1]). "Maria". // declara un arreglo de enteros enteros = new int[10]. System. i < enteros.println(nombres[3]). System.println(nombres[2]). System.out. el acceso a cada elemento de un array se realiza mediante el índice del elemento. i++) { enteros[i] = i.out.println("Numero de elementos en el array: "+nombres.out. System.

los usuarios de linux notarán una semejanza con las opciones tar. Genera una salida que describe que va haciendo jar. que es una forma de coleccionar un grupo de archivos en un único archivo comprimido. no los comprime (usarlo para crear un archivo JAR que se puede poner en el CLASSPATH) No crear automáticamente un archivo de declaración. Las opciones son: c t x x file f m v O M Crea un archivo nuevo vacío. Se invoca en la línea de comandos: jar [opciones] destino [manifiesto] archivo(s)Entrada Las opciones son simplemente una colección de letras. Nombre del archivo. Lista la tabla de contenidos. Extraer el archivo nombrado. Sin embargo. los ficheros JAR son multiplataforma. Java archivos (JAR) El formato ZIP también se usa en el formato de archivos JAR (Java ARchive). por ejemplo: int[][] ventas = new ventas[4][7] . También se pueden incluir archivos de audio e imagen.Manual del Curso Java Básico Programa de Tecnología en Cómputo tamaño del array se usa new int[10]. 30 . Indica que el primer parámetro será el archivo de declaración. o archivos de clases. Esta instrucción declara una matriz de 4 x 7 elementos. nótese el cambio de corchetes por los tradicionales paréntesis. para crear un arreglo de dos dimensiones usamos dobles corchetes. Un archivo JAR consta de un único archivo que contiene una colección de archivos ZIP junto con una declaración que los describe. por lo que no hay que preocuparse por aspectos de plataforma. como todo lo demás en Java. exactamente igual que el ZIP. Extrae todos los archivos. la salida del programa se muestra a continuación: 0123456789 Arrays de dos dimensiones Java ofrece una extensión natural de los arreglos unidimensionales a dos dimensiones. Simplemente almacena los archivos. La utilidad jar que viene con el JDK de Sun comprime automáticamente los archivos que se seleccionan.

class Escuela2. Por tanto. éste te proporciona la habilidad de llevar acabo alguna limpieza importante a la vez que la recolección de basura. Por ejemplo vamos a comprimir en un archivo JAR las dos ultimas clases que trabajamos de la versión de nuestra clase Alumno que son: Alumno8 y Escuela2. Cuando el recolector de basura está preparado para liberar el espacio de almacenamiento utilizado por el objeto.Manual del Curso Java Básico Programa de Tecnología en Cómputo He aquí una forma habitual de invocar a Jar: C:\jar cf miArchivoJar. El recolector de basura sólo sabe liberar la memoria asignada por new.jar Limpieza: Finalización y recolección de basura. junto con un archive declaración creado automáticamente.class Para ejecutar el archivo escribir: C:\>java –jar Escuela.MF Como siguiente paso vamos a comprimir los archivos. si se elige usar finalize(). este archivo puede ser escrito en un editor de texto plano como puede ser notepad de Windows o vi de Linux: Manifest-Version: 1. Supóngase que los objetos asignan memoria “especial” sin utilizar new.MF Escuela.jar Alumno8. 31 . en la línea de comandos escribe: C:\ >jar cmf MANIFEST.0 Created-By: 1. En el capitulo anterior hablamos del recolector de basura como un proceso que se ejecuta en segundo plano y libera la memoria de aquellos objetos que han perdido su referencia. Primero vamos a crear nuestro archivo Manifiesto que tenga la siguiente información. He aquí como se supone que funciona.class Esto crea un fichero JAR llamado miFichero.jar *. Para hacer frente a este caso. Java proporciona un método denominado finalize( ) que se puede definir en cada clase. Considere ahora un caso muy inusual.jar que contiene todos los archivos de clase del directorio actual. y sólo recuperará la memoria del objeto durante la pasada del recolector de basura. guarda este archivo en el mismo directorio de tus clases con el nombre: MANIFEST.0_02 (Sun Microsystems Inc. por lo que ahora no sabrá como liberar esa memoria “especial” del objeto.5. El archivo de declaración que es creado automáticamente puede tener varias utilidades como por ejemplo indicar la clase a partir de la cual se podrá ejecutar el archivo completo JAR. primero invocara a finalize( ).) Main-Class: Escuela2 Nota que hemos especificado la clase que contiene el método main a ejecutar.

} finalizadas++.out. considere un objeto que dibuja una figura en pantalla. } if(i==47) { System.println("Creadas 47"). static int creadas = 0. if(finalizadas>=creadas) System. que es una función que siempre se invoca. Java no cuenta con algo parecido así que si se necesita para un programa en específico tendrá que ser programado por su cuenta. Esto puede ocurrir principalmente a través de métodos nativos. "+ "Poniendo el indicador que evita la creacion de mas f=true. static boolean f= false.println("Las "+finalizadas+" han sido finalizadas"). que son la forma de invocar a código no-Java desde Java. static int finalizadas =0.out.println("Finalizando la silla #47. Pero la limpieza y recolección de basura esta ligada exclusivamente a la liberación de memoria.Manual del Curso Java Básico Programa de Tecnología en Cómputo Hay que señalar que no es lo mismo que un destructor para C++. if(creadas==47) System.out. Por ejemplo. public Silla() { i= ++creadas. int i. en los que un objeto puede reservar espacio de almacenamiento de forma distinta a la creación de un objeto. Resulta que la necesidad de finalize( ) se limita a casos especiales. el recolector de basura puede eliminar el objeto pero no la información que dibujo en pantalla.println("Comenzando a finalizar tras haber creado "+ creadas +"sillas"). sillas").out. } 32 . El ejemplo siguiente resume las descripciones anteriores del recolector de basura: //Silla. Una de las cosas para las que puede ser útil finalize( ) es para observar el proceso de recolección de basura. } public void finalize() { if(!recolector) {//la primera vez que se invoca a finalize(): recolector=true. System.java //Demostracion de recolector de Basura y //finalizacion public class Silla { static boolean recolector=false.

entonces (sabiamente) no malgastará tiempo en recuperar memoria mediante el recolector de basura. Si se llama a System. y hay un indicador denominado recolector para indicar si el recolector a comenzado su ejecución o no.gc(). Un segundo indicador f es la forma de que Silla le comunique al bucle main( ) que deberá dejar de hacer objetos.gc() se finalizan todos los objetos. lo que hará cuando se empiece a poner nervioso por la cantidad de memoria disponible. Ambos indicadores se ponen dentro de finalize( ). total finalizadas: 33864 Por consiguiente. no se invoca a todos los finalizadotes cuando acaba el programa.out. Dado que el recolector puede ejecutarse en cualquier momento. uno no sabe exactamente cuando empezará. y en cierto momento después de que el recolector de basura comience a ejecutarse el programa deja de crear objetos Silla.f) { new Silla(). //hacer sillas y cadenas de texto while(!Silla.java public class Basura { public static void main(String args[]) { //Mientras no se haya puesto la bandera. Poniendo el indicador que evita la creacion de mas sillas Las 33864 han sido finalizadas Despues de haber creado todas las sillas: Creadas en total: 33865. La creación de un objeto String en cada iteración es simplemente la asignación de almacenamiento extra para animar al recolector de basura a actuar. Si la Máquina Virtual Java (JVM) no está a punto de quedarse sin memoria.Manual del Curso Java Básico Programa de Tecnología en Cómputo } //Basura. Recuerde que ni el recolector de basura ni la finalización están garantizadas. } } El programa anterior crea muchos objetos Silla. 33 . total finalizadas: "+Silla.finalizadas). } System. Una posible salida del programa anterior se muestra a continuación: Creadas 47 Comenzando a finalizar tras haber creado 12207sillas Finalizando la silla #47.creadas+". Existe también una forma de invocar al recolector de basura explícitamente cuando el programador lo desee y esto se hace mediante el método: System. que se invoca durante la recolección de basura. new String("Ocupar Espacio"). por consiguiente se destruirán todos los objetos que no estén en uso en ese momento.println("Despues de haber creado todas las sillas: \n"+ "Creadas en total: "+Silla.

ese fichero debería ser cerrado por el programador antes de que el objeto sea eliminado por el recolector de basura. que es lo que verdaderamente hay que cuidar. //Cargarse la referencia olvidando la limpieza new Libro(true). El valor de finalize( ) es que puede usarse para descubrir esta condición. 34 . pero en el método main( ) un error del programador no comprueba alguno de los libros. } } La condición de muerto consiste en que todos los objetos libros supuestamente serán comprobados antes de ser recogidos por el recolector de basura.Manual del Curso Java Básico Programa de Tecnología en Cómputo La condición de Muerto En el momento que uno deja de estar interesado en un objeto –cuando está listo para ser eliminado– el objeto debería estar en cierto estado en el que su memoria puede ser liberada de manera segura. } public void finalize() { if(comprobado) System.println("Error: comprobado").out. si el objeto representa un fichero abierto. se descubre el problema.java //Utilizacion de finalize() para detectar un objeto // que no ha sido correctamente eliminado public class Libro { boolean comprobado=false. incluso si no se invoca siempre. //forzar la recoleccion de basura y finalizacion System. se tendrá un fallo en el programa que podría ser difícil de encontrar. } void correcto() { comprobado=false. public Libro(boolean comprobar) { comprobado=comprobar. Por ejemplo. //Eliminacion Correcta novela. Si no se eliminan correctamente ciertas porciones de objeto.java public class CondicionDeMuerto { public static void main(String[] args) { Libro novela = new Libro(true). } } //CondicionDeMuerto. Si una de las finalizaciones acaba revelando el fallo. He aquí un ejemplo simple de cómo debería usarse: //Libro.correcto().gc().

La salida de javadoc es un archivo HTML que puede visualizarse a través del navegador web. este error sería difícil de encontrar. el comentario relativo a una variable precede siempre a la definición de la variable. Sintaxis Todos los comandos de javadoc se dan únicamente en comentarios /**. que fue heredado por C++. /** Un comentario de un método */ public void f( ){} } 35 .Manual del Curso Java Básico Programa de Tecnología en Cómputo Sin finalize( ) para verificar la condición de muerte. Hay dos formas principales de usar javadoc: empotrar HTML. Una de las partes más interesantes del lenguaje Java es que los diseñadores no sólo tuvieron en cuenta que la escritura de código era la única actividad importante. Gracias a javadoc se tiene incluso un estándar para la creación de documentación. una variable o un método. es necesaria una sintaxis especial y una herramienta para extraer esos comentarios. tan sencillo que se puede incluso esperar o solicitar documentación con todas las bibliotecas Java. Utiliza parte de la tecnología del compilador Java para extraer etiquetas de comentarios especiales. Es decir. Un ejemplo simple: /** Un comentario de clase */ public class PruebaDoc { /** Un comentario de una variable */ public int i. Estos comentarios empiezan por /* y pueden extenderse a lo largo de varias líneas hasta encontrar */. Kas etiquetas doc son comandos que comienzan por ‘@’ y se sitúan al principio de una línea de comentarios. La herramienta para extraer comentarios se le denomina javadoc. el comentario relativo a una clase aparece justo antes de la definición de la misma. El primero es el estilo de comentarios tradicional de C. sino que también pensaron en la documentación del código. que corresponden con el elemento al que precede el comentario: una clase. Estos comentarios acaban con */. Hay tres “tipos” de documentación en forma de comentarios. y un comentario de un método aparece inmediatamente antes de la definición de un método. sin embargo. o utilizar “etiquetas doc”. Comentarios y documentación Hay dos tipos de comentarios en Java. Esto se hizo mediante comentarios especiales que se incrustan dentro del código fuente.

el motivo principal es permitir dar formato al código. Javadoc generará HTML con las etiquetas @see en forma de vínculos a la otra documentación. sin embargo. Forma de uso: @param nombre-parámetro descripción @return: especifica una descripción para un valor de retorno @return descripción @throws: Descripción para las excepciones. @author: Suele ser el nombre del creador pero podría ser cualquier cosa como la dirección de correo. variable y métodos) pueden contener etiquetas @see.out. La forma es: @see NombreDeClase @version: Información de la versión de la clase. que permiten hacer referencia a la documentación de otras clases. 36 .println(new Date()). Los tres tipos de comentarios de documentación (de clase. La forma de uso es: @author información-del-autor @param: permite especificar una descripción de un parámetro. como: /** * <pre> * System.Manual del Curso Java Básico Programa de Tecnología en Cómputo HTML empotrado Javadoc pasa comandos HTML al documento HTML generado. que serán vistas en el curso de java Avanzado. Esto permite un uso total de HTML. * </pre> */ También puede usarse HTML como se haría en cualquier otro documento web para dar formato al propio texto de las descripciones: /** * * * * * * */ Uno puede <em>incluso</em> insertar una lista: <ol> <li> Elemento uno <li> Elemento dos <li> Elemento tres </ol> @see: Referencias a otras clases. La forma es: @version información-de-version.

Vector. uso. } public void run(){ } /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub } } Para ejecutar el comando javadoc en un ventana de comandos escribir: javadoc Comantada. Se utilizan * @param arg1 Comentario del parámetro 1 * @param arg2 Comentario del parámetro 2 * @param num Comentario del parámetro n * @return Comentario del valor de retorno * @throws Exception Comentario sobre alguna excepción que regrese */ private int Metodo(String arg1. /** * Tambien los métodos constructores pueden ir comentados * */ public Comentada(){ } /** * Asi se comentan lo métodos.<br> * En esta parte.java y la herramienta javadoc generará el archivo html en el directorio actual. /** * Este es una atributo de clase.Manual del Curso Java Básico Programa de Tecnología en Cómputo @throws nombre-de-clase descripción Ejemplo de documentación. * @author PROTECO * */ public class Comentada extends Vector implements Runnable{ /** * Asi se comentan los atributos */ protected String atributo. * para darle formato al texto. import java. /** * Este es un ejemplo de código comentado<br> * <h1>Se pueden usar etiquetas de HTML</h1>.util. y funcionamiento * de la clase en general.Vector arg2. 37 . Se da una descripción de lo que hacen * y se pueden dar algunos ejemplos. y no modificable */ static final int VALOR=10. se describe sobre las características.int num) throws Exception{ return 0.

Los String se pueden crear explícitamente o implícitamente.startsWith("El"). Sin embargo. según que el string comience o no por dicho prefijo: String str="El primer programa". pero aún no se ha creado ningún objeto de esta clase.out.Manual del Curso Java Básico Programa de Tecnología en Cómputo 4:La Clase String Dentro de un objeto de la clases String o StringBuffer. Java crea un objeto de la clase String automáticamente. Podemos conocer si un string comienza con un determinado prefijo. int longitud=str.length(). Cómo se obtiene información acerca del String Una vez creado un objeto de la clase String podemos obtener información relevante acerca del objeto a través de las funciones miembro. Para crear un String nulo se puede hacer de estas dos formas String str="". También se puede escribir. Para crear un String explícitamente escribimos: String str=new String("El primer programa"). String str="El primer programa". alternativamente String str="El primer programa". Java crea un array de caracteres de una forma similar a como lo hace el lenguaje C++. boolean resultado=str. String str=new String(). pero es un objeto de la clase String. Para obtener la longitud.println("El primer programa"). A este array se accede a través de métodos de la clase. En este ejemplo la variable resultado tomará el valor true. 38 . número de caracteres que guarda un String se llama al método length. Está declarando un objeto str de la clase String. cuando se escribe: System. que devuelve true o false. Por ejemplo. Un string nulo es aquél que no contiene caracteres. Para crear un String implícitamente basta poner una cadena de caracteres entre comillas dobles. llamando al método startsWith. String str.

println("Distinto contenido"). se llama a otra versión de la misma función pos=str.out.println("El mismo contenido"). boolean resultado=str. Otra versión de indexOf busca la primera ocurrencia de un substring dentro del String: String str="El primer programa". se usa la función indexOf: String str="El primer programa".out. int pos=str.indexOf('p'. pos+1).println("Los mismos objetos").indexOf('p').endsWith("programa"). 39 . podemos saber si un String finaliza con un conjunto dado de caracteres. El segundo argumento le dice a la función indexOf que empiece a buscar la primera ocurrencia de la letra p a partir de la posición pos+1. } else { System.equals(str2)) { System. Vemos que una clase puede definir varios métodos con el mismo nombre pero que tienen distinto número de parámetros o de distinto tipo. mediante el método endsWith: String str="El primer programa". } else { System. Para obtener las sucesivas posiciones de la letra p. int pos=str. if(str1==str2) { System.indexOf("pro"). Si se quiere obtener la posición de la primera ocurrencia de la letra p. esto se conoce como sobrecarga de métodos y será visto a detalle en el siguiente capitulo.out. Comparación de Strings La comparación de strings nos da la oportunidad de distinguir entre el operador lógico == y la función miembro equals de la clase String.out.println("Distintos objetos"). String str2=new String("El lenguaje Java"). } if(str1. En el siguiente código: public class ClaseString { public static void main(String[] args) { String str1="El lenguaje Java".Manual del Curso Java Básico Programa de Tecnología en Cómputo De modo similar.

nos permite extraer un substring especificando la posición de comienzo y la el final. ya que de otra forma. y mayor que cero si el objeto String es mayor que el String dado.substring(3.compareTo("Tomás"). str1 y str2 ocupan posiciones distintas en memoria pero guardan los mismos datos. int resultado=str. ya que Tomás está después de Alberto en orden alfabético. Cambiemos la segunda sentencia y escribamos: String str1="El lenguaje Java".Manual del Curso Java Básico Programa de Tecnología en Cómputo } } } Esta porción de código devolverá que str1 y str2 son distintos objetos pero con el mismo contenido. System. Una segunda versión del método substring. ya que Alberto está antes que Tomás en orden alfabético. 40 . Para extraer un substring desde una posición determinada hasta el final del String escribimos: String str="El lenguaje Java". La expresión (str1==str2) devolverá true. El método comapareTo devuelve un entero menor que cero si el objeto String es menor (en orden alfabético) que el String dado. String str="El lenguaje Java". Los objetos str1 y str2 guardan la misma referencia al objeto de la clase String creado. La variable entera resultado tomará un valor menor que cero. Así cuando deseamos comparar el contenido de dos String se debe usar el método equals. Se obtendrá el substring "Java". String str2=str1. String str="Tomás". 11). cero si son iguales. Para este propósito hay un método de la clase String denominada substring. La variable entera resultado tomará un valor mayor que cero.substring(12).compareTo("Alberto"). String subStr=str.out. Extraer un substring de un String En muchas ocasiones es necesario extraer una porción o subcadena de un String dado.prinln("Son el mimso objeto "+(str1==str2). con el operador = = compararemos si los Objetos apuntan a la misma dirección de memoria. String str="Alberto". String subStr=str. int resultado=str.

double. Recuérdese. Para eliminar estos espacios tenemos el método trim: String str=" 12 ". La clase String proporciona versiones de valueOf para convertir los datos primitivos: int. String str1=str. 41 . que las posiciones se empiezan a contar desde el indice cero. Convertir un número a String Para convertir un número en String se emplea el método estático valueOf: int valor=10. float.trim(). String str=String.Manual del Curso Java Básico Programa de Tecnología en Cómputo Se obtendrá el substring "lenguaje".valueOf(valor). Cuando introducimos caracteres en un control de edición a veces es inevitable que aparezcan espacios ya sea al comienzo o al final. long.

} public void respirar() { System. String tipoDeComida.out. } public void dormir() { System. String tamaño. 42 .out. } public Animal(String nombre. } public void reproduccion() { System. se pone la palabra reservada extends seguida del nombre de la clase base. Cuando se hace esto. He aquí un ejemplo. automáticamente se tiene todos los atributos y métodos de la clase base. Resulta que siempre se esta haciendo herencia cuando se crea una clase.java public class Animal { String raza. String tipoDePelaje.println("El gato esta maullando"). //Animal.out. Se dice esto en el código dando el nombre de la clase pero antes de abrir el cuerpo de clase.Manual del Curso Java Básico Programa de Tecnología en Cómputo 5: Herencia La herencia es una parte integral de Java.nombre=nombre.raza= nombre. Cuando se hereda. } public void comer() { System.println("El animal duerme").out. pero a menos que se herede explícitamente de otra clase.println("El animal es totalmente Rebelde").println("El animal puede reproducirse").java public class Gato extends Animal { int numVidas=7.out.out. String nombre. se dice: “Esta clase nueva es como esa clase vieja”. } } //Gato.println("Alimentando al animal").println("El animal respira"). se hereda implícitamente de la clase raíz estándar de Java Object. public Animal(){ System. this. public void maullar() { System. int edad. String nombre){ this.

se invoca al constructor por default de la clase animal. para 43 .nombre=nombre. gato1.out. en primera instancia. } public Gato(String nombre. debido a que la clase gato no invoca de manera explicita ningún constructor. como puede verse la clase Gato no incorpora explícitamente los atributos nombre y raza. estos son heredados directamente por la clase Animal.String raza) { this.rasgar(). pero ¿Por qué no crear el objeto Animal llamando otro constructor? Si usamos el segundo constructor de animal podemos inicializar las variables nombre y raza de manera automática. La palabra reservada super Como ya dijimos. el programa anterior crea este objeto por medio del constructor por default. } public static void main(String args[]) { Gato gato1=new Gato("Batman". también los métodos son heredados.out. gato1. al observar la salida del programa anterior nos encontramos en la primera linea: “El animal es totalmente Rebelde”. en este caso antes de haber creado un Gato fue necesario crear primero un objeto de tipo Animal.raza=raza. System. una vez creado un objeto de tipo Gato se creará. gato1. this. Invocar explícitamente a un constructor es posible mediante el uso de la palabra reservada super. } } En la clase Gato muestra el uso de la herencia en este ejemplo.maullar().Manual del Curso Java Básico Programa de Tecnología en Cómputo } public void rasgar() { System.println("\nGato creado"). esto se puede ver en las llamadas a los métodos respirar y dormir."Angora"). gato1. un objeto tipo Animal.println("El gato esta rasgando"). Como dijimos en el capitulo uno. He aquí la salida del programa: El animal es totalmente Rebelde Gato creado El animal respira El gato esta maullando El gato esta rasgando El animal duerme Hace falta aun notar un punto importante en este programa. Esta línea muestra que en la herencia se crean los objetos correspondientes que se encuentran el la cima del árbol jerárquico.respirar().dormir().

} public void comer() { System.println("El animal es totalmente Rebelde").println("\nGato creado"). } public void reproduccion() { System. public void maullar() { System. } public static void main(String args[]) { 44 . String nombre.Manual del Curso Java Básico Programa de Tecnología en Cómputo invocar a un constructor en específico debemos hacer uso de la palabra super. String tamaño. Modificando el programa anterior tenemos: //Animal.out. } public Animal2(String nombre. System.println("El gato esta rasgando").println("El animal duerme").out. } } public class Gato2 extends Animal2 { int numVidas=7.println("En el constructor llamado por super"). int edad.raza= nombre. String raza){ this. System. } public void rasgar() { System.java public class Animal2 { String raza.out.out.String raza) { super(nombre.out.out.println("El animal respira").out.out. String tipoDePelaje.println("Alimentando al animal"). raza). public Animal2(){ System.println("El gato esta maullando"). } public void dormir() { System.nombre=nombre. String tipoDeComida.println("El animal puede reproducirse"). this. } public void respirar() { System. } public Gato2(String nombre.out.

La sobrecarga de métodos es la creación de varios métodos con el mismo nombre pero con diferentes firmas y definiciones. gato1."Angora").rasgar(). de no existir. a continuación se muestra un ejemplo que ilustra la sobrecarga de constructores. La salida del programa se muestra a continuación: En el constructor llamado por super Gato creado El animal respira El gato esta maullando El gato esta rasgando El animal duerme Sobrecarga y sobreescritura de métodos La firma de un método es la combinación del tipo de dato que regresa.maullar(). Cuando se usa super de esta manera debe ser la primera instrucción en aparecen en el constructor. cabe señalar que super buscará un constructor que contenga ese tipo de parámetros.java public class SobreCarga{ public SobreCarga(){ System.out. la compilación no tendrá éxito. Java diferencia los métodos sobrecargados con base en el número y tipo de argumentos que tiene el método y no por el tipo que devuelve.dormir(). También existe la sobrecarga de constructores: Cuando en una clase existen constructores múltiples. se dice que hay sobrecarga de constructores. su nombre y su lista de argumentos. gato1.println("Soy un objeto creado por el constructor sin argumentos"). gato1. } } Hemos agregado la llamada al constructor por medio de super en método constructor de Gato. } public SobreCarga(String cad){ 45 .out.respirar(). gato1.Manual del Curso Java Básico Programa de Tecnología en Cómputo Gato2 gato1=new Gato2("Batman". } public SobreCarga(int num){ System. La sobrecarga de constructores ya la hemos manejado en algunos ejemplos de este manual.println("Soy un objeto creado por el constructor con un argumento int= "+num). Java utiliza el número y tipo de argumentos para seleccionar cuál definición de método ejecutar. //SobreCarga.

String cad){ System. public void maullar() { System."No hay papel").out.out. System. Una subclase hereda todos los métodos de su superclase que son accesibles a dicha subclase a menos que la subclase sobrescriba los métodos. new SobreCarga("Hola enfermera").println("\nGato creado"). raza).println("El gato esta durmiendo. String tipoDeComida.java public class Gato3 extends Animal2 { int numVidas=7. new SobreCarga('Z'.String= "+cad). } public Gato3(String nombre. Una subclase sobrescribe un método de su superclase cuando define un método con las mismas características (nombre. } } Sobrescritura de Métodos.int= "+num+" .println("Soy un objeto creado por el constructor con un argumento String= "+cad). Las subclases emplean la sobre-escritura de métodos la mayoría de las veces para agregar o modificar la funcionalidad del método heredado de la clase padre. } public void rasgar() { System.int num. } public static void main(String args[]) { Gato3 gato1=new Gato3("Batman".out.respirar(). //Gato3."Angora"). regresemos al ejemplo de la clase Animal y Gato. gato1. } public SobreCarga(char c. } public static void main(String[] args){ new SobreCarga(2). Esta vez la Clase Gato sobrescribirá el método dormir de la clase Animal cuyo código no variara con respecto a la última versión. no molestar").println("Soy un objeto creado por el constructor con tres argumentos char= "+c+" .out.println("El gato esta rasgando"). es decir Animal2.out.Manual del Curso Java Básico Programa de Tecnología en Cómputo System.println("El gato esta maullando"). new SobreCarga(). } public void dormir() { System.7. 46 . número y tipo de argumentos) que el método de la superclase. Como ejemplo. new SobreCarga(9).out.String raza) { super(nombre.

System.dormir(). Como sabemos. esta vez agregaremos la siguiente línea: super.maullar().rasgar().dormir(). Al usar super de esta manera. la herencia implica que todos los métodos de la clase padre estarán disponibles en la clase hija. la herencia es importante por la relación que se crea entre la clase padre y la clase hija. } } He aquí la Salida: En el constructor llamado por super Gato creado El animal respira El gato esta maullando El gato esta rasgando El gato esta durmiendo. no molestar"). Sin embargo. } Esta es otra forma de usar super. gato1.println("El gato esta durmiendo. no hay ninguna restricción del lugar donde se haga la llamada al método. gato1. Justo antes de la línea que imprime: “El gato esta durmiendo. Ahora modifiquemos la clase Gato. Es decir: public void dormir() { super. es que podemos heredar métodos a nuestra clase hija. podemos pensar que el aspecto más importante acerca de la herencia. //Instrumento. no molestar”. Veamos un ejemplo. Conversión hacia arriba (upcasting) Hasta ahora. cualquier mensaje que le enviemos a la clase padre podrá ser enviado a la clase hija. en la cual se ejecuta un método de la clase Padre o superclase. y una clase derivada Viento. entonces.dormir(). consideremos como clase base Instrumento que representa instrumentos musicales.java //Herencia y upcasting public class Instrumento{ 47 .Manual del Curso Java Básico Programa de Tecnología en Cómputo gato1. no molestar Observe que la última línea ha cambiado por la sobre-escritura del método dormir.out.

//Upcasting } } Vemos en el ejemplo lo siguiente: el método tune() tiene como argumento un objeto Instrumento. La clase hija podrá tener más métodos que la clase padre. final hace de la referencia una constante.java //Los instrumentos de Viento son instrumentos! //porque tienen la misma interfaz public class Viento extends Instrumento{ public static void main(String[] args){ Viento flauta=new Viento(). Como podemos comprobar. Utilizar constantes declaradas por final puede eliminar parte de la sobrecarga en tiempo de ejecución de un programa. su significado se vuelve algo confuso. Para Datos Una variable o atributo puede ser una constante que deseamos no cambia nunca en nuestro programa. Java no proporciona ninguna manera de convertir un objeto arbitrario en una constante. La palabra clave final La palabra clave final de Java tiene significados ligeramente diferentes dependiendo del contexto. Sin embargo. final convierte el valor en constante. debe contener por lo menos los métodos de la clase padre. en el método Viento. ésta nunca se puede cambiar para que apunte a otro objeto. esto se puede realizar anteponiendo la palabra final a la declaración de una variable. } } //Viento. Vemos que el upcasting tiene sentido ya que partimos de una clase más específica a una más general. pero en general dice: “Esto no puede cambiarse”. los objetos de tipo Viento también son objetos de tipo Instrumento. Sin embargo se puede modificar el objeto en sí. Dado que estas dos razones son bastantes diferentes. 48 . Al usar final con referencias a objetos en vez que con datos primitivos.Manual del Curso Java Básico Programa de Tecnología en Cómputo public void play(){} public static void tune(Instrumento i){ //… i. Una vez que la referencia se inicializa a un objeto. es posible utilizar erróneamente la palabra clave final. sin embargo. pero con una referencia a un objeto.main() el método tune() es llamado con una referencia de tipo Viento.tune(flauta). por lo que se cumple la regla. Instrumento.play(). Con un dato primitivo. Se podría querer evitar cambios por dos razones: diseño o eficiencia.

Manual del Curso Java Básico

Programa de Tecnología en Cómputo

He aquí un ejemplo que muestra el funcionamiento de los campos final:
//Valor.java public class Valor { int i = 1; } //DatosConstantes.java public class DatosConstantes { //Pueden ser constantes en tiempo de compilacion final int variable1 = 9; static final int VAL_DOS=99; //Tipica constante publica public static final int VAL_TRES=39; //No pueden ser constantes en tiempo de compilacion final int variable4= (int)(Math.random()*20); static final int variable5=(int)(Math.random()*20); Valor v1= new Valor(); final Valor v2 = new Valor(); static final Valor v3 = new Valor(); //Arrays: final int[] a= {1,2,3,4,5,6}; public void escribir(String id) { System.out.println(id+" : variable4 ="+variable4+ ", variable5 ="+variable5); } public static void main(String[] args) { DatosConstantes fd1= new DatosConstantes(); //! fd1.variable1++; //Error: No se puede cambiar el valor fd1.v2.i++; //El objeto no es constante fd1.v1= new Valor(); //OK, el Objeto no es final for(int i=0;i< fd1.a.length;i++) fd1.a[i]++; //! fd1.v2 = new Valor(); // No se puede //! fd1.v3 = new valor3(); //Cambiar la referencia //! fd1.a= new int[3]; fd1.escribir("fd1"); System.out.println("Creando un nuevo DatosConstantes"); DatosConstantes fd2= new DatosConstantes(); fd1.escribir("fd1"); fd2.escribir("fd2"); } }

Nota que los datos primitivos static final, se escriben en mayúsculas por convención. Una posible salida del programa se muestra a continuación:
fd1 : variable4 =12, variable5 =14 Creando un nuevo DatosConstantes fd1 : variable4 =12, variable5 =14

49

Manual del Curso Java Básico

Programa de Tecnología en Cómputo

fd2 : variable4 =19, variable5 =14

Fíjese que los valores de variable4 para fd1 y fd2 son únicos, pero el valor variable5 no ha cambiado al crear el segundo objeto DatosConstantes. Esto es porque es estático y se inicializa una vez en el momento de la carga y no cada vez que se crea un nuevo objeto. Las variables v2 y v3 demuestran el significado de una referencia final. Como se puede ver en main( ), justo porque v2 sea final, no significa que no pueda cambiar su valor. Sin embargo, no se puede reubicar v2 a un nuevo objeto, precisamente por que es final. Esto es lo que final significa para un referencia.

Constantes Blancas.
Java permite la creación de constantes blancas, que son campos declarados como final pero a los que no se da un valor de inicialización. En cualquier caso, se debe inicializar una constante blanca antes de utilizarla, y esto lo asegura el propio compilador. Sin embargo, las constantes blancas proporcionan mucha mayor flexibilidad en el uso de la palabra clave final puesto que, por ejemplo, un campo final incluido en una clase puede ahora ser diferente para cada objeto, y sin embargo, sigue reteniendo su cualidad de inmutable. He aquí un ejemplo:
//ConstanteBlanca.java public class ConstanteBlanca { final int i=0; //Constante inializada final int j; // Constante blanca final Elemento p; //Referencia a constante blanca //Las constantes blancas DEBEN inicializarse en el constructor public ConstanteBlanca(){ j=1; //Inicializa la constante blanca p= new Elemento(); } public ConstanteBlanca(int x){ j=x;//Inicializa la constante blanca p=new Elemento(); } public static void main(String args[]) { ConstanteBlanca bf= new ConstanteBlanca(); }

}

50

Manual del Curso Java Básico

Programa de Tecnología en Cómputo

Métodos Constantes
Hay dos razones que justifican los métodos constantes. La primera es poner un “bloqueo” en el método para evitar que cualquier clase heredada varíe su significado. Esto se hace por razones de diseño cuando uno se quiere asegurar de que se mantenga el comportamiento del método durante la herencia, evitando que sea sobrescrito. La segunda razón para los métodos constantes es la eficiencia. Si se puede hacer un método constante se ésta permitiendo al compilador convertir cualquier llamada a ese método en llamadas rápidas. Para que un método sea constante, basta con anteponer la palabra final en su firma, ejemplo:
public final void nombreMetodo() { . . . }

Clases Constantes
Cuando se dice que una clase entera es constante (precediendo su definición de la palabra clave final), se establece que no se desea heredar de esta clase o permitir a nadie más que lo haga. En otras palabras, por alguna razón el diseño de la clase es tal que nunca hay necesidad de hacer cambios, o por razones de seguridad no se desea la generación de subclases. De esta manera alternativa, se pueden estar tratando aspectos de eficiencia, y hay que asegurarse de que cualquier actividad involucrada con objetos de esta clase sea lo más eficiente posible.
//Cerebro.java public class CerebroPequenio { } //Dinosaorio.java public final class Dinosaurio { int i=7; int j=1; CerebroPequenio x= new CerebroPequenio(); public void f() {} } //Jurasico.java public class Jurasico { public static void main(String args[]) { Dinosaurio n= new Dinosaurio();

51

n.i=40.Manual del Curso Java Básico Programa de Tecnología en Cómputo } } n. //public class SerEvolucionado extends Dinosaurio{ //} //Error: no se puede heredar de la clase constante. n.j++. 52 .f().

} } //Musica2.println("Viento. Es una herramienta que provee otra dimensión de interfaz. } //Instrumento2.Manual del Curso Java Básico Programa de Tecnología en Cómputo 6: Polimorfismo El polimorfismo es la tercera característica esencial de un lenguaje orientado a objetos. Veamos un ejemplo para recordar la conversión (Cast) hacia arriba: //Nota.java public class Musica2{ public static void tonada(Instrumento2 i){ i. } } //Viento2. public static final Nota DO_SOSTENIDO=new Nota(1). public class Nota{ private int valor. tonada(flauta).java //Herencia y upcasting.DO_SOSTENIDO). capaz de separar el “qué” del “cómo”. todo en el mismo código para trabajar con todos los distintos tipos de manera similar.play()").java //Los instrumentos de viento son también tipo Instrumento! //porque tienen el mismo comportamiento. El polimorfismo nos permite que distinguir entre los tipos de objetos que son similares.play()").} public static final Nota DO_MAYOR=new Nota(0). public static final Nota SI_BEMOL =new Nota(2).java public class Instrumento2{ public void play(Nota n){ System. En el capítulo pasado aprendimos que con la herencia podemos tratar un objeto como “tipo de” su clase padre.println("Instrumento.out.out. private Nota(int val){ valor=val. Esta habilidad es esencial porque permite que objetos de varios tipos puedan ser tratados como objetos de un solo tipo.play(Nota. //Upcasting } } 53 . } public static void main(String[] args){ Viento2 flauta=new Viento2(). Dicha diferencia se expresa a través del comportamiento de los métodos que se heredan de la clase padre. public class Viento2 extends Instrumento2{ //Redefiniendo un método public void play(Nota n){ System.

} public static void tonada(Cuerda c){ c. en este ejemplo creamos un método para cada tipo de objeto distinto. Por eso es que cualquier objeto Viento es aceptable para dicho método.play(Nota. Esto presenta un punto esencial: si se hiciera esto se necesitará escribir un nuevo método tonada para cada tipo de Instrumento del sistema.DO_SOSTENIDO). Nuestra primera impresión es que dicho código resulta bastante largo debido a que repetimos una y otra vez la misma función.tonada() acepta un objeto Instrumento como referencia. Metal p=new Metal(). renombremos y modifiquemos la clase Musica2 por Musica3 como se muestra a continuación: //Metal. ya que Viento hereda de Instrumento. Supóngase que se sigue este razonamiento y se añaden los instrumentos de Cuerda y Metal. pero también objetos derivado de éste.DO_SOSTENIDO).println("Cuerda. tonada( c ).println("Metal. } } //Cuerda.play(Nota.java public class Cuerda extends Instrumento2{ //Redefiniendo un método public void play(Nota n){ System.play(Nota. } } Como podemos observar.Manual del Curso Java Básico Programa de Tecnología en Cómputo El método Musica. dado que una vez que creemos un nuevo objeto que herede de la clase Instrumento. Agregaremos las siguientes clases a nuestro directorio.java public class Metal extends Instrumento2{ //Redefiniendo un método public void play(Nota n){ System. tendremos que agregar una nueva 54 .out.java public class Musica3{ public static void tonada(Viento2 v){ v. Cuerda c=new Cuerda(). Este programa parecería más directo sí el método tonada tuviera como argumento un objeto de tipo Viento. } } //Musica3.play()").DO_SOSTENIDO). } public static void tonada(Metal m){ m.play()"). } public static void main(String[] args){ Viento2 f=new Viento2(). Además resulta muy estático.out. tonada( p ). tonada(f).

Dicho de otra forma. y desde la perspectiva anterior. ¿ No sería más sencillo escribir un solo método que tome como argumento a la clase base sin especificar el tipo de objeto en particular ?. es el método de Cuadrado el que es llamado gracias al polimorfismo. Ahora veamos el ejemplo en código Java: //Figura.Manual del Curso Java Básico Programa de Tecnología en Cómputo función. Es claro que la salida del programa es Viento. sin embargo. Cuadrado y Triángulo. por lo que en realidad la sentencia es correcta.java. sin embargo. supongamos que llamamos un método de la clase padre: f. lo cual parece incorrecto.out. Java utiliza una alternativa llamada late binding (ligadura tardia). ya que el método tonada() recibe como argumento un objeto Instrumento. Ahora.Dibujar(). que significa que dicha atadura ocurre en tiempo de compilación.println("Dibujando una Figura"). A esta alternativa de binding se le conoce también como dynamic binding (ligadura dinámica). Expliquemos a grandes rasgos de en qué consiste este concepto. Este ejemplo es bastante explícito ya que es bastante lógico decir: “un cuadrado es una figura”. } void borrar() { System. Veamos un ejemplo clásico de la OOP.play(). Regresemos al ejemplo de Musica.println("Borrando una Figura"). } } 55 . Pero. La frase anterior puede ser codificada correctamente de la siguiente manera: Figura f = new Cuadrado().out. Cuando el compilador realiza dicha acción antes de ejecutar un código. Java es capaz de reconocer el tipo de objeto que será utilizado en un método gracias al dynamic binding. En este ejemplo.java //Polimorfismo en Java public class Figura{ void dibujar() { System. un objeto Cuadrado es creado y el resultado es una referencia asignada a Figura. Podría suponerse que el método Dibujar() de Figura es llamado. se le conoce como early binding (ligadura temprana). Consideremos la clase Figura y sus clases hijas Círculo. Ligar la llamada de un método con el cuerpo de un método se llama ligar (bind). “un Cuadrado es una figura”. Todos los métodos en Java utilizan dicha técnica a menos que sean declarados final. ¿ cómo puede saber el compilador que el objeto que recibe es Viento y no de otro tipo? La respuesta es la manera en que trabaja Java: binding (ligadura).

Es decir.out. } } La clase padre establece el comportamiento de las clases que la heredan.java public class Triangulo extends Figura{ void dibujar(){ System.borrar()").out. } } //Triangulo. Cada subclase establece su comportamiento particular para dichos métodos. 56 .length.borrar()").i<s. //llenamos el arreglo de figures! for(int i=0. case 1: return new Cuadrado().println("Circulo.dibujar(). } void borrar(){ System.i++) s[i].println("Cuadrado. //Llamadas polimorficas for(int i=0. todas las subclases pueden borrar y dibujar.dibujar()").i<s.println("Triangulo.println("Circulo. En el ejemplo. } } public static void main(String[] args){ Figura[] s=new Figura[9].out.dibujar()"). } void borrar(){ System. case 2: return new Triangulo().length.java public class Cuadrado extends Figura{ void dibujar(){ System.out.random()*3)){ default: case 0: return new Circulo().println("Triangulo.println("Cuadrado.out.java public class Circulo extends Figura{ void dibujar(){ System.dibujar()").out. } void borrar(){ System.borrar()"). se crean objetos de manera aleatoria y se almacenan en un arreglo de objetos Figura.i++) s[i]=figuraAleatoria(). } } public class Figuras{ public static Figura figuraAleatoria(){ switch((int)(Math. } } //Cuadrado.Manual del Curso Java Básico Programa de Tecnología en Cómputo //Circulo.

Sólo serán abstractos alguno de sus métodos. public String quienSoy(){ return "Instrumento". su única intención era la de crear una interfaz común para todas las clases que se deriven de Instrumento.out. seguir siendo abstracta. Instrumento simplemente tiene que expresar la interfaz. los métodos declarados eran “falsos”. } //Viento4.java public class Viento4 extends Instrumento4{ public void play(){ System. Con un solo método abstracto. La clase instrumento puede convertirse fácilmente en una clase abstracta. de forma que no tiene sentido crear objetos de tipo Instrumento. y no una implementación particular. } public abstract void adjust(). //Instrumento4. se califica de abstracto. Es decir. Java proporciona un mecanismo para hacer esto.java //Clases abstractas y métodos. Si una clase hereda de una clase abstracta. public abstract void play(). abstract class Instrumento4{ int i.println("Viento. Se trata de un método incompleto. Otra manera es llamar a la clase Instrumento. Se crea una clase abstracta cuando se desea manipular un conjunto de clases a través de una interfaz común. tiene sólo declaración faltándole los métodos. ésta debe implementar todos los métodos abstractos o bien. Una clase abstracta puede tener métodos no-abstractos y abstractos. la clase debe ser declarada como abstracta. } public String quienSoy(){ 57 . los objetos de esa clase casi nunca tienen significado.play()"). La sintaxis para una declaración de método abstracto es: abstract void f ( ). Si se tiene una clase abstracta como instrumento. denominado método abstracto. Toda clase que contenga uno o más métodos abstractos.Manual del Curso Java Básico Programa de Tecnología en Cómputo Clases y métodos abstractos En lo ejemplos de la clase Instrumento. una clase abstracta. Con las clases abstractas tenemos las siguientes características: • • • • No se puede crear un objeto de una clase abstracta.

play()").adjust()"). } public static void main(String[] args){ 58 . } public void adjust(){} } //Percusion.println("Saxofon.java public class Flauta4 extends Viento4{ public void play(){ System.println("Percusion. } public String quienSoy(){ return "Cuerda".out.java public class Percusion4 extends Instrumento4{ public void play(){ System. } public String quienSoy(){ return "Saxofon". } public void adjust(){}//Se implementa el body } //Cuerda. } public String quienSoy(){ return "Percusion".play()").length.Manual del Curso Java Básico Programa de Tecnología en Cómputo return "Viento".i++) tune(e[i]).play(). } public String quienSoy(){ return "Flauta".println("Cuerda.java public class Cuerda4 extends Instrumento4{ public void play(){ System.println("Flauta. } static void tuneAll(Instrumento4[] e){ for(int i=0.println("Flauta.java public class Musica4{ static void tune(Instrumento4 i){ i.out.play()").out. } public void adjust(){ System.i<e.out. } public void adjust(){} } //Flauta.play()"). } } //Musica4.} } //Saxofon.java public class Saxofon4 extends Viento4{ public void play(){ System.out.

orquesta[0]=new Viento4(). orquesta[2]=new Cuerda4().java //Interfaces interface Instrumento5{ int i=5. Por consiguiente. se usa la palabra clave interface en vez de la palabra clave class. tuneAll(orquesta).play()"). pero ahora voy a decir cómo funciona”.java public class Viento5 implements Instrumento5{ public void play(){ System. void adjust(). Una interfaz dice: “Ésta es la apariencia que tendrán todas las clases que implementen esta interfaz”. orquesta[3]=new Flauta4(). Por lo demás. se usa la palabra clave implements. } public String quienSoy() {return "Viento".out. pero no cuerpos de método. orquesta[4]=new Saxofon4(). orquesta[1]=new Percusion4(). } } Interfaces y clases internas Interfaces. //Los métodos no deben estar definidos. cualquier código que use una interfaz particular sabe qué métodos deberían ser invocados por esa interfaz. } //Viento5. La palabra clave interfaz lleva el concepto de abstracción un paso más allá. Para hacer una clase que se ajuste a una interfaz particular (o a un grupo de interfaces). El ejemplo de los instrumentos utilizando interfaces se muestra a continuación. void play(). Se podría pensar que es una clase abstracta pura permite al creador establecer la forma de una clase: nombres de métodos. listas de parámetros y tipos de retorno. es como la herencia. String quienSoy(). //Insterface. y eso es todo.println("Viento. Se esta diciendo “La interfaz contiene la apariencia.} public void adjust(){} } public class Cuerda5 implements Instrumento5{ public void play(){ 59 .Manual del Curso Java Básico Programa de Tecnología en Cómputo Instrumento4[] orquesta=new Instrumento4[5]. Para crear una interfaz.

play()").Manual del Curso Java Básico Programa de Tecnología en Cómputo System.} public void adjust(){} } //Percusion5. tuneAll(orquesta).println("Viento.out.java public class Saxofon5 extends Viento5{ public void play(){ System.play(). } public String quienSoy(){ return "Saxofon".play()").play()").out. } } 60 .java public class Flauta5 extends Viento5{ public void play(){ System.} public void adjust(){} } //Flauta. orquesta[i++]=new Flauta5(). } public static void main(String[] args){ Instrumento5[] orquesta=new Instrumento5[5].play()"). } public String quienSoy(){return "Percusion".println("Percusion. } public String quienSoy(){return "Viento".out.i++) tune(e[i]).} } //Saxofon.length.adjust()"). orquesta[i++]=new Saxofon5(). } public void adjust(){ System. } static void tuneAll(Instrumento5[] e){ for(int i=0.java public class Musica5{ static void tune(Instrumento5 i){ i.println("Flauta. orquesta[i++]=new Cuerda5().java public class Percusion5 implements Instrumento5{ public void play(){ System.println("Flauta.out. orquesta[i++]=new Percusion5(). orquesta[i++]=new Viento5().println("Saxofon.i<e. } public String quienSoy(){ return "Flauta". int i=0. } } //Musica5.out.

u(barney). } //Vampiro. Este tipo de clases son una 61 . Podemos fácilmente añadir un nuevo método a una interfaz usando herencia. v(barney).java //Extendiendo una interfaz con herencia public interface Monstruo{ void amenaza(). } public static void main(String[] args){ Dragon barney=new Dragon().destruye().Manual del Curso Java Básico Programa de Tecnología en Cómputo Extender una interfaz con herencia.amenaza().Letal{ void ChupaSangre(). d.} static void v(MonstruoPeligroso d){ d. } //Dragon.java public interface MonstruoPeligroso extends Monstruo{ void destruye(). } //Letal.java interface Vampiro extends MonstruoPeligroso. y también podemos combinar muchas interfaces con una nueva interfaz con ayuda de la herencia: //Monstruo.amenaza().java public interface Letal{ void mata().java public class Dragon implements MonstruoPeligroso{ public void amenaza(){} public void destruye(){} } //ShowDeHorror. A la primera se le denomina clase interna.java public class ShowDeHorror { static void u(Monstruo b){ b. } } Clases Internas: Es posible colocar una definición de clase dentro de otra definición de clase. } //MosntruoPeligroso.

Aquí. } } Las clases internas. System. la clase externa tendrá un método que devuelva una referencia a una clase interna. pues permite agrupar clases que lógicamente están relacionadas una de otra. } public Contenidos cont() 62 . cuando se usan dentro de enviar tiene la misma apariencia que muchas otras clases.enviar("Tanzania"). } String leerEtiqueta(){ return etiqueta. Destino(String adonde){ etiqueta=adonde.Manual del Curso Java Básico Programa de Tecnología en Cómputo característica importante. public int valor(){ return i. Destino(String aDonde){ etiqueta=aDonde.} } class Destino{ private String etiqueta. Destino d=new Destino(dest). } public static void main(String[] args){ Paquete1 p=new Paquete1 (). public int valor(){ return i. Se crea una clase interna como uno esperaría. Generalmente.leerEtiqueta()).println(d.out. //Paquete1.} } class Destino{ private String etiqueta. } String leerEtiqueta(){ return etiqueta. ubicando su definición dentro del envolvente. Este tipo de clases son una característica valiosa. la única diferencia práctica es que los nombres se anidan dentro de Paquete1.} } public Destino para(String s) { return new Destino(s).java //Creando clases internas public class Paquete2{ class Contenidos{ private int i=11.} } public void enviar(String dest){ Contenidos c=new Contenidos(). como esta: //Paquete2. p.java //Creando clases internas public class Paquete1{ class Contenidos{ private int i=11.

cont().leerEtiqueta()). } public static void main(String[] args){ Paquete2 p=new Paquete2 (). System.Manual del Curso Java Básico Programa de Tecnología en Cómputo { return new Contenidos(). } } 63 .out. Paquete2 q=new Paquete2(). Destino d=para(dest). //Definir referencias a clases internas Paquete2.println(d.Contenidos c= q. Paquete2. p.enviar("Tanzania").Destino d= q. } public void enviar(String dest){ Contenidos c= cont().para("Borneo").

Ejemplo import miPaquete.. La forma general de la declaración package es la siguiente: package nombrePaquete. las clases se agrupan en paquetes.nombre2. cuando se requiera hacer uso de estas clases se tendrán que importar de la siguiente manera. } 64 .MiClase.miPaquete.. Donde nombrePaquete puede constar de una sola palabra o de una lista de nombres de paquetes separados por puntos.. class TuClase { . import nombre1.nombre2. class MiClase { .Manual del Curso Java Básico Programa de Tecnología en Cómputo 7:Paquetes. De esta manera. } Ejemplo package nombre1. } Los nombres de los paquetes se corresponden con nombre de directorios en el sistema de archivos. class OtraClase { /* Aqui se hace uso de la clase 'Miclase' y de la clase 'TuClase' */ . • Paquete Un paquete es un conjunto de clases e interfaces relacionadas. Para hacer que una clase sea más fácil de localizar y utilizar así como evitar conflictos de nombres y controlar el acceso a los miembros de una clase.TuClase..miPaquete. Ejemplo package miPaquete...

sin modificador (también conocido como package) y privado (private). Ejemplo: package paquete1. En orden. el cual es un paquete que no tiene nombre. } } Para compilar este clase ejecutar la siguiente sentencia: javac –d . ClaseEnPaquete. public void algunMetodo() { System.) a indica que se crearan los directorios a partir del directorio actual.algunMetodo(). son los que permiten controlar la visibilidad y acceso a los métodos y variables que están dentro de una clase. es que pueden proteger a sus variables y métodos (tanto de instancia como de clase) del acceso desde otras clases. Para ejecutar esta clase podemos escribir: java paquete1. Uno de los beneficios de las clases. protegido (protected).ClaseEnPaquete Modificadores de Acceso Los modificadores más importantes desde el punto de vista del diseño de clases y objetos.println("Prueba de paquete"). Ejemplo import miPaquete. } public static void main(String args[]) { ClaseEnPaquete a=new ClaseEnPaquete().Manual del Curso Java Básico Programa de Tecnología en Cómputo Para importar todas las clases que están en un paquete. a. public class ClaseEnPaquete { int prueba.*. ésta terminará en el package por default.out. La siguiente tabla muestra el nivel de acceso permitido por cada modificador: public protected (sin modificador) private 65 .java Donde el punto (. Java soporta cuatro niveles de acceso a variables y métodos. se utiliza el asterisco ( * ). Si no se utiliza la sentencia package para indicar a que paquete pertenece una clase. del más público al menos público son: público (public).

Los miembros de instancia no son visibles.Manual del Curso Java Básico Programa de Tecnología en Cómputo Clase SI SI SI SI SI/NO (*) SI SI SI NO SI NO NO NO Subclase en SI el mismo paquete No-Subclase en SI el mismo paquete Subclase en SI diferente paquete No-Subclase en diferente paquete SI (Universo) NO NO NO (*) Los miembros (variables y metodos) de clase (static) si son visibles. public void metodoPublic() { System. una clase se ve a ella misma todo tipo de variables y métodos (desde los public hasta los private).println("En el metodo } public").java package paq01. Ejemplo: //ClaseInicial. las demas clases del mismo paquete (ya sean subclases o no) tienen acceso a los miembros desde los public hasta los sinmodificador. éstos últimos siempre que sean static ya de no ser así no serán visibles en la subclase (Esto se explica en la siguiente página). int c = 3.out. El resto del universo de clases (que no sean ni del mismo paquete ni subclases) pueden ver sólo los miembros public.out. Como se observa de la tabla anterior.println("En el metodo } private void metodoPrivate() { System. protected int b = 2.out.out.println("En el metodo } void metodo() { System. sin modificador").println("En el metodo } protected void metodoProtected() { System. private"). protected"). 66 . Las subclases de otros paquetes pueden ver los miembros public y a los miembros protected. public class ClaseInicial { public int a = 1. //es amigable private int d = 4.

metodo(). obj.c). obj.c).println("c = " + obj. import paq01.b). System.out.println("c = " + obj. obj.a).out.metodoPublic().out.out. /* System.out.java package paq02. System.out.out.println("b = " + obj.d).metodoPrivate().println("d = " + obj.java package paq01.metodoPrivate(). obj. } } // ClaseNoHijaEnDiferentePaquete.ClaseInicial. //obj.java package paq02.out.out.*.b). obj.metodoProtected(). */ } } // ClaseHijaEnMismoPaquete. System. obj.metodo(). obj.println("d = " + obj.b). public class ClaseHijaEnDiferentePaquete extends ClaseInicial { public static void main(String arg[]) { ClaseInicial obj = new ClaseInicial(). //System. public class ClaseHijaEnMismoPaquete extends ClaseInicial { public static void main(String arg[]) { ClaseInicial obj = new ClaseInicial().out. System.println("b = " + obj.a).println("a = " + obj. System.println("b = " + obj. System.out.println("c = " + obj.println("a = " + obj. obj.metodoProtected(). public class ClaseNoHijaEnDiferentePaquete { public static void main(String arg[]) 67 .d).metodoProtected(). System. System.out.c). obj.metodoPublic().metodoPublic().println("a = " + obj. } // ClaseHijaEnDiferentePaquete.metodoPrivate().d).a).println("d = " + obj.Manual del Curso Java Básico Programa de Tecnología en Cómputo } public static void main(String arg[]) { ClaseInicial obj = new ClaseInicial(). System. obj. import paq01.metodo(). obj. System.

//obj.metodoPrivate().println("a = " + obj.c).metodoProtected().println("b = " + obj.b).metodo().b).println("d = " + obj. /* System. */ } } // ClaseNoHijaEnMismoPaquete. compilar y ejecutar cada clase por separado. public class ClaseNoHijaEnMismoPaquete { public static void main(String arg[]) { ClaseInicial obj = new ClaseInicial().c).out.out. obj.println("b = " + obj.println("c = " + obj. } } Para ejecutar el ejemplo. obj.println("a = " + obj. obj.Manual del Curso Java Básico Programa de Tecnología en Cómputo { ClaseInicial obj = new ClaseInicial().metodo(). 68 .d). //System.metodoPrivate().println("c = " + obj.out.a). obj.metodoProtected().println("d = " + obj.out.d). obj.out. System.metodoPublic(). obj.java package paq01. obj.out. System. System. System.a). System. System.out.metodoPublic().out.

Scott McNealy. que fuera universal. Con el paso del tiempo el Hot Java se convirtió en un concepto práctico dentro del leguaje Java y demostró que podría proporcionar una forma segura multiplataforma para que el código pueda ser bajado y corrido del Host del World Wide Web y que de otra forma no son seguros.Manual del Curso Java Básico Programa de Tecnología en Cómputo Apéndice A: Breve historia de Java Para apreciar el significado e importancia de Java. es muy importante conocer su lugar de origen y cuales fueron sus propósitos: En Diciembre de 1990. sin embargo el equipo concluyó que el mercado para consumidores electrónicos smart y las cajas Set-Up en particular. y con la ayuda de los otros miembros del equipo desarrollaron un decodificador que mas tarde se convertiría en lenguaje Java. reclutó a sus colegas James Gosling y Mike Sheridan para trabajar sobre un nuevo tema conocido como "El proyecto verde". Este a su vez estaba auspiciado por la compañía "Sun founder Hill Joy" y tenía como objetivo principal crear un lenguaje de programación accesible. no eran del todo eficaces. que son las partes del código Java que pueden ser cargadas mediante una red de trabajo para después ejecutarlo localmente y así lograr o alcanzar soluciones dinámicas en computación acordes al rápido crecimiento del ambiente Web. el equipo de Naughton se lanzó en busca de nuevas oportunidades en el mercado. Patrick Naughton. mismas que se fueron dando mediante el sistema operativo base. el equipo decidió introducir sistemas de software con aplicaciones para consumidores smart como plataforma de lanzamiento para su proyecto. y que estuviera basado en un ambiente C++ ya que había mucha frustración por la complejidad y las limitaciones de los lenguajes de programación existentes. el equipo ya había desarrollado un sistema prototipo conocido como "*7". Patrick Naugthon procedió a la construcción del lenguaje de programación Java que se accionaba con un browser prototipo. La subsidiaria Proyecto Verde fue amortizada por la compañía Sun a mediados del 94’. se dio cuenta en forma muy oportuna y estableció el Proyecto Verde como una subsidiaria de Sun. más tarde se le fueron incorporando algunas mejoras y el browser Hot Java fue dado a conocer al mundo en 1995. James Gosling escribió el compilador original y lo denominó "Oak". el cese del Proyecto Verde coincidió con el nacimiento del fenómeno mundial Web. que era una especie de cruce entre un asistente digital personalizado y un mecanismo inteligente de control remoto. En abril de 1991. lo realizado por el ex equipo verde se adecuaba a este nuevo ambiente ya que cumplía con los mismos requerimientos de las settop box OS que estaban diseñadas con un código de plataforma independiente pero sin dejar de ser pequeñas y confiables. De 1993 a 1994. un empleado de la empresa Sun. Por su parte el presidente de la compañía Sun. La incipiente subsidiaria fracasó en sus intentos de ganar una oferta con Time-Warner. fácil de aprender y de usar. 69 . Una de las características más atractivas del Hot Java fue su soporte para los "applets". Para 1992. Al examinar las dinámicas de Internet. Afortunadamente.

Java Soft otorgó permisos a otras compañías para que pudieran tener acceso al código fuente de Java y al mismo tiempo mejorar sus navegadores. Microsoft. y que a su vez forzó a otros vendedores para apoyar el soporte de applets en Java. Muy pronto las licencias o permisos contemplaban a prestigiadas firmas como IBM. Oracle. una rudimentaria colección de componentes básicos para ayudar a los usuarios de software a construir aplicaciones de Java. Java se ha ganado una impresionante cantidad de apoyo. Los Colegios y Universidades alrededor del mundo están adoptando Java como un lenguaje universal y de enseñanza indispensable. 70 . dicha licencia también les permitía crear herramientas de desarrollo para programación Java y los facultaba para acondicionar Máquinas Virtuales Java (JVM). a varios sistemas operativos. Asimismo el Netscape Comunications Inc. Este fue el factor clave que lanzó a Java a ser reconocido y famoso. No pasó mucho tiempo antes de que Netscape Communications decidiera apoyar a los Java applets en Netscape Navigator 2. Los nuevos proyectos de Java son co-patrocinados por cientos de millones de dólares en capital disponible de recursos tales como la Fundación Java. IBM. animación y trabajo en red. sistemas de plataforma y servicios para aumentar las capacidades del lenguaje. Dicha colección incluía el compilador Java. en algunos casos como "Marimba´s Castanet" se han concebido desde un principio con bases de tecnología Java para Internet y han sido autorizados bajo licencia de Netscape para poner al corriente "netcast". de esta forma de se dio continuidad al fortalecimiento del programa del lenguaje Java y así trabajar con terceras partes para crear aplicaciones. Java Soft dio a conocer el Java Developmet Kit (JDK) 1. sonido. Toshiba y por supuesto Novell. Durante ese mismo mes. incluyendo Cisco Systems. hoy en día existen más de 150 libros en Java que se están imprimiendo en este momento. necesaria para correr programas basados en Java. Desde su aparición.Manual del Curso Java Básico Programa de Tecnología en Cómputo Para dedicarse al desarrollo de productos basados en la tecnología Java. un producto informativo para PC’s de escritorio. un visualizador de applets. Symantec. un debugger prototipo y una máquina virtual Java(JVM). también incluía paquetería básica de gráficos. Como parte de su estrategia de crecimiento mundial y para favorecer la promoción de su nueva tecnología. herramientas. Netscape y Oracle. Sun formó la empresa Java Soft en enero de 1996.0.0. Un gran número de nuevas empresas ya están preparadas para recibir a la Ola Java o para ingresar a los Mercados de software basados en Java. Silicon Graphics. Virtualmente cada vendedor importante de software ha obtenido autorización de Java y ahora ha sido incorporado en los principales sistemas operativos base de PC’s de escritorio hasta estaciones de trabajo UNIX. un fondo común de capital formado el verano pasado por 11 compañías. mostró las ventajas de Java y rápidamente se asoció con Java Soft para explotar su nueva tecno logía.

Manual del Curso Java Básico Programa de Tecnología en Cómputo En un reciente estudio se encontró que el 60% de los empresarios están usando Java y el 40% expresaron que Java representa la solución estratégica que estaban buscando para sus negocios. asistentes.000 usuarios. se ha estimado que actualmente las compañías de hoy que cuentan con más de 5000 empleados. Java también está ganando aceptación en el área empresarial. un año después. en la segunda conferencia Java One albergó a 10. el primer Java One fue celebrado en abril de 1996 y atrajo a 5000 usuarios. 71 . Para darse una idea de la rápida aceptación que tiene Java en el mundo. Java Soft estima que el número actual de usuarios Java llega a 400 mil y sigue creciendo.. tenemos el ejemplo de las conferencias "Java Soft Java One" en San Francisco. una tercera parte están usando Java.

Sign up to vote on this title
UsefulNot useful