Java Basico 1

JAVA FUNDAMENTALS PROGRAMMING[Type the document subtitle][Type the abstract of the document here. The abstract is typically a short summary of the contents of the document. Type the abstract of the document here. The abstract is typically a short summary of the contents of the document.] Ing. Marcel Chasiguasi 1/9/2012

JAVA FUNDAMENTALS PROGRAMMING

TABLE OF CONTENTSINTRODUCCION ................................................................................................................... 6 HISTORIA DE JAVA .......................................................................................................... 6 Los antecedentes de Java ................................................................................................ 6 La llegada de Java ........................................................................................................... 6 Caractersticas de Java .................................................................................................... 7 Utilizando java desde la consola de comandos ...................................................................... 8 Instalando la JDK y configurando el entorno..................................................................... 9 Compilando y ejecutando ................................................................................................. 10 Identificadores .................................................................................................................. 10 Identificadores legales ................................................................................................... 11 Convenciones de cdigo de Java Sun ............................................................................. 11 Estndares para nombres de JavaBeans........................................................................ 11 Declaraciones de clases y modificadores de acceso .......................................................... 12 Modificadores de acceso a clases .................................................................................. 13 Modificadores de no acceso .......................................................................................... 13 Declaracin de interfaces .................................................................................................. 14 Declaracin de mtodos y atributos ................................................................................. 15 Modificadores de acceso ............................................................................................... 15 Modificadores de acceso en variables locales ............................................................... 16 Modificadores de no acceso .......................................................................................... 16 Modificador de no acceso en mtodos final............................................................... 16 Modificador de no acceso en atributos final .............................................................. 16 Modificador de no acceso en mtodos abstract ......................................................... 16 Modificador de no acceso en mtodos synchronized ................................................ 16 Modificador de no acceso en mtodos Native ........................................................... 16 Modificador de no acceso en mtodos strictfp ...........................................................17 Chapter: INTRODUCCION

0

JAVA FUNDAMENTALS PROGRAMMING Mtodos con listas de argumentos variables .................................................................17 Declaracin de constructores ........................................................................................ 18 Declaracin de variables ................................................................................................... 18 Declaracin de variables primitivas y rango de variables ............................................. 18 Declaracin de variables de referencia ......................................................................... 19 Declaracin de arrays .................................................................................................... 20 Declaracin de variables final ....................................................................................... 20 Variables transient ........................................................................................................ 20 Variables volatile ........................................................................................................... 20 Variables y mtodos estticos ....................................................................................... 20 Declaracin de enumeradores....................................................................................... 20 Paradigmas de programacin ........................................................................................... 21 Paradigma estructural ................................................................................................... 21 Paradigma orientado a objetos ..................................................................................... 21 Definicin de una clase ................................................................................................. 22 Diferencia entre clase y objeto ...................................................................................... 23 Ms conceptos de la POO ................................................................................................. 24 Encapsulamiento........................................................................................................... 24 Herencia ........................................................................................................................ 24 Polimorfismo ................................................................................................................. 25 Sobre escritura .............................................................................................................. 26 Sobrecarga ..................................................................................................................... 27 Polimorfismo en sobre escritura y sobrecarga .............................................................. 28 Casteo de variables de referencia .................................................................................. 29 Implementar (implements) una interfaz ......................................................................... 31 Tipos de valor de retorno vlidos ..................................................................................... 31 Declaracin de tipos de valor de retorno (Return types declaration)........................... 31 Tipos de valor de retorno en mtodos sobrecargados .................................................. 31 Tipos de valor de retorno en mtodos sobre escritos ................................................... 32 Devolviendo un valor .................................................................................................... 32 Constructores e instanciacin........................................................................................... 32 Conceptos bsicos de los constructores (Constructor basics) ...................................... 32 Llamadas en cadena a constructores (Constructor chaining) ...................................... 32

JAVA FUNDAMENTALS PROGRAMMING Reglas de los constructores (Rules for constructors).................................................... 33 Determinar cundo se crear el constructor por defecto.............................................. 33 Como es el constructor por defecto? ............................................................................. 34 Qu pasa si el constructor de la superclase requiere argumentos? .............................. 34 Sobrecarga de constructores ......................................................................................... 34 Mtodos y variables estticos ........................................................................................ 34 Accediendo a mtodos y variables estticas.................................................................. 35 Valores literales para todos los tipos primitivos............................................................... 35 Integer ........................................................................................................................... 35 Literales decimal ........................................................................................................... 35 Literales octal ................................................................................................................ 35 Literal hexadecimal ....................................................................................................... 35 Punto flotante................................................................................................................ 35 Booleanos ...................................................................................................................... 36 Caracteres ...................................................................................................................... 36 Strings ........................................................................................................................... 36 Operadores de asignacin ................................................................................................. 36 Asignacin de valores primitivos .................................................................................. 36 Casteo de primitivas ...................................................................................................... 37 Tabla de casteos implcitos para primitivas .................................................................. 37 Asignacin de nmeros con punto flotante .................................................................. 38 Asignacin de un literal que es ms grande que la variable ......................................... 38 Asignar una variable primitiva a otra variable primitiva.............................................. 38 mbito de las variables (scope) .................................................................................... 38 Errores ms comunes con problemas de scope ............................................................ 39 Utilizar una variable o array que no ha sido inicializado ni asignado .......................... 39 Variables de instancia de tipos primitivos y objetos ..................................................... 39 Variables de instancia de tipo array .............................................................................. 40 Variables primitivas locales y objetos ........................................................................... 40 Envo de variables a mtodos ........................................................................................ 41 Declaracin, construccin e inicializacin de arrays .................................................... 41 Construccin de un array .............................................................................................. 41 Construir un array multidimensional ........................................................................... 42 Chapter: INTRODUCCION

2

JAVA FUNDAMENTALS PROGRAMMING Inicializacin de un array .............................................................................................. 42 Inicializando elementos en un bucle ............................................................................. 43 Declaracin, construccin, e inicializacin en una lnea .............................................. 43 Construyendo e inicializando un array annimo .......................................................... 43 Asignaciones legales de elementos de un array ............................................................ 44 Asignaciones legales de referencias de tipo array ............................................................ 44 Referencias para tipo de datos primitivos .................................................................... 44 Referencias para tipos de datos de referencia .............................................................. 44 Referencias para tipos de datos de referencia en arrays multidimensionales .............. 44 Bloques de inicializacin................................................................................................... 45 Las clases Wrapper........................................................................................................ 46 Creacin de objetos Wrapper ........................................................................................ 46 Los constructores del Wrapper ..................................................................................... 47 El mtodo valueOf() ...................................................................................................... 47 Utilidades de conversin de los Wrappers .................................................................... 47 Autoboxing .................................................................................................................... 49 Boxing, ==, y equals() ................................................................................................... 49 Sobrecarga (overloading) .............................................................................................. 49 Sobrecarga con boxing y var-args ................................................................................. 50 Sobrecarga con var-args ................................................................................................ 50 Operadores ........................................................................................................................... 50 Operadores de asignacin ................................................................................................. 50 Operadores de asignacin compuestos............................................................................. 51 Operadores relacionales ................................................................................................... 52 Operadores de igualdad .................................................................................................... 53 Igualdad en primitivas ...................................................................................................... 54 Igualdad en variables de tipo referencia........................................................................... 54 Igualdad en enumeradores ........................................................................................... 55 Comparacin con instanceof ......................................................................................... 55 Operadores aritmticos ................................................................................................. 56 Operadores de incremento y decremento ..................................................................... 56 Operador condicional.................................................................................................... 58 Operadores lgicos............................................................................................................ 58

JAVA FUNDAMENTALS PROGRAMMING Operadores lgicos sobre bits (no entra en el examen) ................................................ 58 Operadores lgicos de circuito corto............................................................................. 59 Operadores lgicos de circuito completo ...................................................................... 60 Operadores lgicos ^ y ................................................................................................ 61 If y Switch ......................................................................................................................... 62 If-else ............................................................................................................................. 62 Switch ............................................................................................................................ 65 Bucles e iteraciones ....................................................................................................... 67 While ............................................................................................................................. 67 Sentencias de ruptura con etiquetas ............................................................................. 72 Manejo de excepciones.................................................................................................. 73 Propagacin de excepciones.......................................................................................... 74 Definiendo que es una excepcion .................................................................................. 76 Jerarqua de excepciones .................................................................................................. 76 Atrapando excepciones ................................................................................................. 76 Declaracion de excepciones e interface pblica ............................................................ 77 Relanzando excepciones ............................................................................................... 78 De donde provienen las excepciones ............................................................................ 79 Afirmaciones .................................................................................................................80 El mtodo toString() ..................................................................................................... 83 Sobrescribiendo el mtodo equals().............................................................................. 84 Contratos a cumplir....................................................................................................... 86 Colecciones ....................................................................................................................... 86 Caractersticas de cada clase ......................................................................................... 86 List ........................................................................................................ 87 Set ......................................................................................................... 88 Map ....................................................................................................... 89 Queue .................................................................................................... 90 ArrayList........................................................................................................................ 91 Autoboxing con colecciones .......................................................................................... 92 Ordenando colecciones ................................................................................................. 92 La interfaz comparable.................................................................................................. 93 La interfaz comparator.................................................................................................. 94 Chapter: INTRODUCCION

4

