P. 1
javaBasico

javaBasico

|Views: 5.934|Likes:
Publicado porRolando Arqque

More info:

Published by: Rolando Arqque on Apr 06, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

04/17/2013

pdf

text

original

Sections

  • 1:Programación Orientada a Objetos
  • Introducción:
  • La Crisis del Software
  • La metodología orientada a objetos
  • Clases y objetos
  • Mensajes y métodos
  • Encapsulamiento
  • Herencia
  • Polimorfismo
  • Abstracción
  • 2:La Tecnología Java
  • La Plataforma Java
  • Tipos de programas en java
  • Compilación y Ejecución de Programas
  • Tipos de datos primitivos
  • El recolector de basura
  • 3: Clases y objetos
  • Atributos y métodos
  • Constructores, la palabra reservada this
  • Variables y métodos de clase
  • Clases envolventes o wrappers
  • Arreglos
  • Arrays de dos dimensiones
  • Java archivos (JAR)
  • Limpieza: Finalización y recolección de basura
  • La condición de Muerto
  • Comentarios y documentación
  • Sintaxis
  • HTML empotrado
  • 4:La Clase String
  • Comparación de Strings
  • 5: Herencia
  • La palabra reservada super
  • Sobrecarga y sobreescritura de métodos
  • Sobrescritura de Métodos
  • Conversión hacia arriba (upcasting)
  • La palabra clave final
  • Para Datos
  • Constantes Blancas
  • Métodos Constantes
  • Clases Constantes
  • 6: Polimorfismo
  • Clases y métodos abstractos
  • Interfaces y clases internas
  • Extender una interfaz con herencia
  • Clases Internas:
  • 7:Paquetes
  • Apéndice A: Breve historia de Java

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

entre los que destacan los métodos Booch. Por esta razón y en base a nuestra experiencia de la vida diaria podemos identificar grupos o clases de objetos. etc. el análisis de requisitos. que es una combinacion de variables locales y procedimientos llamados metodos que juntos conforman una entidad de programación. que es la relación entre la asignación de software al nivel del sistema y el diseño del software. se creó el Lenguaje Unificado de Modelado (UML). una silla. una caja. La metodología orientada a objetos presenta características que lo hacen idóneo para el análisis. 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. se quedó atrás por lo que empezaron a surgir diferentes métodos de análisis y diseño orientado a objetos. La programación orientada a objetos. 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. un automóvil. Para poner fin a la "guerra de métodos" que se presentó en ese momento. Los lenguajes orientados a objetos se clasifican como lenguajes de quinta generacion. 4 . diseño y programación de sistemas. Un objeto en el mundo real viene a representar cualquier cosa: un plumón. intenta simular el mundo real a traves del significado de objetos que contiene caracteristicas y funciones. sin embargo. Clases y objetos En la metodología orientada a objetos la esencia es el objeto. OOSE (Object Oriented Software Engineering) y OMT (Object Modeling Technique). 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. Como su mismo nombre indica. la programación orientada a objetos se basa en la idea de un objeto. la metodología orientada a objetos comenzaba a madurar como un enfoque de desarrollo de software.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.

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. Figura 1. Cuando un objeto necesita interactuar con otro lo hace a través de un método. Un método se implementa dentro la clase que defina al objeto. 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. Hay diferentes tipos de herencia: los más importantes son simples y múltiples. 5 . Figura 1.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.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. a su vez los métodos también pueden ser restringidos de cierta forma. Encapsulamiento. La Herencia simple consiste en que una clase sólo puede heredar de otra clase llamada clase padre o superclase. Un buen diseño de clases hace que los atributos solo sean modificados mediante el acceso a un método. en la herencia múltiple una clase puede heredar de una o mas clases. 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. De esta manera si queremos acceder a un atributo lo tenemos que hacer a través de alguno de sus métodos. Herencia La herencia es propiedad que permite a los objetos construirse a partir de otros objetos.

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

a esa clase de objeto la podemos definir como aquello que se desea abstraer. conforme descendemos en el árbol las clases se convierten en algo mas concreto. Para que esta referencia sea polimorfica debe haber necesariamente una relación de herencia entre las clases.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. 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. 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. Una referencia a objeto de la clase Consultor también puede ser una referencia a objeto de la clase Trabajador. por ejemplo nuestro diagrama de clases de la figura 1. hablar de un trabajador resulta mas abstracto que hablar de un empleado o bien un consultor. es decir. de esta forma el diseño de clases lo podemos considerar como una abstracción de datos.4 presenta una abstracción de datos en la parte superior y esta abstracción desminuye conforme se desciende del árbol. Abstracción Como mencionamos anteriormente en la POO para poder utilizar o crear un objeto es necesaria la clase del objeto. 7 . Por ejemplo.

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. Una plataforma es el ambiente de hardware o software en el cual se ejecutan los programas. la mayoría de las plataformas pueden ser descritas como una combinación de hardware y sistema operativo. Solaris.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. Java tiene la característica de ser al mismo tiempo compilado e interpretado. Algunas de las plataformas más populares son Windows. 8 . 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. 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. . Linux y MacOS. En general. El lenguaje de programación Java consiste en un lenguaje de programación y una plataforma.1 La Plataforma Java. Figura 2.