JAVA FUNDAMENTALS PROGRAMMING Comparable vs Comparator .......................................................................................... 96 Ordenando con la clase Arrays...................................................................................... 96 Bsqueda en Arrays y Collections ................................................................................. 96 Conversion de Arrays a Lists a Arrays .......................................................................... 97 Utilizando los Lists ........................................................................................................ 98 Utilizando los Sets ....................................................................................................... 100 Utilizando los Maps......................................................................................................101 Bsqueda dentro de los TreeSets y TreeMaps ............................................................ 103 Colecciones respaldadas.............................................................................................. 103 Mtodos para crear colecciones respaldadas .............................................................. 104 Cola de prioridades (PriorityQueue) .............................................................................. 105 Mtodos de PriorityQueue .......................................................................................... 105 Resmen de mtodos para Arrays y Colecciones ........................................................ 105 Resumen de mtodos para List, Set y Map ................................................................. 106 Genricos ........................................................................................................................ 107 Un vistazo a colecciones con y sin genricos .............................................................. 107 Mezclando colecciones genricas y no genricas ........................................................ 109 Polimorfismo y genricos .............................................................................................110 Comodines en la declaracin de mtodos .................................................................... 111


Java Fundamentals ProgrammingINTRODUCCIONHISTORIA DE JAVALOS ANTECEDENTES DE JAVA Antes de que llegue Java a facilitarnos el desarrollo de aplicaciones existan ya varios lenguajes de programacin tales como Fortran, Cobol, Basic, Pascal, C, etc. Pero estos lenguajes usaban tcnicas de programacin estructurada, lo cual causaba problemas de cdigo incontrolable cuando la aplicacin creca. Entre ellos tambin estaba el lenguaje C, como el lenguaje ms popular en aquella poca. Este es un lenguaje muy verstil, con posibilidad de programar en ensamblador y la comodidad que da los lenguajes de alto nivel. El inconveniente de este lenguaje es que permita acceso directo a la memoria del computador usando punteros. Recuerdo que los punteros causaban dolores de cabeza a los programadores. Hay otro inconveniente es que un programa en C/C++ es ejecutable, provocando que el programa no sea independiente de la plataforma en la que se ejecuta. Para mitigar el problema de cdigo incontrolable se cre el Lenguaje C++ con soporte de programacin Orientada a Objetos. Pero segua teniendo problemas debido a que C++soportaba el paradigma de programacin estructurada, el cual provocaba que los programadores no usen el nuevo paradigma de Orientacin a Objetos. Java fue diseado para satisfacer las necesidades de la poca, planteada por nuevos requerimientos que surgan a los lenguajes existentes. LA LLEGADA DE JAVA En 1991, la empresa Sun Microsystem inicia el Proyecto Green(Proyecto Verde), sus objetivos estaban enfocados a crear un lenguaje para dispositivos electrnicos inteligentes y televisin interactiva. En el lapso de 18 meses se presentaron varios requerimientos: Lenguaje fcil de usar y aprender Programacin Orientada a Objetos Multiplataforma: Los dispositivos inteligentes cambian con frecuencia, asi que deseaban que el programa que funciones en un dispositivo funcione para las nuevos modelos de dispositivos El resultado fue un nuevo lenguaje llamado Oak (Roble en inlges, nombre originado por el roble que vea en la ventana de sus despacho), este lenguaje tenia similitudes con C/C++ y no estaba ligado a tipo de CPU especifico.

6

Chapter: INTRODUCCION

JAVA FUNDAMENTALS PROGRAMMING Ms tarde en 1995 el nombre fue cambiado de Oak a Java(Nombre dado por un tipo de caf originario de Asia) por custiones de propiedad intelectual, debido a que ya exista un lenguaje llamado Oak. Java se da a conocer al pblico. Adquiere notoriedad rpidamente. Java pasa a ser un lenguaje totalmente independiente de la plataforma y a la vez potente y orientado a objetos. Esa filosofa y su facilidad para crear aplicaciones para redes TCP/IP ha hecho que sea uno de los lenguajes ms utilizados en la actualidad. Sus ventajas sobre C++ son: Su sintaxis es similar a C y C++ No hay punteros (lo que le hace ms seguro) Totalmente orientado a objetos Muy preparado para aplicaciones TCP/IP Implementa excepciones de forma nativa Es interpretado (lo que acelera su ejecucin remota, aunque provoca que las aplicaciones Java se ejecuten ms lentamente que las C++ en un ordenador local). Permite multihilos Admite firmas digitales Tipos de datos y control de sintaxis ms rigurosa Es independiente de la plataforma La ltima ventaja (quiz la ms importante) se consigue ya que el cdigo Java no se compila, sino que se precompila, de tal forma que se crea un cdigo intermedio que no es ejecutable. Para ejecutarle hace falta pasarle por un intrprete que va ejecutando cada lnea. Ese intrprete suele ser la mquina virtual de Java CARACTERSTICAS DE JAVA Bytecodes Los programas Java no son ejecutables, no se compilan como los programas en C o C++. En su lugar son interpretados por una aplicacin conocida como la mquina virtual de Java (JVM). Gracias a ello no tienen porque incluir todo el cdigo y libreras propias de cada sistema. Previamente el cdigo fuente en Java se tiene que precompilar generando un cdigo (que no es directamente ejecutable) previo conocido como bytecode o J-code. Ese cdigo (generado normalmente en archivos con extensin class) es el que es ejecutado por la mquina virtual de Java que interpreta las instrucciones de los bytecodes, ejecutando el cdigo de la aplicacin. El bytecode se puede ejecutar en cualquier plataforma, lo nico que se requiere es que esa plataforma posea un intrprete adecuado (la mquina virtual de esa plataforma). La mquina virtual de Java, adems es un programa muy pequeo y que se distribuye gratuitamente para prcticamente todos los sistemas operativos. A este mtodo de ejecucin de programas en tiempo real se le llama Just in Time (JIT).

En Java la unidad fundamental del cdigo es la clase. Son las clases las que se distribuyen

JAVA FUNDAMENTALS PROGRAMMING en el formato bytecode de Java. Estas clases se cargan dinmicamente durante la ejecucin del programa Java. Seguridad Al interpretar el cdigo, la JVM puede delimitar las operaciones peligrosas, con lo cual la seguridad es fcilmente controlable. Adems, Java elimina las instrucciones dependientes de la mquina y los punteros que generaban terribles errores en C y la posibilidad de generar programas para atacar sistemas. Tampoco se permite el acceso directo a memoria y adems. La primera lnea de seguridad de Java es un verificador del bytecode que permite comprobar que el comportamiento del cdigo es correcto y que sigue las reglas de Java. Normalmente los compiladores de Java no pueden generar cdigo que se salte las reglas de seguridad de Java. Pero un programador malvolo podra generar artificialmente cdigo bytecode que se salte las reglas. El verificador intenta eliminar esta posibilidad. Hay un segundo paso que verifica la seguridad del cdigo que es el verificador de clase que es el programa que proporciona las clases necesarias al cdigo. Lo que hace es asegurarse que las clases que se cargan son realmente las del sistema original de Java y no clases creadas reemplazadas artificialmente. Finalmente hay un administrador de seguridad que es un programa configurable que permite al usuario indicar niveles de seguridad a su sistema para todos los programas de Java. Hay tambin una forma de seguridad relacionada con la confianza. Esto se basa es saber que el cdigo Java procede de un sitio de confianza y no de una fuente no identificada. En Java se permite aadir firmas digitales al cdigo para verificar al autor del mismo. Tipos de aplicaciones Java Applet: Son programas Java pensados para ser colocados dentro de una pgina web. Pueden ser interpretados por cualquier navegador con capacidades Java. Estos programas se insertan en las pginas usando una etiqueta especial (como tambin se insertan vdeos, animaciones flash u otros objetos). Los applets son programas independientes, pero al estar incluidos dentro de una pgina web las reglas de stas le afectan. Normalmente un applet slo puede actuar sobre el navegador. Hoy da mediante applets se pueden integrar en las pginas web aplicaciones multimedia avanzadas (incluso con imgenes 3D o sonido y vdeo de alta calidad) Aplicaciones de consola: Son programas independientes al igual que los creados con los lenguajes tradicionales. Aplicaciones grficas: Aquellas que utilizan las clases con capacidades grficas (como awt por ejemplo). Servlets: Son aplicaciones que se ejecutan en un servidor de aplicaciones web y que como resultado de su ejecucin resulta una pgina web.

UTILIZANDO JAVA DESDE LA CONSOLA DE COMANDOSVamos a hacer una diferencia entre dos componentes de Java: JRE JDK

8

Chapter: Utilizando java desde la consola de comandos


JRE (Java Runtime Environment): Set de libreras que permiten correr una JVM en la pc para poder ejecutar un programa escrito en Java (bytecodes). JDK (Java Development Kit): Como mencionamos arriba, los bytecodes son un lenguaje intermedio entre el cdigo fuente y el cdigo mquina, el cual es interpretado para la JVM. Para generar este cdigo, necesitamos de otras funcionalidades que no contiene la JRE. Adems, en la JDK encontraremos la API de Java. Un set de libreras predefinidas para que utilicemos en nuestros programas. Los pasos a continuacin representan una gua simple para poder utilizar la consola de comandos, simplemente para que puedan hacer ejercicios sobre los temas estudiados. De todas maneras, la consola de comandos se tratar ms a fondo en entregas posteriores.