sun. 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. JNDI: Java Naming and Directory Interface. • • • • • J2SE: Java Standard Edition. Existen numerosos API’s. etc. Para obtener el J2SE que utilizaremos a lo largo del curso basta con entrar a la pagina de java: http://java. PALM. 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. 9 . 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. 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.com y descargarlo.2 La figura anterior muestra un aspecto importante: 1.Como puede verse la máquina virtual esta por encima de la plataforma del Hardware. a continuación se muestran varios API (todos ellos bajo la tecnología Java) y una breve descripción de cada uno. J2ME: Java Micro Edition. Se utiliza en la elaboración de programas standalone comúnmente utilizados para ser ejecutados de manera local en una PC. 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. Son programas para ser ejecutados en una arquitectura cliente – servidor. La elección del API a utilizar depende del tipo de programa que queremos realizar.. 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. J2EE: Java Enterprise Edition.Manual del Curso Java Básico Programa de Tecnología en Cómputo Figura 2. PDA’s.

necesitan de un Navegador Web compatible con Java para poder ejecutarse.3 Nuestro primer programa consiste en el tradicional hola mundo. 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.3 muestra un esquema del proceso de construcción de una aplicación. • • Compilación y Ejecución de Programas La figura 2. 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. Figura 2. escribirlo en un editor de texto plano como puede ser el block de notas de windows o bien el editor vi de unix. Los servlets son una alternativa de la programación CGI tradicional. Aplicaciones: Las aplicaciones son programas standalone de propósito general que normalmente se ejecutan desde la línea de comandos del sistema operativo.Manual del Curso Java Básico Programa de Tecnología en Cómputo Tipos de programas en java. A menudo los applets se descargan junto con una página HTML desde un Servidor Web y se ejecutan en la máquina cliente. Con Java se puede realizar cualquier programa que normalmente se crearía con algún otro lenguaje de programación. 10 . para entender su funcionamiento pasaremos a ejecutar un ejemplo directamente.

en este caso el nombre del archivo corresponde a HolaMundo. ejemplos: o miVariable o nombreDeVariable. 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 es un lenguaje sensitivo lo cual quiere decir que hace una distinción entre mayúsculas y minúsculas. println(): método del atributo out.Manual del Curso Java Básico Programa de Tecnología en Cómputo public class HolaMundo { public static void main(String arg[]) { System. Hasta este momento tenemos listo el código fuente de nuestro programa en un archivo llamado HolaMundo. System: clase out: atributo de la clase System. Java sigue ciertas convenciones en la asignación de nombres a clases.java. } } Para ejecutar nuestro programa tenemos que seguir algunas reglas: El nombre del archivo debe tener el nombre de la clase publica. la diferencia es que los métodos van seguidos por paréntesis. 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. Para nombrar métodos se usa la misma convención que para nombrar variables. además la extensión siempre debe ser *. 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.java.out.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. métodos y variables. podemos identificar clases.println("Mi primer programa en java"). ejecutar y escribir cmd en sistemas Windows 2000 y XP) e invocar al compilador de la siguiente manera: 11 .

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

Sin embargo puede existir la necesidad de realizar alguna acción cuando un objeto es destruido.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. Java tiene un recolector de basura para recuperar la memoria de los objetos que ya no se usan. El recolector de basura se ejecuta en un proceso en segundo plano cada determinado tiempo. verifica que objetos han dejado de usarse y libera esa porción de memoria al sistema operativo para su nueva reasignación. Java soluciona este problema por medio del método finalize() que será visto en el siguiente capitulo. 13 . Precisión doble: bit de signo +11 bits de exponente + 52 bits de mantisa. esta envoltura será vista a detalle en el capitulo 3: clases envolventes. es decir de los cuales se ha perdido su referencia. pero a menudo se les olvida la importancia de la limpieza. El recolector de basura Los programadores conocen la importancia de la inicialización. Todos los tipos primitivos tienen asociada una envoltura o wrapper que se muestra en la última columna de la tabla anterior. por ejemplo hacer uso de un destructor similar al de C++.

System. System.println("Carrea: "+alumno1.apellidoMaterno). int edad.carrera="Computacion". Ahora codificando esa clase. Para poder crear un objeto es necesario que exista previamente la clase de ese objeto.carrera).edad). alumno1. System.out. } } 14 . La definición de una clase especifica cómo serán los objetos de dicha clase. String apellidoPaterno.nombre="Juan".apellidoMaterno="Lopéz".numeroDeCuenta). de que variables y de que métodos constarán. alumno1. // creamos un nuevo objeto de tipo alumno.semestre).out. 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.out.println("Semestre: "+alumno1. alumno1. crearemos una clase llamada Alumno de esa clase vamos a crear un objeto. tenemos el siguiente código: public class Alumno { //Atributos de la clase String nombre.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. alumno1.nombre+" "+alumno1. int semestre. public static void main(String args[]) { Alumno alumno1=new Alumno().apellidoPaterno+" "+alumno1. alumno1. String carrera. String apellidoMaterno. esto es.edad=20.numeroDeCuenta="03021458".println("Edad: "+alumno1. System.println("Nombre: "+alumno1. alumno1. alumno1.out.apellidoPaterno="Hernandez". System.semestre=4. String numeroDeCuenta.out.println("Numero de cuenta: "+alumno1.

). este contiene una copia de todos los atributos declarados en la clase siempre y cuando no estén declarados como static.edad=18. String apellidoMaterno. alumno1. este nuevo alumno tendrá como referencia: alumno2.apellidoPaterno="Hernandez". Esta sentencia crea un nuevo objeto. String apellidoPaterno.// creamos otro nuevo objeto alumno1.semestre=4. alumno1. y lo asigna a la referencia alumno1. alumno2. alumno1.// creamos un nuevo objeto de tipo alumno Alumno alumno2= new Alumno(). int edad. alumno1.carrera="Ing. alumno2. alumno2. alumno2.numeroDeCuenta="040012548". System. alumno2. alumno2. alumno2. En el ejemplo también es interesante resaltar el uso de operador + para concatenar cadenas. 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. con la palabra reservada new.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(). alumno1.//inicializamos sus atributos.nombre="Pedro".println("Datos del alumno1:"). String numeroDeCuenta.out.//inicializamos sus atributos. int semestre. En el método main de la clase creamos un nuevo objeto de tipo Alumno en la sentencia: Alumno alumno1=new Alumno(). System. Electrica".edad=20.numeroDeCuenta="03021458".apellidoMaterno="Lopéz".apellidoMaterno="Rodriguez".println("Numero de cuenta: "+alumno1.out.apellidoPaterno="Rodriguez". String carrera.carrera="Computacion". Una vez creado el objeto. public class Alumno { // atributos de la clase String nombre.semestre=1.nombre="Juan". alumno1.numeroDeCuenta). Cuando ya esta creado el objeto podemos acceder a un atributo mediante el operador punto (. 15 .