INSTALANDO LA JDK Y CONFIGURANDO EL ENTORNO1. Si ya tienes una version de la JDK igual o superior a la 1.6.0 puedes pasar al paso 3. Vamos a obtener la JDK desde el sitio oficial de sun http://java.sun.com. El link directo: http://java.sun.com/javase/downloads/widget/jdk6.jsp Lo que nosotros buscamos es la JDK de Java SE. 2. Una vez que hayas desccargado la JDK es tiempo de instalarla. 3. Dijimos que ibamos a utilizar la consola de comandos, el problema es que la JDK no se almacena en la variable PATH de windows, esto quiere decir que aun no podemos ejecutar los comandos de Java, salvo que nos encontremos en el directorio de los mismo \[Directorio instalacin JDK]\Bin\ En Windows, lo que vamos a hacer primero es rastrear este Path. Generalmente se encuentra en: C:\Archivos de programa\Java\jdk1.6.0_XX\bin\. Si no puedes dar con este Path, puedes buscar el archivo javac.exe. Una vez que tengas el directorio, guardalo en un txt. 4. Botn derecho sobre Mi Pc -> Propiedades. En la solapa de Opciones Avanzadas, buscamos la opcin que dice Variables de entorno. En el segundo recuadro, buscamos por una variable que se llame PATH. Doble click sobre la misma, y abrir la edicin. Ahora, agreguen el siguiente texto sin eliminar lo que hubiera antes: ;[Path copiado al txt]; donde Path copiado al txt es el path de los bin de la JDK (ponemos entre comillas el cdigo por si el path contiene algn espacio). Luego acepta los cambios. 5. Ve a Menu Inicio -> Ejecutar -> y tipea cmd. Se debera de abrir una consola de comandos. Ahora vamos a probar que la asignacin del Path fue correcta. Para ello tecleamos el comando javac. Debera de aparecerte algo como lo siguiente:

C:\>javac Usage: javac where possible options include:


Si recibiste un mensaje que comienza como este, significa que la instalacin fue exitosa, de lo contrario, vuelve a rever los pasos anteriores.

COMPILANDO Y EJECUTANDOCuando escriban cdigo en Java, cada archivo fuente contendra la extensin java (dificil de recordar, no?!). En cambio, los archivos compilados contienen la extensin class. Tambin pueden estar dentro de un jar, que no es ms que un zip que los agrupa en un solo archivo (tiene otras particularidades). Nosotros vamos a centrarnos en la creacin de los .java y los .class. Los jar los dejaremos fuera por ahora. Esta seccin tiene en cuenta que el lector tiene conocimientos bsicos para manejarse en la consola de comandos. Vamos a crear nuestra primer app. Java: 1. Crea un archivo llamado HolaJavaWorld.java (en el directorio que quieras), y copia el cdigo a continuacin dentro del archivo.1. 2. 3. 4. 5. public class HolaJavaWorld { static public void main(String[] args) { System.out.println("Hola Java World!"); } }

Con estos conocimientos bsicos de la consola, y un poco de conocimiento del lenguaje Java, ya te encuentras en condiciones de generar cdigo para probar tus conocimientos sobre lo que vayas leyendo.System.out.println(Buena Suerte);

IDENTIFICADORESLos identificadores permiten que podamos identificar una variable por un nombre y/o conjunto de caracteres alfanumricos (generalmente, describen el contenido). Para los identificadores, existen una serie de convenciones.

10


2. Ejecuta la consola de comandos, y posiciona el Prompt sobre el directorio donde creaste el archivo (Tip: si haces botn derecho sobre el directorio, vers una opcin que dice smbolo de sistema, esto te habre una consola de comandos posicionada en dicho directorio). 3. Ejecuta javac g HolaJavaWorld.java . En esta parte es donde le pedimos al compilador de Java que genere el Bytecode de dicho archivo fuente. Si llegase a existir algn error de compilacin, es en este punto que se nos informa de tal. 4. Ejecuta java HolaJavaWorld. Aqui creamos una instancia de la JVM sobre la cual correr nuestra aplicacin, en la cual veremos un grandioso Hola Java World!.

JAVA FUNDAMENTALS PROGRAMMING IDENTIFICADORES LEGALES Los identificadores legales se refieren a aquellos que cumplen con las normas mnimas de manera que el compilador no genere un error en tiempo de compilacin. Las caractersticas que deben de cumplir los identificadores son:

Debe estar compuesto de caracteres Unicode, nmeros, $ o _ Debe comenzar con un carcter Unicode, $ o _ Luego del primer carcter, puede contener cualquier conjunto de los nombrados en el primer punto No tienen un lmite de largo No es posible utilizar palabras reservadas de Java Son case-sensitive (distingue maysculas de minsculas)

Expresin regular de la composicin de un identificador legal: [\w$_]([\w\d$_]*) CONVENCIONES DE CDIGO DE JAVA SUN Sun cre un conjunto de estndares de codificacin para Java, y public estos estndares en un documento titulado Convenciones de cdigo de Java el cual puede ser encontrado en java.sun.com. Las caractersticas que debe de cumplir los identificadores son: Clases e interfaces o La primer letra debe ser mayscula o Utiliza nomenclatura camelCase o Para las clases, los nombres deben de ser sustantivos o Para las interfaces, los nombres deben de ser adjetivos Mtodos o La primer letra debe ser minscula o Utiliza nomenclatura camelCase o Los nombres deben conformarse por el par verbo + sustantivo Variables o La primer letra debe ser minscula o Utiliza nomenclatura camelCase o Es recomendable utilizar nombres con un significado explcito, y en lo posible, cortos Constantes o Todas las letras de cada palabra deben estar en maysculas o Se separa cada palabra con un _

ESTNDARES PARA NOMBRES DE JAVABEANS Al utilizar estndares para nombres, se garantiza que las herramientas puedan reconocer los componentes realizados por cualquier desarrollador. Las caractersticas que debe de cumplir los identificadores son: Atributos

JAVA FUNDAMENTALS PROGRAMMING Ambos (getters y setters) se conforman del prefijo especificado + el nombre del atributo con su primer letra en mayscula o Getters Si la propiedad no es de tipo boolean el prefijo debe ser get Si la propiedad es de tipo boolean el prefijo debe ser is Deben de ser public, no recibir ningn argumento, y devolver un valor del mismo tipo que el setter para la propiedad. o Setters El prefijo debe ser set Deben de ser public, recibir un parmetro del mismo tipo que la propiedad, y devolver void Listeners o Los mtodos que agreguen un listener deben de comenzar con el prefijo add o Los mtodos que quiten un listener deben de comenzar con el prefijo remove o El tipo del listener a agregar/quitar debe de ser pasado como argumento o Deben de terminar con el sufijo Listener Archivos de cdigo fuente o Solo puede haber una clase public por cada archivo o Los comentarios pueden aparecer en cualquier lnea o Si existe una clase public, el nombre de la misma debe corresponderse con el nombre del archivo o Si la clase pertenece a un package, esta sentencia debe ser incluida como primera lnea o Si hay import, estos deben de ser incluidos entre la declaracin del package y de la clase (class) o Los import y package aplican a todas las clases dentro del archivo o Un archivo puede tener ms de una clase, siempre que esta no sea public o Los archivos que no tengan una clase public pueden contener cualquier nombre o

DECLARACIONES DE CLASES Y MODIFICADORES DE ACCESOEl acceso significa visibilidad. Dependiendo de los modificadores aplicados a la clase, atributos, o propiedades, ser que estos podrn ser accedidos o no por otros. Modificadores de acceso o public o prvate o protected o Default (package). Si no se especifica un modificador, este es el que toma por defecto Modificadores de no acceso o strictpf o final

12


JAVA FUNDAMENTALS PROGRAMMING o abstract

MODIFICADORES DE ACCESO A CLASES package (default) Nivel de visibilidad: clase visible para todas las clases que se encuentren dentro del mismo package. Este no debe especificarse (modificador por defecto).

public Nivel de visibilidad: clase visible para todas las clases de todos los package. Para especificar este modificador se antepone a la palabra clave class, la palabra public. De todas maneras, si la clase es utilizada por otra clase que no se encuentra en el mismo package, es necesario realizar el import de la misma. MODIFICADORES DE NO ACCESO Estos modificadores pueden combinarse con aquellos que si modifican el acceso. strictpf No es necesario saber para la certificacin como es que funciona strictpf. Lo nico que es necesario, es saber que: Es una palabra reservada Puede modificar solo clases y mtodos Hacer una clase strictpf significa que todos los mtodos que la conforman cumplen con la norma IEEE 754 para punto flotante

final El modificador final indica que una clase no puede ser heredada o redefinida por una subclase. abstract Caractersticas de una clase abstract: No puede ser instanciada (new), solo puede ser heredada. Si un mtodo de la clase es abstract, esto fuerza a que la clase completa sea abstract. No todos los mtodos de una clase abstract tienen que ser abstractos. Los mtodos abstract no llevan cuerpo (no llevan los caracteres {}). La primer subclase concreta que herede de una clase abstract debe implementar todos los mtodos de la superclase.

abstract y final Es posible combinar estos dos modificadores de no acceso, pero si interpretamos el funcionamiento de cada uno nos dicen que:

JAVA FUNDAMENTALS PROGRAMMING abstract: obliga a que la subclase defina el cuerpo de los mtodos. final: previene que la clase sea heredada o redefinida.

Un modificador se opone al otro, de manera que, aunque no recibamos un error de compilacin, la clase declarada de esta manera es inutilizable.