de esta forma podemos darnos cuenta de que cada objeto.println("Carrea: "+alumno1. Como ya se dijo en el capitulo 1.Manual del Curso Java Básico Programa de Tecnología en Cómputo System.out.println("Edad: "+alumno2. System. en este caso la acción ha realizar será imprimir el valor de sus 16 .carrera).edad).apellidoPaterno+" "+alumno2.carrera).apellidoMaterno).out.out.out. 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. entonces ¿Podemos unir esas líneas en una sola que permitan imprimir los datos de cualquier objeto tipo Alumno creado?. System. tanto alumno1 como alumno2.semestre).out. 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. Si observamos las líneas de código en donde se imprimen los datos de cada alumno encontraremos que son prácticamente las mismas.nombre+" "+alumno2.out. La respuesta es sí y esto se hará a través de un método.apellidoPaterno+" "+alumno1.println("\nDatos del alumno2:"). System. System.println("Numero de cuenta: "+alumno2.numeroDeCuenta).out. Electrica Semestre: 1 Atributos y métodos En la versión 2 de nuestra clase Alumno hemos creado 2 objetos de esta clase.println("Edad: "+alumno1.nombre+" "+alumno1.out. System. System.out.println("Semestre: "+alumno2.edad).apellidoMaterno).println("Nombre: "+alumno1.println("Carrea: "+alumno2. System. contiene una copia de los atributos de la clase los cuales almacenan valores de forma independiente.out. System. un método es una acción que puede ejecutar un objeto.println("Semestre: "+alumno1. } } En este ejemplo hemos creado el nuevo objeto el cual tiene la referencia alumno2. System.semestre).println("Nombre: "+alumno2.

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

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

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

Con esta modificación al constructor nuestro programa quedará de la siguiente manera: public class Alumno4 { // atributos de la clase String nombre. String carrera. System. String cuenta) { System. String car.out. } public void imprimirDatos() { System. nombre=nom."). carrera=car. String apellidoMaterno. String apellidoPaterno.println("Edad: "+edad). int edad. Electrica Semestre: 1 Lo que demuestra que el constructor es invocado cada vez que se crea un nuevo objeto de la clase.out. String apeMat. System. apellidoMaterno=apeMat. numeroDeCuenta=cuenta. String apePat.. int semestre. String apeMat.println("Semestre: "+semestre). int sem.out.println("Creando un nuevo Alumno. System. System.out. int anios. es seguida explicaremos la razón. int anios. Ahora adecuaremos la firma del constructor para que pueda recibir argumentos e inicialice los atributos del objeto. apellidoPaterno=apePat.out. String apePat. String numeroDeCuenta.out. String cuenta) { … } Observa que hemos cambiado intencionalmente el nombre de las variables para que no concidan con el nombre de los atributos.println("Carrea: "+carrera). public Alumno4(String nom.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno).println("Numero de cuenta: "+numeroDeCuenta). } 20 . String car.. int sem. para esta cambiaremos a firma del constructor de la siguiente manera: public Alumno3(String nom. semestre=sem.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. edad=anios.

esto ocurre debido a que la asignación de variables en el constructor es únicamente de forma local.imprimirDatos()."). //creamos otro nuevo objeto Alumno4 alumno2= new Alumno4("Pedro". es decir la sentencia: nombre=nombre.out. } } Al correr este código veremos que se obtiene el mismo resultado.imprimirDatos()."040012548").1. Electrica". carrera=carrera. String numeroDeCuenta) { System. edad=edad. semestre=semestre. el código se encuentra en el archivo Alumno5.18. nombre=nombre. alumno1. apellidoPaterno=apellidoPaterno. apellidoMaterno=apellidoMaterno.. cambiemos en nombre de las variables de los argumentos del constructor por el mismo nombre que tienen los atributos.java en el cual se hizo el siguiente cambio en el constructor."Lopez"..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"."computacion". String apellidoMaterno."Rodriguez".. Creando un nuevo Alumno."Rodriguez".. int edad.println("Creando un nuevo Alumno. } El resultado de realizar estos cambios se muestra a continuación: Creando un nuevo Alumno. Ahora revisemos de nueva cuenta el constructor.4. public Alumno4(String nombre. el resultado podría ser inesperado.20. alumno2."03021458")."Hernadez". 21 ."Ing. String apellidoPaterno. 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. int semestre. String carrera... numeroDeCuenta=numeroDeCuenta.

out.18.nombre=nombre. } public static void main(String args[]) { //creamos un nuevo objeto de tipo alumno Alumno6 alumno1=new Alumno6("Juan"."Rodriguez".imprimirDatos(). this."040012548").semestre=semestre. alumno1.println("Creando un nuevo Alumno. String numeroDeCuenta) { System. System. int semestre.20."Rodriguez". //creamos otro nuevo objeto Alumno6 alumno2= new Alumno6("Pedro".println("Numero de cuenta: "+numeroDeCuenta).1. this. this. System. public Alumno6(String nombre.println("Semestre: "+semestre).out. String apellidoPaterno.numeroDeCuenta=numeroDeCuenta. Electrica". System.out. 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."Hernadez".out.apellidoPaterno=apellidoPaterno. podemos mejorar nuestro código de la siguiente manera: public class Alumno6 { // atributos de la clase String nombre. this.println("Carrea: "+carrera). this. alumno2."Lopez".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. String apellidoMaterno. this.apellidoMaterno=apellidoMaterno. String carrera.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno)."Ing."03021458")."computacion".out.. es decir es una asignación entre la misma variable.out. } } 22 .4.carrera=carrera. Con el uso de la palabra reservada this. int edad.edad=edad.println("Edad: "+edad). this. int semestre.imprimirDatos(). String apellidoMaterno. int edad. System. String apellidoPaterno.").. nunca se afecta al atributo del objeto. String numeroDeCuenta. String carrera. } public void imprimirDatos() { System.

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

numeroDeCuenta=numeroDeCuenta. this. System.out. this. this.java public class Alumno7 { // atributos de la clase String nombre. int edad.. this.semestre=semestre.println("Semestre: "+semestre). String numeroDeCuenta) { System. La salida del programa anterior es la siguiente: Constructor: Parametro entero solo. System."). System.out. } } 24 .carrera=carrera. String apellidoPaterno. //Alumno7.nombre=nombre. public Alumno7(String nombre.edad=edad.println("Nombre: "+nombre+" "+apellidoPaterno+" "+apellidoMaterno). String numeroDeCuenta. System. Además el uso de this con parámetros.out. petalos= 20 Constructor: Parametro cadena y entero Constructor por defecto (Sin parametros) Numero de petalos: 20 texto= Hola Constructor: Parametro entero solo.. int edad.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.apellidoPaterno=apellidoPaterno. 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.out. String apellidoPaterno. } public void imprimirDatos() { System. String carrera.out.out. Estos dos archivos deberán encontrarse en el mismo directorio por el momento. this. this. String apellidoMaterno.println("Carrea: "+carrera). es decir como llamada al constructor.apellidoMaterno=apellidoMaterno.println("Edad: "+edad).println("Creando un nuevo Alumno. String apellidoMaterno. this. int semestre. String carrera. debe ser la primer cosa que se haga o se obtendrá un mensaje de error del compilador. int semestre. 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.println("Numero de cuenta: "+numeroDeCuenta).

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

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

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

El siguiente ejemplo ilustra lo anterior. Para declara un array basta escribir: int[] suma.println("El resultado de la suma es: "+c). Estos datos trabajan por su cuenta. Hasta ahora. int b= Integer. desempeñando funciones útiles en los programas. que hace rápidos los accesos a elementos. El array es una secuencia lineal simple. System. } } para ejecutar este programa hay que hacerlo de la siguiente manera: C:\ javac SumaDeNumeros. Por ejemplo: int contador. Para solucionar este problema contamos con un tipo de almacenamiento que son los arrays.parseInt(args[0]). referencias a objetos). 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. sino agrupados en una colección de información. public class SumaDeNumeros { public static void main(String args[]) { int a= Integer. Podemos pensar en estas variables como posiciones en memoria que tienen asignados nombres individuales. sumas o lo que sea. El array es la forma más eficiente que proporciona Java para almacenar y acceder al azar a una secuencia de objetos (verdaderamente. 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.java C:\ java SumaDeNumeros 1 2 Arreglos. suma. en la vida tratamos con datos que no están aislados.parseInt(args[1]). Existen muchas otras formas de guardar objetos.out. int c= a+b. o bien: 28 . hemos descrito datos (variables) individuales y aislados. En contraste. como contadores. String nombre.

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

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

Supóngase que los objetos asignan memoria “especial” sin utilizar new. He aquí como se supone que funciona. 31 . si se elige usar finalize(). primero invocara a finalize( ).jar Alumno8. éste te proporciona la habilidad de llevar acabo alguna limpieza importante a la vez que la recolección de basura.) Main-Class: Escuela2 Nota que hemos especificado la clase que contiene el método main a ejecutar. El recolector de basura sólo sabe liberar la memoria asignada por new.MF Escuela. Primero vamos a crear nuestro archivo Manifiesto que tenga la siguiente información. junto con un archive declaración creado automáticamente.jar *. Para hacer frente a este caso. Considere ahora un caso muy inusual.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. Cuando el recolector de basura está preparado para liberar el espacio de almacenamiento utilizado por el objeto.0_02 (Sun Microsystems Inc. Java proporciona un método denominado finalize( ) que se puede definir en cada clase. 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. este archivo puede ser escrito en un editor de texto plano como puede ser notepad de Windows o vi de Linux: Manifest-Version: 1.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. guarda este archivo en el mismo directorio de tus clases con el nombre: MANIFEST.class Para ejecutar el archivo escribir: C:\>java –jar Escuela.5. Por tanto. en la línea de comandos escribe: C:\ >jar cmf MANIFEST. por lo que ahora no sabrá como liberar esa memoria “especial” del objeto.class Escuela2.class Esto crea un fichero JAR llamado miFichero.jar que contiene todos los archivos de clase del directorio actual.MF Como siguiente paso vamos a comprimir los archivos.jar Limpieza: Finalización y recolección de basura. y sólo recuperará la memoria del objeto durante la pasada del recolector 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.

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

uno no sabe exactamente cuando empezará. 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. Si la Máquina Virtual Java (JVM) no está a punto de quedarse sin memoria. 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.f) { new Silla(). 33 . Una posible salida del programa anterior se muestra a continuación: Creadas 47 Comenzando a finalizar tras haber creado 12207sillas Finalizando la silla #47. no se invoca a todos los finalizadotes cuando acaba el programa. que se invoca durante la recolección de basura.java public class Basura { public static void main(String args[]) { //Mientras no se haya puesto la bandera. lo que hará cuando se empiece a poner nervioso por la cantidad de memoria disponible. total finalizadas: "+Silla. new String("Ocupar Espacio").out. Recuerde que ni el recolector de basura ni la finalización están garantizadas. Dado que el recolector puede ejecutarse en cualquier momento.println("Despues de haber creado todas las sillas: \n"+ "Creadas en total: "+Silla.creadas+". por consiguiente se destruirán todos los objetos que no estén en uso en ese momento.finalizadas). entonces (sabiamente) no malgastará tiempo en recuperar memoria mediante el recolector de basura. Si se llama a System. Ambos indicadores se ponen dentro de finalize( ).Manual del Curso Java Básico Programa de Tecnología en Cómputo } //Basura. } } El programa anterior crea muchos objetos Silla. 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. y en cierto momento después de que el recolector de basura comience a ejecutarse el programa deja de crear objetos Silla. total finalizadas: 33864 Por consiguiente. y hay un indicador denominado recolector para indicar si el recolector a comenzado su ejecución o no. } System.gc(). //hacer sillas y cadenas de texto while(!Silla.

si el objeto representa un fichero abierto. Si una de las finalizaciones acaba revelando el fallo.java public class CondicionDeMuerto { public static void main(String[] args) { Libro novela = new Libro(true). } } 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.java //Utilizacion de finalize() para detectar un objeto // que no ha sido correctamente eliminado public class Libro { boolean comprobado=false.out. pero en el método main( ) un error del programador no comprueba alguno de los libros. ese fichero debería ser cerrado por el programador antes de que el objeto sea eliminado por el recolector de basura. } void correcto() { comprobado=false. //Cargarse la referencia olvidando la limpieza new Libro(true). } } //CondicionDeMuerto.gc().println("Error: comprobado"). se tendrá un fallo en el programa que podría ser difícil de encontrar. Por ejemplo. 34 . incluso si no se invoca siempre. public Libro(boolean comprobar) { comprobado=comprobar. El valor de finalize( ) es que puede usarse para descubrir esta condición.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.correcto(). } public void finalize() { if(comprobado) System. He aquí un ejemplo simple de cómo debería usarse: //Libro. se descubre el problema. Si no se eliminan correctamente ciertas porciones de objeto. que es lo que verdaderamente hay que cuidar. //Eliminacion Correcta novela. //forzar la recoleccion de basura y finalizacion System.

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

Esto permite un uso total de HTML. 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. @author: Suele ser el nombre del creador pero podría ser cualquier cosa como la dirección de correo. Javadoc generará HTML con las etiquetas @see en forma de vínculos a la otra documentación. que serán vistas en el curso de java Avanzado.Manual del Curso Java Básico Programa de Tecnología en Cómputo HTML empotrado Javadoc pasa comandos HTML al documento HTML generado. 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. sin embargo. La forma es: @see NombreDeClase @version: Información de la versión de la clase. 36 .println(new Date()). como: /** * <pre> * System. que permiten hacer referencia a la documentación de otras clases. * </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.out. La forma es: @version información-de-version. el motivo principal es permitir dar formato al código. variable y métodos) pueden contener etiquetas @see.

} 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. y no modificable */ static final int VALOR=10. se describe sobre las características. uso.util. * @author PROTECO * */ public class Comentada extends Vector implements Runnable{ /** * Asi se comentan los atributos */ protected String atributo. * para darle formato al texto. Se da una descripción de lo que hacen * y se pueden dar algunos ejemplos.<br> * En esta parte. import java.Vector.Vector arg2. /** * Este es un ejemplo de código comentado<br> * <h1>Se pueden usar etiquetas de HTML</h1>. 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.Manual del Curso Java Básico Programa de Tecnología en Cómputo @throws nombre-de-clase descripción Ejemplo de documentación. 37 . /** * Tambien los métodos constructores pueden ir comentados * */ public Comentada(){ } /** * Asi se comentan lo métodos. /** * Este es una atributo de clase.int num) throws Exception{ return 0.java y la herramienta javadoc generará el archivo html en el directorio actual. y funcionamiento * de la clase en general.

cuando se escribe: System. pero es un objeto de la clase String. Podemos conocer si un string comienza con un determinado prefijo. llamando al método startsWith. según que el string comience o no por dicho prefijo: String str="El primer programa". Por ejemplo. También se puede escribir. Para obtener la longitud. Sin embargo. int longitud=str. alternativamente String str="El primer programa". 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. Los String se pueden crear explícitamente o implícitamente. número de caracteres que guarda un String se llama al método length.out. String str=new String(). Un string nulo es aquél que no contiene caracteres. pero aún no se ha creado ningún objeto de esta clase. Para crear un String implícitamente basta poner una cadena de caracteres entre comillas dobles. boolean resultado=str. Java crea un array de caracteres de una forma similar a como lo hace el lenguaje C++. Java crea un objeto de la clase String automáticamente. que devuelve true o false. Para crear un String nulo se puede hacer de estas dos formas String str="". Está declarando un objeto str de la clase String. A este array se accede a través de métodos de la clase. 38 .length(). String str.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. String str="El primer programa".println("El primer programa"). En este ejemplo la variable resultado tomará el valor true. Para crear un String explícitamente escribimos: String str=new String("El primer programa").startsWith("El").

indexOf('p'. se usa la función indexOf: String str="El primer programa". se llama a otra versión de la misma función pos=str. String str2=new String("El lenguaje Java").println("Distinto contenido"). Para obtener las sucesivas posiciones de la letra p. mediante el método endsWith: String str="El primer programa".println("El mismo contenido"). if(str1==str2) { System. Otra versión de indexOf busca la primera ocurrencia de un substring dentro del String: String str="El primer programa". } else { 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. Si se quiere obtener la posición de la primera ocurrencia de la letra p. } else { System. int pos=str.indexOf('p'). En el siguiente código: public class ClaseString { public static void main(String[] args) { String str1="El lenguaje Java".equals(str2)) { System. pos+1).println("Los mismos objetos"). 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. 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. boolean resultado=str. int pos=str.endsWith("programa"). esto se conoce como sobrecarga de métodos y será visto a detalle en el siguiente capitulo.out.indexOf("pro").println("Distintos objetos"). 39 .out. } if(str1. podemos saber si un String finaliza con un conjunto dado de caracteres.Manual del Curso Java Básico Programa de Tecnología en Cómputo De modo similar.out.

cero si son iguales. String subStr=str. Una segunda versión del método substring. System. str1 y str2 ocupan posiciones distintas en memoria pero guardan los mismos datos. 40 .compareTo("Tomás"). String subStr=str. Cambiemos la segunda sentencia y escribamos: String str1="El lenguaje Java". 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.compareTo("Alberto").out. Para extraer un substring desde una posición determinada hasta el final del String escribimos: String str="El lenguaje Java". ya que de otra forma. String str="El lenguaje Java".prinln("Son el mimso objeto "+(str1==str2). Los objetos str1 y str2 guardan la misma referencia al objeto de la clase String creado. String str="Tomás". La expresión (str1==str2) devolverá true. String str2=str1. int resultado=str. nos permite extraer un substring especificando la posición de comienzo y la el final. Para este propósito hay un método de la clase String denominada substring. int resultado=str. La variable entera resultado tomará un valor mayor que cero. Extraer un substring de un String En muchas ocasiones es necesario extraer una porción o subcadena de un String dado. 11). y mayor que cero si el objeto String es mayor que el String dado. ya que Alberto está antes que Tomás en orden alfabético. El método comapareTo devuelve un entero menor que cero si el objeto String es menor (en orden alfabético) que el String dado.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. Se obtendrá el substring "Java". ya que Tomás está después de Alberto en orden alfabético. String str="Alberto". con el operador = = compararemos si los Objetos apuntan a la misma dirección de memoria.substring(3.substring(12).

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

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

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

out. int edad.out.println("El animal respira").raza= nombre.println("El animal duerme"). } public static void main(String args[]) { 44 .out.java public class Animal2 { String raza. public void maullar() { System. String nombre. } public Gato2(String nombre. public Animal2(){ System.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 tipoDeComida.println("Alimentando al animal"). Modificando el programa anterior tenemos: //Animal.out.out. } public void dormir() { System.out.println("En el constructor llamado por super"). String tipoDePelaje. String tamaño.println("El gato esta maullando").out. System. String raza){ this.println("\nGato creado"). } public void respirar() { System. } public void reproduccion() { System. raza). } public void comer() { System. this.println("El gato esta rasgando").println("El animal es totalmente Rebelde"). } public void rasgar() { System.out. System. } } public class Gato2 extends Animal2 { int numVidas=7.out.nombre=nombre.String raza) { super(nombre. } public Animal2(String nombre.println("El animal puede reproducirse").

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

out. //Gato3. public void maullar() { System. new SobreCarga('Z'. } public void dormir() { System. es decir Animal2. } public static void main(String[] args){ new SobreCarga(2).String cad){ System. new SobreCarga("Hola enfermera").out.String= "+cad).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.out. } public SobreCarga(char c. System. Como ejemplo.out.println("El gato esta durmiendo. 46 .7.respirar().int= "+num+" . no molestar"). 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. 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.String raza) { super(nombre. raza)."No hay papel").println("\nGato creado"). String tipoDeComida. new SobreCarga(). new SobreCarga(9).println("Soy un objeto creado por el constructor con tres argumentos char= "+c+" .println("El gato esta rasgando"). } public static void main(String args[]) { Gato3 gato1=new Gato3("Batman". } } Sobrescritura de Métodos.Manual del Curso Java Básico Programa de Tecnología en Cómputo System. } public Gato3(String nombre.java public class Gato3 extends Animal2 { int numVidas=7.println("El gato esta maullando"). número y tipo de argumentos) que el método de la superclase. regresemos al ejemplo de la clase Animal y Gato.out."Angora"). } public void rasgar() { System.int num. Una subclase sobrescribe un método de su superclase cuando define un método con las mismas características (nombre. gato1.out.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

println("En el metodo } private void metodoPrivate() { System. //es amigable private int d = 4. sin modificador"). protected").java package paq01.out. una clase se ve a ella misma todo tipo de variables y métodos (desde los public hasta los private).out. public void metodoPublic() { System.println("En el metodo } void metodo() { System. private").println("En el metodo } protected void metodoProtected() { System. Como se observa de la tabla anterior. 66 . El resto del universo de clases (que no sean ni del mismo paquete ni subclases) pueden ver sólo los miembros public.out.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 class ClaseInicial { public int a = 1.out.println("En el metodo } public"). int c = 3. Ejemplo: //ClaseInicial. las demas clases del mismo paquete (ya sean subclases o no) tienen acceso a los miembros desde los public hasta los sinmodificador. Los miembros de instancia no son visibles. Las subclases de otros paquetes pueden ver los miembros public y a los miembros protected. protected int b = 2. é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).

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

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

más tarde se le fueron incorporando algunas mejoras y el browser Hot Java fue dado a conocer al mundo en 1995. Por su parte el presidente de la compañía Sun. que era una especie de cruce entre un asistente digital personalizado y un mecanismo inteligente de control remoto. Para 1992. mismas que se fueron dando mediante el sistema operativo base. y con la ayuda de los otros miembros del equipo desarrollaron un decodificador que mas tarde se convertiría en lenguaje Java. es muy importante conocer su lugar de origen y cuales fueron sus propósitos: En Diciembre de 1990. reclutó a sus colegas James Gosling y Mike Sheridan para trabajar sobre un nuevo tema conocido como "El proyecto verde". se dio cuenta en forma muy oportuna y estableció el Proyecto Verde como una subsidiaria de Sun. 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. En abril de 1991. Afortunadamente. Scott McNealy. Al examinar las dinámicas de Internet. sin embargo el equipo concluyó que el mercado para consumidores electrónicos smart y las cajas Set-Up en particular. 69 . el cese del Proyecto Verde coincidió con el nacimiento del fenómeno mundial Web. James Gosling escribió el compilador original y lo denominó "Oak".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. 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. 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. el equipo decidió introducir sistemas de software con aplicaciones para consumidores smart como plataforma de lanzamiento para su proyecto. De 1993 a 1994. Patrick Naughton. Una de las características más atractivas del Hot Java fue su soporte para los "applets". el equipo de Naughton se lanzó en busca de nuevas oportunidades en el mercado. el equipo ya había desarrollado un sistema prototipo conocido como "*7". 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. fácil de aprender y de usar. no eran del todo eficaces. 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. 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’. que fuera universal. La incipiente subsidiaria fracasó en sus intentos de ganar una oferta con Time-Warner. un empleado de la empresa Sun.

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. un producto informativo para PC’s de escritorio. Como parte de su estrategia de crecimiento mundial y para favorecer la promoción de su nueva tecnología. también incluía paquetería básica de gráficos. Microsoft. 70 . IBM. un debugger prototipo y una máquina virtual Java(JVM). herramientas. Durante ese mismo mes. Netscape y Oracle. 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".0. a varios sistemas operativos. 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). de esta forma de se dio continuidad al fortalecimiento del programa del lenguaje Java y así trabajar con terceras partes para crear aplicaciones. mostró las ventajas de Java y rápidamente se asoció con Java Soft para explotar su nueva tecno logía. 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. 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. Symantec. No pasó mucho tiempo antes de que Netscape Communications decidiera apoyar a los Java applets en Netscape Navigator 2. Sun formó la empresa Java Soft en enero de 1996. Desde su aparición. Toshiba y por supuesto Novell.0. Java Soft dio a conocer el Java Developmet Kit (JDK) 1. sistemas de plataforma y servicios para aumentar las capacidades del lenguaje. Dicha colección incluía el compilador Java. un fondo común de capital formado el verano pasado por 11 compañías. incluyendo Cisco Systems. Los Colegios y Universidades alrededor del mundo están adoptando Java como un lenguaje universal y de enseñanza indispensable. hoy en día existen más de 150 libros en Java que se están imprimiendo en este momento. y que a su vez forzó a otros vendedores para apoyar el soporte de applets en Java. Este fue el factor clave que lanzó a Java a ser reconocido y famoso. necesaria para correr programas basados en Java. Asimismo el Netscape Comunications Inc.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. sonido. un visualizador de applets. Oracle. Muy pronto las licencias o permisos contemplaban a prestigiadas firmas como IBM. 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. animación y trabajo en red. Silicon Graphics. 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.

.000 usuarios. 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. 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.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. Para darse una idea de la rápida aceptación que tiene Java en el mundo. 71 . en la segunda conferencia Java One albergó a 10. asistentes. un año después. una tercera parte están usando Java. el primer Java One fue celebrado en abril de 1996 y atrajo a 5000 usuarios.

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->