DECLARACIN DE INTERFACESCuando creamos una interfaz, lo que estamos diciendo es lo que la clase deber de poder hacer, pero no como lo har. Una interfaz tambin es conocida como contrato. Caractersticas de una interfaz: Todos los mtodos de una interfaz son implcitamente public abstract, no es necesario especificarlo en la declaracin del mismo. Todos los atributos de una interfaz son implcitamente constantes (public static final), no es necesario especificarlo en la declaracin del mismo. Todas las variables de una interfaz deben de ser constantes (public static final). Los mtodos de una interfaz no pueden ser: static, final, strictfp ni native. Una interfaz puede heredar (extends) de una o ms interfaces. Una interfaz no puede heredar de otro elemento que no sea una interfaz. Una interfaz no puede implementar (implements) otra interfaz. Una interfaz debe ser declarada con la palabra clave interface. Los tipos de las interfaces pueden ser utilizados polimrficamente. Una interfaz puede ser public o package (valor por defecto). Los mtodos toman como mbito el que contiene la interfaz. Chapter: Utilizando java desde la consola de comandos

IMPORTANTE: cuando se menciona el implcitamente, se refiere a que si no se especifican estos son los modificadores que toma, pero se pueden especificar todos, ninguno, o algunos, siendo declaraciones semejantes, por ejemplo:1. public interface Dibujable { 2. int CONST = 1; 3. public int CONST = 1; 4. public static int CONST = 1; 5. public final int CONST = 1; 6. static int CONST = 1; 7. final int CONST = 1; 8. static final int CONST = 1; 9. public static final int CONST = 1; 10. 11. void doCalculo(); 12. 13. public void doCalculo(); 14. 15. abstract void doCalculo();

14


16. 17. 18. }

public abstract void doCalculo();

DECLARACIN DE MTODOS Y ATRIBUTOSUn mtodo puede contener modificadores de acceso y de no acceso. Adems, posee ms combinaciones que la definicin de clases. Dado que ambos, mtodos y atributos se declaran de manera semejante, se especifican en un mismo apartado. MODIFICADORES DE ACCESO Los modificadores disponibles son: public protected package prvate

Con estos modificadores tenemos dos conceptos que entender: Cuando un mtodo de una clase puede acceder a un miembro de otra clase. Cuando una subclase puede heredar un miembro de su superclase.

El primer caso se da cuando un mtodo de una clase intenta acceder a un mtodo o atributo de otra clase, valindose del operador . para invocar un mtodo, u obtener una variable. El segundo caso se da cuando una clase hereda de otro, permitiendo que la subclase acceda a los mtodos y atributos de la superclase, a travs de la herencia (extends). public Cuando un atributo o mtodo es declarado como public, significa que cualquier clase en cualquier package puede acceder a dicho miembro. private Cuando un atributo o mtodo es declarado como private, solo puede ser referenciado por la misma clase (ni siquiera por una subclase). Incluso si una subclase declarara un atributo o mtodo con el mismo nombre, solo estara generando un nuevo miembro, no sobrescribindolo, como puede llegar a ser malinterpretado. package (default) Cuando un atributo o mtodo es declarado como package, solo puede ser referenciado por cualquier clase que se encuentre dentro del mismo package, por medio de herencia y referencia.

JAVA FUNDAMENTALS PROGRAMMING protected Cuando un atributo o mtodo es declarado como protected, este se comporta de la siguiente manera: Una variable declarada como protected, se comporta como un modificador de tipo package en el paquete donde se encuentra la clase que declar el miembro. Una variable declarada como protected, solo puede ser accedida a travs de la herencia (no referencia), cuando se encuentra fuera del package.

Esto quiere decir que, un miembro declarado como protected es visible para todas las clases dentro del package donde fue declarado (ya sean subclases de la misma o no) a travs de referencia y herencia, y solo disponible a travs de la herencia para las subclases que se encuentran fuera del package. Para el resto de las clases, se comporta como un modificador prvate (no subclases fuera del package de declaracin). MODIFICADORES DE ACCESO EN VARIABLES LOCALES No es posible aplicar ningn modificador de acceso a una variable local. Solo es posible aplicar un modificador de no acceso: final. MODIFICADORES DE NO ACCESO Dentro de los modificadores de no acceso, se agregan varios de los 2 ya conocidos a la lista para modificadores de miembros. MODIFICADOR DE NO ACCESO EN MTODOS FINAL El modificador final fuerza a que un mtodo no pueda ser redefinido por una subclase. MODIFICADOR DE NO ACCESO EN ATRIBUTOS FINAL En el caso de un modificador final para un atributo, pueden darse 2 casos:

Si el atributo es un valor primitivo, impide de que modifique su valor (un valor primitivo es por ejemplo un int). Si el atributo es una referencia, impide que se modifique la referencia, pero no el estado de la misma.

MODIFICADOR DE NO ACCESO EN MTODOS ABSTRACT El modificador abstract en un mtodo indica que el mismo se ha declarado en el contrato, pero no se ha especificado su comportamiento (cuerpo del mtodo). MODIFICADOR DE NO ACCESO EN MTODOS SYNCHRONIZED El modificador sinchronized indica que el mtodo solo puede ser accedido por un Thread a la vez. Este modificador puede utilizarse en conjunto con cualquiera de los 4 modificadores de acceso. MODIFICADOR DE NO ACCESO EN MTODOS NATIVE El modificador native indica que el cdigo es dependiente de la plataforma, generalmente en cdigo C. Solo es necesario saber para la certificacin que un modificador

16


JAVA FUNDAMENTALS PROGRAMMING de no acceso native solo puede ser aplicado a un mtodo. El mtodo debe especificarse como si fuera abstracto (sin los caracteres {}, y directamente con ;) MODIFICADOR DE NO ACCESO EN MTODOS STRICTFP Al igual que para una clase, el modificador de no acceso strictfp indica que los caracteres de punto flotante utilizan la norma IEEE 754. MTODOS CON LISTAS DE ARGUMENTOS VARIABLES A partir de Java 5.0, es posible crear mtodos que reciban una cantidad de argumentos variables.

Pueden ser de tipo primitivo o un objeto. La definicin de var-args se hace: tipoDato nombreVariable. Solo se puede especificar un solo parmetro de tipo var-args en la firma del mtodo. El parmetro var-args debe de ser el ltimo especificado en la firma del mtodo. La sintaxis de estos es: TipoDeDato nombreVariable.

Al llamar a un mtodo sobrecargado o sobre escrito, primero se verifica si la llamada concuerda con algn mtodo que no tenga argumentos variables, si no se encuentra ninguno de estos, se verifica con los mtodos de argumentos variables.1. public class PruebaParametrosVariables { 2. static public void haceAlgo(int val) { 3. System.out.println("Soy haceAlgo con un parmetro int"); 4. } 5. 6. static public void haceAlgo(int val1, int val2) { 7. System.out.println("Soy haceAlgo con dos parmetros int"); 8. } 9. 10. static public void haceAlgo(int... val) { 11. System.out.println("Soy haceAlgo con parmetros variables"); 12. } 13. 14. static public void main(String[] args) { 15. PruebaParametrosVariables.haceAlgo(1); 16. PruebaParametrosVariables.haceAlgo(2, 3); 17. PruebaParametrosVariables.haceAlgo(4, 5, 6); 18. PruebaParametrosVariables.haceAlgo(4, 5, 6, 7); 19. } 20. }

Soy Soy Soy Soy

haceAlgo haceAlgo haceAlgo haceAlgo

con con con con

un parmetro int dos parmetros int parmetros variables parmetros variables

JAVA FUNDAMENTALS PROGRAMMING DECLARACIN DE CONSTRUCTORES En Java, cada vez que un objeto es instanciado, esto se logra a travs de un constructor, el cual fue invocado con un new. Toda clase tiene al menos un constructor. Si este no se especifica, existe un constructor implcito. Si se especifica explcitamente al menos un constructor, el constructor implcito deja de existir. Un constructor se define como un mtodo, con la salvedad de que jams puede devolver ningn parmetro. Puede utilizar cualquiera los modificadores de acceso (public, private, protected, package). El nombre del mtodo debe de ser siempre igual al de la clase. Puede existir ms de un constructor. Esto se logra utilizando la sobrecarga de mtodos. Al igual que no pueden existir dos mtodos iguales, no pueden existir dos constructores iguales. No pueden ser: static, final ni abstract. Pueden contener en su definicin como parmetro cualquier tipo primitivo, objeto, o incluso var-args.

DECLARACIN DE VARIABLESSe dividen en dos grupos:

DECLARACIN DE VARIABLES PRIMITIVAS Y RANGO DE VARIABLES Estas pueden ser declaradas como: Tabla 1 *Tipo byte short Bits 8 16 *Bytes 1 2 Minimum range -128 -32768 Maximum range (2^7)-1 (2^15)-1

Variables de clase (static) Variables de instancia (objeto) Parmetros Variables locales

18


Primitivas: estas pueden ser cualquiera de los tipos contenidos en la tabla 1 Referencias: se utilizan para referenciar un objeto. Estas son declaradas para ser de un tipo especfico, y ese tipo no podr cambiar jams

JAVA FUNDAMENTALS PROGRAMMINGchar int long float double boolean 16 24 32 16 32 2 4 8 4 8 0 -8388608 -2,1E+09 -32768 -2,1E+09 2^16 (2^23)-1 (2^31)-1 (2^15)-1 (2^31)-1

Dependiente de la JVM

*Con conocer el valor de estas dos columnas, es ms que suficiente para deducir el resto.

DECLARACIN DE VARIABLES DE REFERENCIA Estas pueden ser declaradas como: Variables de clase (static) Variables de instancia (objeto) Parmetros Variables locales

Variables de instancia Representan los atributos de una clase. Se definen dentro de la clase, pero fuera de los mtodos, y solo se inicializan cuando el objeto es inicializado. Caractersticas: Pueden utilizar cualquiera de los cuatro modificadores de acceso Pueden ser final, transient, volatile No pueden ser abstract, sinchronized, strictfp, native, static

Variables locales Son variables declaradas dentro de un mtodo. Una variable local puede definirse con el mismo nombre que una variable de instancia. A esto se lo conoce con el nombre de shadowing. Dado un caso de estos (shadowing), si se quisiera referenciar la variable de instancia, se debe utilizar el operador this. Este almacena una referencia al objeto actual. Caractersticas: No son inicializadas por defecto Pueden ser final No pueden ser transient, volatile, abstract, sinchronized, strictfp, native, static (porque se volveran variables de clase)

JAVA FUNDAMENTALS PROGRAMMING DECLARACIN DE ARRAYS Un array es un objeto que almacena multiples variables del mismo tipo, o subclases del mismo. Estos pueden contener tanto variables primitivas como objetos, pero el array, siempre ser almacenado en el heap. Sintaxis: TipoVariable[] NombreVariable De esta manera, al encontrarnos con una declaracin como la anterior, es simple identificar el tipo de dato, en este caso, una referencia a un array de objetos de tipo TipoVariable. Tambin es posible declarar arrays multidimensionales, que no son otra cosa que arrays de arrays. Por cada dimensin, se especifica un par de []. DECLARACIN DE VARIABLES FINAL El declarar una variable con el modificador final hace imposible modificar su valor una vez que esta ha sido inicializada con un valor explcito. En el caso de ser una variable primitiva, su valor no podr modificarse nunca. En el caso de ser una variable de referencia, no se podr modificar la referencia al objeto que contiene, pero si su estado. VARIABLES TRANSIENTSolo es aplicable a variables de instancia. Cuando una variable es marcada como transient, cuando el objeto es serializado, esta variable es excluida.

VARIABLES VOLATILE Cuando una variable es marcada como volatile, le indica a la JVM que cada vez que un thread quiera acceder a su copia local de la variable, deber verificarla con la copia maestra en memoria. VARIABLES Y MTODOS ESTTICOS El modificador static es utilizado para crear variables y mtodos que existirn independientemente de las instancias creadas. Los atributos y mtodos static existen aun antes de la primer inicializacin de un objeto de dicha clase, y solo habr una copia de estos, por ms que no se realice ninguna o n instancias. Elementos que pueden contener este modificador: Mtodos Variables de clase Una clase anidada dentro de otra clase (pero no dentro de un mtodo). Bloques de inicializacin

DECLARACIN DE ENUMERADORES Java permite restringir una variable para que solo tenga un conjunto determinado de elementos (valores predefinidos). Declaracin: enum NombreEnumerador { VALOR1, VALOR2, , VALORn } Referencia: NombreEnumerador.VALOR1 Cada valor de un enumerador es una clase del tipo del NombreEnumerador. Cada enumerador conoce su ndice, de manera que la posicin en que sea declarado el valor si importa.

20


JAVA FUNDAMENTALS PROGRAMMING Declaracin de contructores, mtodos y variables Debido a que los enum son en realidad un tipo especial de clase, estos pueden contener: constructores, mtodos, variables de instancia, y cuerpo constante de clase especfico (constant specific class body). Debes recordar las siguientes caractersticas sobre enum: Nunca puedes invocar un constructor enum directamente. El contructor de enum es invocado automticamente, con los argumentos que defines luego de las constantes. Puedes definir ms de un argumento para el constructor, y puedes sobrecargar los constructores, as como cualquier clase.

El constant specific class body, es una declaracin de lo que a simple vista parece una clase interna. Es utilizado cuando una constante requiere sobrescribir el comportamiento de algn mtodo.

PARADIGMAS DE PROGRAMACINPara aquellos que son iniciados en el tema de la programacin, es bueno tener en cuenta un poco la evolucin en temas de cmo se programa. Desde siempre la programacin fue una serie de algoritmos que resuelven un problema, lo que cambi, fue la manera de agrupar y asociar estos algoritmos. PARADIGMA ESTRUCTURAL Este paradigma busca como objetivo dividir un problema complejo (sistema), en varios problemas menos complejos (funciones). Este es un paradigma que ha ido quedando en desuso con el correr de los tiempos, aunque aquellos que estn dando sus primeros pasos en alguna institucin, puede que lo vean en lenguajes como Pascal o C++. PARADIGMA ORIENTADO A OBJETOS En este paradigma, cada elemento del sistema se divide en objetos. Estos son representaciones de entidades que encontramos en la vida real. Por ejemplo, si estuviramos diseando un sistema para un aeropuerto, sera ms que factible encontrarse con las clases Aeroplano, Pasajero, Capitan. Pero, y la diferencia? En este paradigma, cada entidad es responsable de realizar las acciones que le conciernen, y solo las que le conciernen. Supongamos que estamos diseando un juego, y tenemos un avin, segn los paradigmas hubiramos hecho lo siguiente: Estrucura procedural en lenguaje C

1. 2.

typedef struct Avion {


3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15.

int cantidadPasajerosSoportada; float peso; //... otras propiedades de un avion } Avion_1; public void volar(avion av) { //... codigo } public void aterrizar(avion av) { //...codigo } public main() { volar(Avion_1) aterrizar(Avion_1) 16. }

Estructura orientada a objetos en Java La diferencia ms grande la podemos apreciar al momento de llamar a las acciones de volar y aterrizar. En el modelo estructural se llama a una funcin a la cal se le pasa un avin como argumento, pero en el modelo orientado a objetos, se le dice al propio avin que vuele o aterrice.1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. class Avion { int cantidadPasajerosSoportada; float peso; // ... otras propiedades de un avin public void volar() { // ... Codigo } public void aterrizar() { // ... Codigo } } public class Juego { public static void main(String[] args) { Avion avion_01 = new Avion(); avion_01.volar(); avion_01.aterrizar(); } }

DEFINICIN DE UNA CLASE1. 2. public class Persona { // Atributos

22



3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. }

String nombre; String apellido; int edad; float peso; // Constructores public Persona(String nombre, String apellido) { // Cdigo ... } // Mtodos public void correr() { // Cdigo... } public void caminar() { // Cdigo... } public void hablar() { // Cdigo... }

Bsicamente, una clase contiene estos elementos: Atributos Definen el estado de un objeto Mtodos Definen el comportamiento (pueden ser de clase o de objeto) Constructores Permiten crear objetos

Existen otros elementos que pertenecen a la clase, y no al objeto. Estos contienen el identificador static. Pero no te preocupes, ya los veremos. DIFERENCIA ENTRE CLASE Y OBJETO Una clase representa una especie de molde para cada objeto. Cuando nosotros creamos un objeto, lo hacemos utilizando alguna clase en particular, esto quiere decir que el objeto creado, puede realizar el comportamiento de la clase, y contiene todos sus atributos. Vamos a verlo con un ejemplo ms grfico. Utilicemos la clase Persona que definimos anteriormente. Basandonos en ella, podemos apreciar que cada Persona (clase), tendr ciertas caractersticas (atributos). Por ejemplo, supongamos una persona llamada Gabriel y otra Laura.

JAVA FUNDAMENTALS PROGRAMMING Clase Persona Nombre Apellido Edad Peso Objetos Gabriel Gabriel Mendoza 15 56.3

Laura Laura Rios 38 65.2

Al definir un objeto de tipo Persona estamos diciendole a la JVM que cree una estructura con tales propiedades y tal comportamiento. En el ejemplo anterior, Laura y Gabriel tambin tienen la capacidad de correr(), caminar(), y hablar().

MS CONCEPTOS DE LA POOAl adentrarnos en este nuevo paradigma, no solamente cambia la manera de codificar, sino que se introducen varios conceptos que forman las bases de este, tales como encapsulamiento, polimorfismo y herencia. ENCAPSULAMIENTO Algunos de los beneficios aportados por el paradigma de orientacin a objetos (OO) son: flexibilidad y mantenimiento. Pero para lograr esto, es necesario escribir las clases de una manera en particular. La clave para lograr esto es encapsular la lgica y el estado de la clase para que no pueda ser accedido de forma directa, y dejar de manera publica un set de mtodos para poder interactuar con la clase. Las claves son: Siempre mantener las variables de instancia protegidas (con un modificador de acceso, generalmente public) Crea mtodos pblicos (public) para acceder a las variables de instancia Para los anteriores, utiliza la convencin de nombres de JavaBeans

HERENCIA Cuando utilizamos la herencia, a veces es necesario saber si un objeto pertenece a una clase en concreto. Para realizar esto utilizamos el operador instanceof, este devuelve un boolean, siendo true en caso de que pertenezca a dicha clase, falso en caso contrario. objeto

24


JAVA FUNDAMENTALS PROGRAMMING instanceof clase Es posible crear relaciones de herencia en Java extendiendo una clase. Las dos caractersticas ms comunes para utilizar la herencia son: Para promover la reutilizacin del cdigo Para el uso del polimorfismo

El polimorfismo nos permite tratar una subclase como si fuera una clase del tipo de su superclase. La contrapartida de esto es que solo se podrn llamar a los atributos que se encuentren disponibles para el tipo de clase declarada. Is-A Para el examen es necesario saber: Is-A indica que la clase X es del tipo Y. Esto se logra a travs de extends o implements. Al termino Is-A tambin se lo puede llamar: derived, subclass, inherits, o subtype. A la superclase tambin se la conoce como supeclase

Has-A Indica que una clase A tiene una variable de instancia que contiene una referencia a B. POLIMORFISMO Un objeto es polimrfico cuando cumple con al menos una condicios Is-A. Esto es cierto para todas las clases que no sean de tipo Object, ya que todas heredan de esta. La nica manera de acceder a un objeto es a travs de una variable de referencia. Algunas pautas para recordar de estas: Una variable de referencia puede ser de un solo tipo, y una vez que fue declarada, ese tipo jams puede modificarse. Una referencia es una variable, de manera que puede ser reasignada a otros objetos (a menos que se declare como final). Un tipo de variable de referencia determina los mtodos que pueden ser invocados sobre el objeto que la variable referencia. Una variable de referencia puede tomar como referencia cualquier objeto del mismo tipo, o un subtipo del mismo. Una variable de referencia puede tener como tipo el de una interface. Si es declarada de esta manera, podr contener cualquier clase que implemente la interfaz. El concepto es que solo los mtodos de instancia son invocados dinmicamente. Esto es logrado por la JVM, la cual siempre tiene conocimiento de que tipo de objeto es el que se est tratando, as como su rbol de herencia.

JAVA FUNDAMENTALS PROGRAMMING SOBRE ESCRITURA Cada vez que una clase hereda un mtodo de su superclase, existe la posibilidad de sobrescribir el mtodo (a menos que este haya sido declarado con el modificador de no acceso final). El beneficio de la sobre escritura es la habilidad de definir comportamiento particular para una clase especfica. Caractersticas necesarias para hacer uso de la sobre escritura: La lista de argumentos debe ser exactamente igual que el mtodo a sobrecargar. El valor de retorno debe ser del mismo tipo, o un subtipo. El modificador de acceso no puede ser ms restrictivo que el del mtodo a sobre escribir. El modificador de acceso puede ser menos restrictivo que el mtodo a sobre escribir. Los mtodos de instancia solo pueden ser sobre escritos si es que son heredados por la subclase. El mtodo sobre escrito puede lanzar cualquier excepcin sin verificacin en tiempo de ejecucin, sin importar de las excepciones que hayan sido declaradas en el mtodo de la superclase. El mtodo no deber lanzar excepciones verificadas que son nuevas o amplan a las ya definidas por el mtodo a sobre escribir. El mtodo sobre escrito puede lanzar una cantidad menor de excepciones que las definidas en el mtodo a sobre escribir. No puedes sobre escribir un mtodo que haya sido declarado como final (creo que es la 20 vez que repetimos esto, pero, nunca es suficiente). No es posible sobre escribir un mtodo que haya sido declarado como static. Si un mtodo no puede ser heredado, no puede ser sobre escrito. Chapter: Utilizando java desde la consola de comandos

Invocando la versin de la superclase de un mtodo sobre escrito Tambin es posible valerse del cdigo definido en la superclase. La manera de invocarlo es con la palabra super (esta hace referencia a la superclase).1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. class Generic { public void doSomething() throws Exception { // . . . some code here } } class Specific extends Generic { public void doSomething() { // . . . some code here } } public class Program { static public void main(String[] args) {

26


15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. }

Generic obj1 = new Specific(); Specific obj2 = new Specific(); obj2.doSomething(); obj1.doSomething(); // Se genera un error de compilacin, dado que no // se declaro como recibir la excepcin Exception // El cdigo podra solucionarse con un try-catch try { obj1.doSomething(); } catch (Exception ex) { // . . . some code here } }

SOBRECARGA La sobrecarga de mtodos permite utilizar el mismo nombre de un mtodo, el cual toma una cantidad y/o tipo de parmetros diferentes. Las reglas para la sobrecarga son: Deben de modificarse la lista de parmetros. Pueden modificar el tipo de valor de retorno. Pueden cambiar el modificador de acceso. Pueden declarar excepciones nuevas o ms abarcativas. Pueden ser sobrecargados en la misma clase, o en una subclase.

Bsicamente, un mtodo sobrecargado no es ms que un mtodo completamente diferente, pero que utiliza un nombre que ya existe. Invocacin de mtodos sobrecargados Para invocar un mtodo sobrecargado, es necesario especificar los parmetros del tipo esperado segn el mtodo que queramos invocar.1. public class Something { 2. public void doSomething(int val) { 3. // . . . some code here 4. } 5. 6. public void doSomething(float val) { 7. // . . . some code here 8. } 9. 10. static public void main(String[] args) { 11. Something s1 = new Something(); 12. int valor1 = 1; 13. float valor2 = 2.3; 14. s1.doSomething(valor1); // Se invoca al mtodo doSomething(int val) 15. s1.doSomething(valor2); // Se invoca al mtodo doSomething(float val) 16. s1.doSomething(new Object); //Error de compilacin. No existe ningn 17. // mtodo que reciba como parmetro un tipo Object 18. }


19. }

En el caso de la invocacin con objetos, se vuelve un poco ms complicado.1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. class Generic { } class Specific extends Generic { } public class Program { public void doSomething(Generic obj) { // . . . some code here } public void doSomething(Specific obj) { // . . . some code here } static public void main(String[] args) { Generic obj1 = new Generic(); Specific obj2 = new Specific(); Generic obj3 = new Specific(); Program p = new Program(); p.doSomething(obj1); // Se invoca al mtodo doSomething(Generic obj) p.doSomething(obj2); // Se invoca al mtodo doSomething(Specific obj) p.doSomething(obj3); // Se invoca al mtodo doSomething(Generic obj) }

En el ltimo caso, por ms que obj3 sea de tipo Specific, la referencia contiene un tipo Generic, y es esta la que determina a que mtodo se invoca.

POLIMORFISMO EN SOBRE ESCRITURA Y SOBRECARGA El polimorfismo no determina que mtodo invocar cuando se trata de sobrecarga, pero si cuando se trata de sobre escritura. Tabla de diferenciacin entre sobrecarga y sobre escritura:Sobrecarga de mtodo Parmetros Valor de retorno Excepciones Deben cambiar. Puede cambiar el tipo. Pueden cambiar. Sobre escritura de mtodo No deben cambiar. No puede cambiar, salvo por alguna covariante (subclass). Pueden reducirse o eliminarse. No se pueden lanzar nuevas excepciones u otras ms abarcativas.

28


}

JAVA FUNDAMENTALS PROGRAMMINGModificadores de acceso Invocacin Pueden cambiar El tipo de la determina que invocar. referencia mtodo No pueden ser ms restrictivos (pueden ser menos restrictivos). El tipo del objeto determina que mtodo invocar. Sucede en tiempo de ejecucin.

CASTEO DE VARIABLES DE REFERENCIA En ciertas ocasiones, es necesario utilizar un mtodo de la clase especfica (subclase), pero la referencia es de la superclase. En estos casos se utiliza un casteo denominado downcast. El problema con este tipo de casteos, es que no generar errores en tiempo de compilacin, pero pueden generarlos en tiempo de ejecucin.1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. class Generic { public void doSomething() { // . . . some code here } } class Specific { public void doSomethingMoreSpecific() { // . . . some code here } } public class Program { static public void main(String[] args) { Generic g1 = new Specific(); Generic g2 = new Generic(); g1.doSomething(); g1.doSomethingMoreSpecific(); // Genera un error de compilacin // "cannot find symbol", esto indica que // la clase Generic no contiene un // mtodo doSomethingMoreSpecific Specific s1 = (Specific) g1; s1.doSomethingMoreSpecific(); // En este caso, la instancia es de tipo // Specific, de manera que conoce el // mtodo doSomethingMoreSpecific g2.doSomething(); g2.doSomethingMoreSpecific(); // Genera un error de compilacin // "cannot find symbol", esto indica que // la clase Generic no contiene un // mtodo doSomethingMoreSpecific s1 = (Specific) g2; // Se genera un error en tiempo de ejecucin // "java.lang.ClassCastException" // Para prevenir esto en tiempo de ejecucin, antes de realizar el // downcast verificamos que el objeto sea del tipo a castear if (g2 instanceof Specific) { // Como el objeto no es de tipo Specific, // ni un subtipo del mismo, la sentencia // if resulta false, y no se entra en la // condicin, previniendo el error en


39. 40. 41. 42. 43. 44. 45. 46. }

// tiempo de ejecucin s1 = (Specific) g2; s1.doSomethingMoreSpecific(); // Tambin se puede realizar un casteo directo como el siguiente ((Specific) g2).doSomethingMoreSpecific(); } }

Lo nico que el compilador verifica es que el tipo de la variable con el tipo a castear se encuentren en el mismo rbol de herencia. Lo que si puede generar un error de casteo es al intentar realizar un upcasting.1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. class Generic { } class Specific extends Generic { } class Another { } public class Program { static public void main(String[] args) { Specific sp = new Specific(); Another an = new Another(); Generic s1 = (Generic) sp; Generic an = (Generic) an; // Error de compilacin al intentar realizar // un upcasting "inconvertible types" // El upcasting tambin se puede escribir de la siguiente manera Generic s1 = sp; // Esta sintaxis automticamente est realizando un // upcasting } }

Tambin, puede darse un caso como el planteado a continuacin:1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. interface Doable { void doSomething(); } class Generic implements Doable { public void doSomething() { // . . . some code here } } class Specific extends Generic { }

30



La clase Specific puede ser tanto de tipo: Specific, Generic, o Doable, dado que su superclase la implementa, y ya se hizo cargo de darle un cuerpo a los mtodos definidos en la interfaz.

IMPLEMENTAR (IMPLEMENTS) UNA INTERFAZCuando se implementa una interfaz, lo que se hace es aceptar el contrato provisto por esta, e implementarlo en la clase. Para el compilador, lo nico que requiere es que se le d una implementacin legal al mtodo, pudiendo ser esta un cuerpo vaco por ejemplo ({}). Para que la implementacin de una interfaz sea legal, la primer clase no abstracta del rbol de herencia debe cumplir con las siguientes reglas: Especificar una implementacin concreta para todos los mtodos definidos en el contrato de la interfaz. Seguir todas las reglas para la sobre escritura de mtodos. Declarar sin excepciones controles sobre los mtodos de ejecucin distintos de los declarados por el mtodo de interfaz, o subclases de los declarados por el mtodo de interfaz. Mantener la misma firma del mtodo, y devolver un valor del mismo tipo (o subtipo).

TIPOS DE VALOR DE RETORNO VLIDOSEsta seccin implica dos cosas: Lo que se puede declarar como un valor de retorno. Qu tipo de dato se puede devolver realmente como valor de retorno.

DECLARACIN DE TIPOS DE VALOR DE RETORNO (RETURN TYPES DECLARATION) Esta seccin indica que tipo de valor de retorno puedes escribir en la declaracin del mtodo, dependiendo si se trata de un mtodo: Sobrecargado Sobre escrito Nuevo

TIPOS DE VALOR DE RETORNO EN MTODOS SOBRECARGADOS El tipo de valor de retorno puede ser cualquiera (el mtodo debe calificar para la declaracin de sobrecarga).

JAVA FUNDAMENTALS PROGRAMMING TIPOS DE VALOR DE RETORNO EN MTODOS SOBRE ESCRITOS Se puede especificar el mismo tipo, o un subtipo (sublass), como tipo de valor de retorno (el mtodo debe calificar para la declaracin de sobre escritura). NOTA: esto es posible a partir de Java 5, en versiones anteriores, solo es posible utilizar el mismo tipo. DEVOLVIENDO UN VALOR Solo existen seis reglas: Puedes devolver un null cuando el tipo es un objeto. Un array representa un tipo de dato valido como retorno. En un mtodo con un valor de retorno de tipo primitivo, es posible devolver un tipo de dato de otro tipo, que sea casteado implcitamente al tipo de retorno. Idem anterior con un tipo que puede ser casteado explcitamente (se debe realizar el cast antes de devolver el valor). Si el tipo es void, el mtodo no puede contener ningn return. Si el tipo es un objeto, se puede devolver cualquier objeto que sea del mismo tipo o que pertenezca al rbol de herencia (no superclases ni superiores). Cualquier tipo que pase la condicin instanceof del tipo de valor de retorno es vlido.

CONSTRUCTORES E INSTANCIACINLos objetos son construidos. No es posible construir un nuevo objeto, sin antes invocar el constructor. Los constructores representan bloques de inicializacin, los cuales pueden llegar a ser invocados con el operador new (no es el caso de los bloques de inicializacin estticos). CONCEPTOS BSICOS DE LOS CONSTRUCTORES (CONSTRUCTOR BASICS) Toda clase, incluidas aquellas que sean abstractas, debern de tener un constructor. Pero esto no implica que el programador tenga que especificarlo. LLAMADAS EN CADENA A CONSTRUCTORES (CONSTRUCTOR CHAINING) Suponiendo el siguiente rbol de herencia:

Clase Especifico

Clase Genrico

Clase Objeto

Al invocar la creacin de un objeto de tipo Especifico, el proceso de inicializacin es el siguiente: 1. Se invoca el constructor se Especifico. Este invoca el constructor de Generico (esta invocacin puede ser implcita o explcita).

32


JAVA FUNDAMENTALS PROGRAMMING 2. Se invoca el constructor de Generico. Este invoca el constructor de Objeto (esta invocacin es siempre implcita). 3. Las variables de instancia del objeto Objeto reciben sus valores explcitos. 4. Se ejecuta el constructor de Objeto. 5. Las variables de instancia del objeto Generico reciben sus valores explcitos. 6. Se ejecuta el constructor de Generico. 7. Las variables de instancia del objeto Especifico reciben sus valores por defecto. 8. Se ejecuta el constructor de Especifico. REGLAS DE LOS CONSTRUCTORES (RULES FOR CONSTRUCTORS) Los constructores pueden utilizar cualquier modificador de acceso. El nombre del constructor debe ser igual al de la clase. Los constructores no deben de tener un valor de retorno. Es legal tener un mtodo que tenga el mismo nombre que la clase. Siempre que este tenga un valor de retorno, es un mtodo. Si no se especifica explcitamente un constructor en la clase, implcitamente se genera un constructor que no recibe parmetros. Si se especifica al menos un constructor, el constructor implcito no ser generado, de manera que si es necesario un constructor con argumentos, y el por defecto, es necesario especificarlo explcitamente. Todos los constructores tienen en la primer lnea, una llamada a un constructor sobrecargado (this()), o una llamada a un constructor de la superclase (super()). La llamada a un constructor de la superclase puede ser con o sin argumentos. Un constructor sin argumentos no es necesariamente un constructor por defecto (este es el que especifica el compilador, en caso de no declarar explcitamente ningn constructor). No es posible acceder a una variable de instancia, o mtodo de instancia, hasta que se ejecute el constructor de la superclase. Solo variables y/o mtodos estticos pueden ser llamados al invocar un constructor mediante this() o super(). Las clases abstractas tambin tienen constructores, y estos son ejecutados cuando se instancie una subclase. Las interfaces no tienen constructores. Las interfaces no forman parte del rbol de herencia. La nica manera de invocar un constructor es desde otro constructor.

DETERMINAR CUNDO SE CREAR EL CONSTRUCTOR POR DEFECTO El constructor por defecto ser creado por el compilador, siempre que no se haya declarado ningn constructor en la clase.

JAVA FUNDAMENTALS PROGRAMMING COMO ES EL CONSTRUCTOR POR DEFECTO? Tiene el mismo modificador de acceso que la clase. No recibe ningn argumento (no tiene parmetros en su definicin). Llama al constructor de la superclase sin argumentos.

QU PASA SI EL CONSTRUCTOR DE LA SUPERCLASE REQUIERE ARGUMENTOS? Es necesario crear explcitamente los constructores en la clase, y dentro de la implementacin de estos, llamar al constructor de la superclase pasando los argumentos necesarios.

SOBRECARGA DE CONSTRUCTORES Simplemente se comporta al igual que los mtodos. Para sobrecargar un constructor basta con declarar varios de estos con diferentes parmetros.

Regla absoluta de los constructores. La primer lnea de estos deber ser una llamada a super() o this() (pueden contener parmetros en la llamada, siempre que la llamada no la realice el compilador).

MTODOS Y VARIABLES ESTTICOS Todos los mtodos y atributos declarados con el modificador de no acceso static pertenecen a la clase y no al objeto (instancia de la clase). Para saber cundo debemos deberamos de crear un atributo o mtodo esttico, simplemente necesitamos saber si este requiere o no acceder a algn atributo de la clase (en el caso de los mtodos), o si debe ser un valor compartido para todos los objetos (en el caso de los atributos). Caractersticas de los atributos y mtodos estticos: No es necesario inicializar ningn objeto para poder acceder a estos. Los atributos estticos son compartidos por todos los objetos (en realidad son de la clase, y dado que el objeto pertenece a dicha clase, tambin tiene acceso a los atributos y mtodos de esta). Las variables estticas tienen la misma inicializacin por defecto que las variables de clase.

34


Alguno de los constructores de la clase deber de llamar a super(), y verificar que todos los dems constructores terminen yendo al que realiza dicha llamada.

JAVA FUNDAMENTALS PROGRAMMING Un mtodo esttico no puede acceder a ningn miembro no esttico (main es esttico!). No existe la sobre escritura (overriding) de mtodos estticos, pero si la sobrecarga (overloading).

ACCEDIENDO A MTODOS Y VARIABLES ESTTICAS Dado que podemos acceder a miembros estticos sin siquiera haber instanciado una clase, para referenciarlos, utilizamos el nombre de la clase con el . para acceder.

En caso de utilizar un identificador que no sea el nombre de la clase (una variable de referencia), se accede a los miembros estticos del tipo declarado de la referencia (no el tipo real contenido).

VALORES LITERALES PARA TODOS LOS TIPOS PRIMITIVOSUn valor literal es simplemente una manera de representar el tipo de dato primitivo. INTEGER Hay tres maneras de representar un nmero entero en Java Decimal (base 10) Hexadecimal (base 16) Octal (base 8)

LITERALES DECIMAL Simplemente es escribir el nmero sin ningn prefijo. LITERALES OCTAL Se antepone al nmero que deseamos escribir el 0. Para formar el 9 (en decimal) se escribe 011 (en octal) LITERAL HEXADECIMAL Los nmero hexadecimales son construidos utilizando valores numricos y alfabticos, siendo el orden el siguiente: 0 1 2 3 4 5 6 7 8 9 A B C D E F NOTA: en los valores exadecimales, las letras pueden ir tanto en maysculas como en minsculas. Se antepone el 0x para identificar un valor hexadecimal. PUNTO FLOTANTE Se utiliza el . como separador de decimales. Por defecto un literal de punto flotante es interpretado como de tipo double. Para que sea interpretado como un float se debe agregar la F al final del literal (12.35F).

JAVA FUNDAMENTALS PROGRAMMING Idem. con la D para que se interprete como un double, aunque no es necesario, dado que es el tipo que se le da por defecto.

BOOLEANOS Solo pueden ser true o false. CARACTERES Se escriben entre (comillas simples). Un carcter es un int sin signo. Es legal asignarle un valor numrico a un caracter. Si el rango es mayor a un integer, o es negativo, no da error, pero es necesario castearlo para impedir la perdida de datos (loss of precision). Para especificar caracteres con un significado especial (salto de lnea, tabulaciones, etc.) se utiliza la \ seguido de un identificador (u para Unicode, n para salto de lnea, t para tabulador).

STRINGS Es una representacin de un objeto String. Se escriben entre (comillas dobles). Representan un objeto, pero se pueden escribir como literales.

Recordemos que una variable puede contener una de dos cosas: El valor del dato. La posicin de memoria donde se encuentra el objeto (puntero). o Puede contener un valor null, que indica que no apunta a ninguna posicin.

ASIGNACIN DE VALORES PRIMITIVOS Se utiliza el operador =. Simplemente evala la expresin y/o literal que se encuentre del lado derecho, y asigna el resultado a la variable especificada en el lado izquierdo:

1. 2. 3.

int a = 1; int b = 2 * a; int c = a / b;

36


OPERADORES DE ASIGNACIN


Si se utiliza simplemente un literal del lado derecho del =, este puede ser casteado al valor de la variable, siempre que sea posible.

CASTEO DE PRIMITIVAS El casteo puede ser implcito o explcito. Un casteo implcito significa que no es necesario escribir ningn cdigo, la conversin se efecta automticamente. Un casteo explcito, por el contrario, requiere de una codificacin.

Las reglas son simples: Si la variable a asignar es de menor o igual tamao a la variable donde ser asignada, se produce un casteo implcito. Si la variable a asignar es de mayor tamao a la variable donde ser asignada, se debe realizar un casteo explcito, o de lo contrario, se generar un error de compilacin.

TABLA DE CASTEOS IMPLCITOS PARA PRIMITIVAS La siguiente tabla indica la posicin de variables primitivas, y cules de ellas puede contener. La interpretacin es: una variable siempre puede contener todas las variables desde su posicin (columna 1), hasta las inferiores, pero nunca superiores. Para ello es necesario un casteo explcito.

Posicin 1 2 3 4 5 6 7

Tipo de dato Byte Short Char Int Long Float Double

Puede contener Posicin actual + anteriores. Posicin actual + anteriores. Posicin actual Posicin actual + anteriores. Posicin actual + anteriores. Posicin actual + anteriores. Posicin actual + anteriores.

JAVA FUNDAMENTALS PROGRAMMING El tipo de dato boolean solo puede contener su mismo tipo. Para darles un ejemplo, una variable de tipo int puede contener un int, char, short o byte.

ASIGNACIN DE NMEROS CON PUNTO FLOTANTE Todo nmero de punto flotante es implcitamente de tipo double.

ASIGNACIN DE UN LITERAL QUE ES MS GRANDE QUE LA VARIABLE En el caso de que la primitiva sea ms grande que el valor mximo permitido, existen dos alternativas: Si el resultado es casteado, se trunca la variable, y esta es almacenada con xito. Si el resultado no es casteado, se genera un error de compilacin Error. Possible loss of precision.

Cuando se trunca una variable, simplemente se eliminan las posiciones extra a la izquierda, siendo por ejemplo: int 128 equivale a 00000000 00000000 00000000 10000000, cuando casteamos a byte, nos queda 10000000 (el resto de la izquierda es eliminado). Los operadores +=, -=, *=, /= realizan un casteo implcito. ASIGNAR UNA VARIABLE PRIMITIVA A OTRA VARIABLE PRIMITIVA Cuando asignamos una variable primitiva a otra variable primitiva, simplemente se copia el valor de esta, quedando ambas como equivalentes, pero totalmente independientes. Esto quiere decir que si modificamos una, la otra no se ver afectada. MBITO DE LAS VARIABLES (SCOPE) Bsicamente, el mbito indica por cunto tiempo la variable existir. Existen cuatro tipos diferentes de mbitos: Variables estticas: Son creadas cuando la clase es cargada, y existirn mientras que la clase siga cargada en la JVM. Variables de instancia: Son creadas cada vez que una nueva instancia es inicializada, y existirn mientras que la instancia exista. Variables locales: Estas existirn durante el tiempo que el mtodo permanece en el stack. Variables de bloque: Estas existirn mientras que se est ejecutando el bloque de cdigo.

1. 2.

public class AlgunaClase { private static int valorEstatico;

38



3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. }

public static int getValorEstatico() { return valorEstatico; } private int valorInstancia; public AlgunaClase() { valorInstancia = 0; } public void setValorInstancia(int valor) { valorInstancia = valor; } public int getValorInstancia() { return valorInstancia; } public void otroMetodo(int valor) { valor++; for (int x = 0; x < 100; x++) { // Cdigo... } }

ERRORES MS COMUNES CON PROBLEMAS DE SCOPE Intentar acceder a un variable de instancia desde un contexto esttico. Intentar acceder a una variable local desde un mtodo anidado (un mtodo que llama a otro, y el segundo utiliza una variable local del primero). Intentar utilizar una variable de bloque, luego de haber concluido la ejecucin del bloque.

UTILIZAR UNA VARIABLE O ARRAY QUE NO HA SIDO INICIALIZADO NI ASIGNADO Java permite inicializar una variable declarada o dejarla sin inicializar. Cuando intentemos utilizar dicha variable (en el caso de no haberla inicializado), podemos encontrarnos con diferentes comportamientos dependiendo del tipo de variable o array con que estemos trabajando, as como, el mbito de la variable. VARIABLES DE INSTANCIA DE TIPOS PRIMITIVOS Y OBJETOS Las variables de instancia son inicializadas a un valor por defecto. La siguiente tabla muestra los valores de inicializacin segn el tipo:Tipo de variable Valor por defecto

JAVA FUNDAMENTALS PROGRAMMINGReferencia a objeto byte, short, int, long float, double boolean char null (no referencia a ningn objeto) 0 0.0 false \u0000

VARIABLES DE INSTANCIA DE TIPO ARRAY Cuando se declara una variable de este tipo, pueden darse dos casos de no inicializacin: Si no se inicializa el array, el mismo contendr una referencia a null (al fin y al cabo, un array es un objeto). Si se inicializa el array, pero a sus elementos no se le asignan valores (int[] a = new int[10]), los elementos del array sern inicializados al valor por defecto del tipo del array (en el caso del ejemplo 0).

VARIABLES PRIMITIVAS LOCALES Y OBJETOS Las variables locales son aquellas que hayan sido declaradas dentro de un mtodo, y esto incluye a los parmetros del mismo. En este caso, el trmino automtico indica variable local, no que se inicializa automticamente. Variables primitivas locales Estas variables debern de ser inicializadas siempre antes de utilizarlas, de lo contrario, obtendremos un error en tiempo de compilacin Variable X may not have been initialized. Otro problema que puede llegar a surgir es el de inicializar la variable dentro de un bucle condicional. El compilador detecta esto, e indica con un error de compilacin el posible problema Variable X might not have been initialized. Variables de referencia locales Si se declara una variable de referencia local, pero no se inicializa, por ms que luego solo se haga una verificacin de si vale null, esto arroja un error. Esto se debe a que null, tambin es un valor. Variables de array locales Se comportan igual que las referencia a objetos locales, con la salvedad de que si una variable array a sido inicializada, y se le asigna un conjunto de elementos de tipo X, pero no los valores, estos siempre sern inicializados al valor por defecto del tipo, sin importar el mbito de la variable.

40


JAVA FUNDAMENTALS PROGRAMMING ENVO DE VARIABLES A MTODOS Los mtodos pueden ser declarados con parmetros de tipo primitivos y/o referencias a objetos. Es importante conocer el efecto de modificar cualquiera de los dos tipos de parmetro, y los efectos de realizar esto. Envo de variables de referencia Cuando se pasa como argumento una referencia a un mtodo, lo que se est enviando es la direccin de memoria a la que apunta la referencia, y no el objeto en s. Esto quiere decir que ambas variables estarn referenciando al mismo objeto en el heap, de manera que si el objeto es modificado dentro del mtodo, se ver afectado fuera de este tambin. Java utiliza la semntica de paso por valor? Si. A pesar de que pareciera que no, dado lo anterior, en realidad se est pasando el valor contenido por la variable. Ahora, que este valor sea un tipo primitivo o una referencia no importa, al pasar un argumento, el parmetro se carga con una copia bit a bit. Otra consideracin es que el parmetro no puede modificar el valor del argumento, lo que es diferente de modificar el estado del objeto al que apuntan ambos. DECLARACIN, CONSTRUCCIN E INICIALIZACIN DE ARRAYS En Java, un array es un objeto que almacena mltiples variables del mismo tipo. Estos pueden contener tanto tipos primitivos como referencias a objetos, pero el array en si mismo siempre ser un objeto en el heap. Para utilizar los arrays, es necesario saber tres cosas: Como crear una variable que referencie a un array (declaracin). Como crear un objeto de tipo array (construccin). Como completar el array con elementos (inicializacin).

Declaracin de un array Los array son declarados especificando el tipo de dato que contendr el array seguido de []. Tambin se pueden especificar varias dimensiones de arrays, siendo cada par de [] equivalentes a una dimensin.1. 2. 3. 4. 5. int[] array_1; // Un array con primitivos int[][] array_2; // Un array con primitivos de 2 dimensiones (tambin // conocido como matriz) int[][][] array_3;

Java Basico 1

Documents

Transcript of Java Basico 1