Seccion Fundamentos SCJP

SCJP – Fundamentos * Extraído desde: http://www.sun.com/training/catalog/courses/CX-310-055.xml

Fundamentos Elementos de un archivo fuente Declaración de paquete (única) Instrucciones “import” (cero o mas) Definiciones de clase (cero o mas, solo una publica –incluso si es interface- ) El nombre de la clase publica debe ser el mismo del archivo (y .java) Sin embargo un archivo fuente puede no tener una clase publica, ó incluso nada. La importación de paquetes no es recursiva (no importa sub paquetes) Los comentarios pueden estar en cualquier lugar, pero no pueden ser anidados.

Identificadores Un identificador valido en Java comienza con una letra (unicode), “$” o “_”, después cualquier combinación de letras, “$”, “_” o dígitos Los caracteres unicote pueden estar en cualquier parte del codigo fuente, las siguientes instrucciones son todas validas: ch\u0061r a = 'a'; char \u0062 = 'b'; char c = '\u0063'; Todos los tipos de datos enteros son con signo excepto “char”

Arreglos Los arreglos son objetos y para crearlo hay que seguir estos pasos: Declarados: int[] a; String b[]; Object []c; (no se especifica el tamaño) Asignados o construidos: a = new int[10]; c = new String[arraysize] (el argumento “arraysize” es de tipo entero) Inicializados: for (int i = 0; i < a.length; a[i++] = 0) Lo anterior se puede hace en un solo paso: int a[] = { 1, 2, 3 }; ó int a[] = new int[] { 1, 2, 3 }; (En ninguna caso se indica el tamaño, se determina a través del numero de elementos “literales”)

Arreglos El tamaño de un arreglo no puede ser cambiado Arreglos “anónimos” pueden ser creados así: new int[] {1,2,3} ó new int[10] El índice de un arreglo comienza con 0 y la cantidad de elementos se determina con el atributo length (el ultimo elemento es igual arreglo.length - 1). Pueden ser creados arreglos con cero elementos El “Garbage Collection” es un mecanismo a través del cual se recupera memoria desde objetos “sin uso”, aumentando la memoria disponible para nuevos objetos.

Recolección de Basura Un objeto “sin uso” es aquel que no puede ser referenciado por ninguna parte “activa” del programa. El “Garbage Collection” corre como un Thread de baja prioridad. No es posible forzar el Garbage Collection, solo se puede “sugerir” su ejecución con System.gc() No hay garantía sobre la recolección y ejecución de los “finalizadores” de los objeto. GC no se ejecutara si en la ejecución del programa no existen “garantías”.

Recolección de Basura La memoria ocupada durante la ejecución del programa no será liberada hasta que el programa termine, a excepción de que el sistema operativo lo solicite. Tampoco existen garantías con respecto al orden en que serán recolectados los objetos (elegibles por el GC) Un objeto es elegible para la recolección de basura solo si las referencias desde otros objetos son a su vez también son elegibles para la recolección de basura.

Recolección de Basura Referencias circulares no previenen que los objetos sean recolectados Podemos asignar null a las variables de referencias y ejecutar gc para recolectar el objeto referenciado por la variable, pero si el objeto tiene asignado un Oyente (Listener), este no será recolectado, primero se debe remover el oyente. Todos los objetos tienen un método “finalize”, el cual es heredado desde la clase Object

El método “finalize” El método “finalize” es utilizado para liberar recursos utilizados (posiblemente) por el objeto, el orden en cual es invocado este método no tiene relación con el orden de creación, la firma del método es: protected void finalize() throws Throwable { } El método finalize es ejecutado solo una vez por objeto, si se produce una excepción (en el método), el objeto continuara en estado “elegible”. El método finalize puede ser ejecutado explícitamente pero esto no implica que será recolectado.

El método “finalize” El método finalize puede ser sobrecargado pero solo el método con la firma “original” será invocado por gc. El método finalize no esta “encadenado” implícitamente, por lo que debe invocar al método finalize de la clase padre, pero el compilador no comprobara esto. Se puede ejecutar System.runFinalization() puede ser usado para ejecutar (no debe ser ejecutado antes) los “finalizadores” de los objetos elegibles.

Operadores y Asignaciones Enteros Los enteros dependiendo de la precisión se dividen en los siguientes tipos primarios: byte 8 bits complemento a dos. short 16 bits complemento a dos. int 32 bits complemento a dos. long 64 bits complemento a dos.

Enteros Los enteros por defecto se almacenan internamente como tipo int, que es un valor de 32 bits con signo. Si fuese necesario que un literal se almacenara como long debe añadirse una letra l o L al final del literal. Estos pueden representarse en tres formatos diferentes: decimal (no tiene notación especial) octal (notación: prefijo 0) hexadecimal (notación: prefijo 0x ó 0X) Ejemplo; Decimal: 42, Hexadecimal: 0x2A, Octal: 052

Coma flotante Los reales en coma flotante (números con parte entera y parte decimal), pueden ser de dos tipos: float y double . Los primeros se almacenan en 32 bits y los segundos en 64 bits. La diferencia esta dada por la capacidad de precisión, debido a la mayor cantidad de información que necesitan para representarlos. Por defecto los literales de coma flotante se almacenan en double si fuese necesario expresar un literal como float solo basta poner una f ó F al final del literal.

Lógicos En Java el tipo lógico se ha implementado a través de los literales (y palabras reservadas): true y false .

Caracteres Los caracteres que se refieran a un único carácter unicode se representan entre comillas simples. Adicionalmente Java cuenta con un tipo de dato char (short) para almacenar este tipo de datos. También pueden incluirse caracteres no imprimibles como: \\, \, \b, \r, \f, \t, \n, \’, \”, \udddd, \ddd Ejemplo de formatos de representación de enteros: int i = 18; int j = 022;//Version Octal: dos veces ocho mas dos int k = 0x12;//Version Hex: una vez dieciséis mas dos

Operadores Los operadores prefijos unarios y todos los operadores binarios (excepto el de asignación) son asociados de izquierda a derecha. Todos los operadores unarios (excepto los prefijos), todos los operadores de asignación, y el operador condicional ternario (incluido el de creación de objetos y cast ) son asociados de derecha a izquierda. Las expresiones se analizan de izquierda a derecha, salvo que existan paréntesis. Las reglas de precedencia determinan que operador debe ser aplicado primero entre dos operadores con diferente precedencia.

Ejemplo: Operadores ¿Como será evaluado: 2 + 3 * 4? Será evaluado como 2 + (3 * 4), debido a que * tiene mayor precedencia que +.

Conversiones Java, es un lenguaje fuertemente tipificado, chequea en tiempo de compilación la compatibilidad de tipos. Si un tipo puede ser sustituido por otro. Pero a veces solo es posible hacerlo en tiempo de ejecución. Un tipo de referencia (objeto) solo se encuentra construido en tiempo de ejecución. Si un operador tiene operadores incompatibles (Por ejemplo, la asignación de un doble a un entero) Java demanda la utilización de un cast para indicar explícitamente el tipo de conversión.

Casting... La sintaxis de cast , es la siguiente: (<tipo>) <expresión> En tiempo de ejecución se creara un nuevo valor de <tipo> que “mejor” represente al valor de <expresión>. El moldeo o casting puede ser aplicado a tipos primitivos como a referencias. Obviamente el casting entre referencias y primitivos, no esta permitido.

Casting... Los valores boolean no pueden ser “moldeados” a otro tipo, y viceversa. Moldear a null genera un error de compilación ya que null no es un tipo. Diferencia importante en la asignación: Los tipos primitivos son chequeados en tiempo de compilación. Los tipos de referencia son chequeados en tiempo de ejecución. Las conversiones que involucran moldeos se llaman conversiones explicitas Bajo ciertas condiciones el compilador realiza conversiones implícitas , por ejemplo cuando un char es asignado a un int

Estrechamiento y Ensanchamiento Para un tipo de dato primitivo, un valor mas “estrecho” puede ser convertido a un valor mas “ancho” sin perder información. Esto se conoce como “Conversión de ensanchamiento de primitivos”. La conversión al próximo valor más “ancho” esta resumida en la siguiente figura. Las conversiones son transitivas.

Promociones Numéricas Los operadores numéricos solo permiten operandos de ciertos tipos. La promoción numérica es implícitamente aplicada a los operandos para convertirlos en tipos permisibles. Existe una distinción importante entre la promoción numérica unaria y binaria.

Promoción Numérica Unaria Si el operando del operador es menor a int , automáticamente será convertido a int . En otras palabras los tipos byte, short, char son convertidos a enteros a través de una conversión de ensanchamiento de primitivos. Asignar un resultado int a una variable de estos tipos requiere una conversión explicita.

Contextos de Aplicación Operando de un operador aritmético unario como + y/o – Operando de un operador de complemento (~) Durante la creación de un arreglo, por ejemplo new int[20], donde la dimensión debe estar expresada en entero y por lo tanto debe ser evaluada En el índice de un arreglo (Idem punto anterior) Operandos individuales de los operadores shift <<, >> y >>>

Ejemplos: byte b = 3; // Asignación valida, literal “3” se encuentra en rango. 128 seria invalido. b = (byte) –b; // Asignación valida, se requiere conversión explicita a byte ya que se produjo la promoción automática del operador unario -.

Promoción Numérica Binaria La promoción numérica binaria implícita se aplica para lograr un apropiado ensanchamiento (primitivo) entre un par de operandos, siendo el de tipo mayor el mandatario para el ensanchamiento. Pero, siempre mayor a int . byte, short, char, siempre son convertidos a int .

Contextos de Aplicación La promoción numérica binaria es aplicada en los siguientes contextos: Operandos de operadores aritméticos: *, /, %, + y – Operandos de operadores relacionales: <, <=, > y >= Operandos de operadores de igualdad numérica: == y != Operandos de operadores de bits (bitwise) &, ^ y |

Contextos de Conversión Las conversiones de tipo pueden ocurrir en los siguientes contextos: Asignaciones, que involucren tipos de datos primitivos y referencias. Invocaciones de métodos, que involucren parámetros de tipo primitivo y de tipo referencia Evaluación aritmética de expresiones que involucren tipos numéricos Concatenación de cadenas que involucren a objetos de la clase String y otros tipos de datos

Notas de Conversión Tanto los operadores unarios como binarios, independiente del tipo de los operandos sobre los que se realice la operación, devuelven un int para todos los casos, excepto que uno de los operandos sea un long, en cuyo caso el valor devuelto será un long. Esto último se aplica sobre números en punto flotante, pero el resultado será de tipo float si ambos operandos son de este tipo y en caso contrario el tipo será double .

Operador de Asignación Simple : = Las asignación tiene la siguiente sintaxis: <variable> = <expresión> El destino <variable> y la fuente <expresión> deben ser de tipo compatible. <variable> debe haber sido declarada. Asignación múltiple: k = j =10, es interpretado como (k = (j = 10)), ya que el operador de asignación tiene asociatividad a la derecha. Esto también se aplica a tipos referencia.

Asignación de Conversiones Numéricas El destino y la fuente deben ser del mismo tipo en la asignación. Si el ensanchamiento de un primitivo es permisible, esta se realiza de manera implícita. Valores enteros ensanchados a punto flotante puede resultar en una perdida de precisión. NO confundir la magnitud (cuan grande puede ser un valor) con la precisión (la cantidad de dígitos en un numero)

Ejemplo: long bigInteger = 412343214321543L; float realNo = bigInteger; Se realiza el ensanchamiento pero se pierde precisión.

Operadores Aritméticos Los operadores aritméticos son usados para construir expresiones matemáticas algebraicas. Los operandos son de tipo numérico, pero el operador + puede actuar concatenando cadenas si uno de sus operando es de tipo String (cadena). La tabla siguiente muestra la precedencia de los operadores aritméticos: Unarios + (Adición) - (Sustracción) Binarios * (Multiplicación) / (División) % (Modulo) + (Adición) - (Sustracción)

Notas Operadores Aritméticos La división por cero solo lanza una excepción para tipos int y float long y double, se obtendrá como resultado NaN, POSITIVE_INFINITY ó NEVATIVE_INFINITY Cálculos en punto flotante pueden producir NaN (la raíz cuadrada de un numero negativo) ó Infinito (División por cero) No comparar x==Float.NaN ya que no funcionara, Usa la clase“Wrapper” ya que dispone de un método Float.IsNaN(x) para realizar esta comprobación correctamente. Pero (X == Double.POSITIVE_INFINITY) OK

Ejemplo El operador “+” se encuentra “sobrecargado para concatenar String, teniendo mayor precedencia el operador “+” para enteros, ejemplo: System.out.println(1 + 2 + “3”); // resultado : 33

Operadores Aritméticos de Asignación Este operador de asignación extendido tiene la siguiente sintaxis: <variable> <op>= <expresión> y tiene el siguiente sentido semántico: <variable> = (<tipo>) ( <variable> <op> (<expresión>) ) Es importante considerar esto a la hora de evaluar expresiones. El tipo de <variable> es igual a <tipo> y la <variable> es evaluada solo una vez. <op> puede ser cualquier operador valido (*,/,%,+,-)

Ejemplo Ejemplo: Dado T igual al tipo de x. a es una expresión. x *= a; es igual a x = (T) (x * (a)); Nota: No se puede utilizar estos operadores junto con la declaración int x += 1;

Operador Binario de Concatenación El operador binario + esta sobrecargado de manera que detecta si alguno de sus operandos es un String, de manera de realizar la conversión del otro operando a String y realizar la concatenación. Valores como true, false y null son representados como String de manera literal. Ejemplo: String s = “Hola ” + 4 Resultado: “Hola 4”

Operadores de Incremento y Decremento Los operadores de incremento (++) y decremento (--) tienen dos comportamientos: prefijo y postfijo. ++i, primero suma 1 a i, después usa este nuevo valor de i como valor en la expresión. i++, primero usa el valor de i en la expresión, después suma 1 a i. Lo mismo aplica al operador --. Notas : Estos operadores pueden ser aplicados a operandos de tipo char, byte y short. En estos casos se realiza la promoción numérica binaria y una conversión de estrechamiento implícita, para evitar el efecto secundario de modificar el valor del operando.

Ejemplo int x=0; x=x++; ¿Resultado? x = ¿?;

Expresiones Booleanas Las expresiones booleanas tienen tipos de datos boolean, y solo pueden ser evaluadas verdadero o falso. Expresiones booleanas pueden ser utilizadas como condicionantes en instrucciones de control de flujo. Expresiones booleanas pueden ser formadas usando: Operadores relacionales Operadores de igualdad Operadores lógicos Operadores condicionales Operadores de asignación

Operadores Relacionales <, <=, >, >= Dado a y b que representan expresiones de valores numéricos, el operador relacional (en este caso comparación) se definen como muestra la siguiente tabla: a < b ¿a es menor a b? a <= b ¿a es menor o igual a b? a > b ¿a es mayor a b? a >= b ¿a es mayor o igual a b? Todos los operadores relacionales son binarios y sus operandos son expresiones numéricas. La promoción numérica binaria es aplicada a los operandos.

Operadores Relacionales Evaluación En la evaluación resulta un valor lógico. Un operador relacional tiene menor precedencia que un operador aritmético, pero mayor precedencia que un operador de asignación. Tienen asociatividad a la izquierda.

Igualdad (primitivos ==, !=) Dado a y b que representan valores de tipo de datos primitivos, la igualdad de los valores según el operador se definen como muestran: a == b ¿a es igual a b?, ¿tienen el mismo valor primitivo? a != b ¿a es distinto a b?, ¿tienen distinto valor primitivo? Los operadores de igualdad == y != pueden ser usados para comparar valores de tipo de datos primitivos incluyendo a los boolean. La promoción numérica binaria es aplicada a los operandos no lógicos.

Consideraciones Precaución con la comparación de números en coma flotante, ya que ciertos valores solo pueden ser almacenados como una aproximación finita de bits. Ejemplo: (1.0 – 2.0/3.0 == 1.0/3.0) retorna falso, aunque matemáticamente sea verdadero. Tienen asociatividad a la izquierda. Pueden ser utilizados valores lógicos como operandos, pero en este caso ambos operandos deben ser del mismo tipo.

Igualdad de referencias de objetos Dado r y s variables de referencia, la igualdad esta dada por: r == s ¿a es igual a b?, ¿tienen el mismo valor de referencia? r != s ¿a es distinto a b?, ¿tienen distinto valor de referencia? Los operadores de igualdad == y != pueden ser usados para comparar valores de referencia de manera de saber si representan al mismo objeto. No se considera el estado de los objetos.

Condiciones Los operandos deben ser de un tipo compatible. Esto significa si es posible moldear uno con el otro, de otra manera se genera un error de compilación. Se puede asignar null a una referencia y por lo tanto también puede utilizarse null como operando.

Consideraciones La clase Object provee el método lógico equals(Object obj) el cual puede ser sobrescrito para dar un sentido semántico correcto a una comparación de igualdad (o desigualdad). La implementación por defecto de este método utiliza el operador == Ciertas clases del API estándar de Java sobrescriben el método equals como por ejemplo: String, BitSet, Date, etc.

Operadores Lógicos Los operadores lógicos lógicos pueden ser aplicados a operandos lógicos, retornan un nuevo valor lógico. Los operadores ^, & y | pueden ser aplicados a enteros para realizar operaciones de complemento lógico. Dado x e y que representan expresiones booleanas, los operadores lógicos lógicos se definen en la tabla siguiente: Todos los operadores lógicos son binarios, ha excepción el operador de negación.

Operadores extendidos Asignación booleana lógica &=, ^=, |= El operando de la izquierda debe ser una variable de tipo boolean. A la derecha debe ser una expresión booleana. Estos operadores son definidos en la tabla siguiente:

Operadores condicionales: &&, || Los operadores condicionales son muy parecidos a los operadores lógicos lógicos, excepto que en la evaluación se produce un corto circuito . Ambos operadores condicionales son binarios y contrario a los operadores lógicos, solo pueden ser aplicados a expresiones booleanas. No existen operadores de asignación extendidos para los operadores condicionales.

Operadores condicionales: &&, || Dado x e y expresiones de valores lógicos, los operadores condicionales se definen según la tabla siguiente:

Corto Circuito en la Evaluación En la evaluación de expresiones que involucren operadores condicionales AND ó OR, el operando de la izquierda es evaluado primero que el de la derecha y se produce un corto circuito en la evaluación. Es decir si la evaluación puede ser determinada por el operando de la izquierda, el operando de la derecha no es evaluado.

Ejemplo boolean b = (4==2) && (1 < 4) //false En este caso como 4==2 es falso, y el operador es &&, no es necesario seguir evaluando la expresión ya que con certeza el resultado será falso. Lo mismo ocurre con el operador || (OR). Los operadores condicionales tienen menor precedencia que cualquier operador matemático o relacional, pero mayor que el de asignación.

Representación de Enteros El tipo de datos entero en Java representa a valores positivos y negativos. Java usa un complemento a dos para representar enteros. Los Bits en un valor entero usualmente son ordenados desde la derecha a izquierda. Comienzan con el bit 0 (mas a la derecha) El numero del bit mas significativo (es el bit de signo , el mas a la izquierda), cuando se aplican operadores a nivel de bits depende del tipo de entero es: 31 para byte, short, char e int 61 para long

Representación Binaria Sumando 1 al valor máximo de int 2147483647 da como resultado el valor mínimo de int -2147483648. Esto demuestra que no existe overflow ó underflow en los enteros. Convirtiendo números binarios a decimales: 101001 = 1*2^5 + 0*2^4 + 1*2^3 + 0*2^2 + 0*2^1 + 1*2^0 = 32 + 0 + 8 + 0 + 0 +1 = 41 A decimal: 41:2=20; 20:2=10; 10:2=5; 5:2=2; 2:2=1 1 0 0 1 0 1 101001

Calculando el Complemento a dos Dado un valor byte positivo 41, entonces la representación binaria es -41 y puede ser determinada de la siguiente manera: De manera similar dado -41, entonces la representación binaria es 41 y puede ser determinada de la siguiente manera:

Operadores a nivel de bits Los operadores a nivel de bits binario manipulan cada valor individual correspondiente en los operandos. La promoción numérica unaria es aplicada al operando del operador unario de complemento ~ La promoción numérica binaria es aplicada a los operandos de los operadores a nivel de bits binarios Ambas promociones dan como resultado un nuevo valor entero, que solo puede ser de tipo int ó long .

Operadores a nivel de bits Ejemplo: char v1 = ')'; // 41 byte v2 = 13; int result; result = ~v1; // -42 result = v1 & v2; // 9 result = v1 | v2; // 45 result = v1 ^ v2; // 36

Operadores extendidos &=, ^=, |= Estos operadores son definidos en la tabla siguiente:

Operadores de desplazamiento Los operadores de desplazamiento binario forman un nuevo valor desplazando bits hacia la izquierda o derecha un numero de veces dado un numero entero. El numero de desplazamientos (distancia) es dado por el operando de la derecha. El valor ha ser desplazado será el operando a la izquierda. Una promoción numérica unaria es aplicada de manera individual a cada operando. El valor retornado es promovido al tipo de dato del operador de la izquierda. El valor del operando (izquierda) no es alterado.

Rangos de desplazamiento El numero de bits desplazados siempre esta en el rango: Modulo de 32 para valores int Modulo de 64 para valores long Los operadores de desplazamiento de bits se definen la siguiente tabla:

El operador << Los bits son desplazados a la izquierda, y llenando con ceros a la derecha. Ejemplo: int i = 12; int result = i << 4; // 192 El desplazamiento se produce asi: i << 4; = 0000 0000 0000 0000 0000 0000 0000 1100 << 4 = 0000 0000 0000 0000 0000 0000 1100 0000 = 0x000000c0 = 192

Operador << Cada desplazamiento a la izquierda corresponde a la multiplicación del valor por 2 elevado al numero de desplazamientos. En el ejemplo anterior esto equivale a: 12 * 2^4 que es 192. El bit de signo de un byte o short es extendido para llenar los bits superiores cuando el valor es promovido

Ejemplo byte b = -42; // 1101 0110 int result = b << 4; // -672 Los bits del byte una vez convertidos a int, y desplazados 4 lugares: b << 4 = 1111 1111 1111 1111 1111 1111 1101 0110 << 4 = 1111 1111 1111 1111 1111 1101 0110 0000 = -672

Operador >> Todos los bits son desplazados a la derecha, el bit de signo es usado para llenar a la izquierda. Si el operando de la izquierda es positivo, se llenara con 0 a la izquierda. Si el operando de la izquierda es negativo, se llenara con 1 a la derecha. Ejemplo: int i = 12; int result = i >> 2; // 3 El valor de i es desplazado a la derecha llenado con el signo 2 lugares: i >> 2; = 0000 0000 0000 0000 0000 0000 0000 1100 >> 2 = 0000 0000 0000 0000 0000 0000 0000 0011 = 3

Operador >>> Todos los bits son desplazados a la derecha, se rellena con 0 a la izquierda sin importar si el operando es positivo o negativo. Obviamente, para valores positivos el operador >> y >>> son equivalentes. Ejemplo: byte b = -42; // 11010110 int result = b >>> 4; // 268435453 El valor del byte b, después de la promoción a int y llenado con 1 a la izquierda. b >>> 4 = 1111 1111 1111 1111 1111 1111 1101 0110 >>> 4 = 0000 1111 1111 1111 1111 1111 1111 1101 = 268435453

Op. Extendidos >>=, >>=, >>>= Estos operadores son definidos en la tabla siguiente: El resultado de -1 >> 1 es –1, y no 0. Esto difiere de la simple división por 2. Donde se puede pensar que la operación de desplazamiento redondea hacia abajo. El resultado de 1 << 31 será el numero menor que puede ser representado. Los números negativos son representados con la notación complementos a dos.

El operador condicional “? :” ternario: El operador ternario permite expresiones condicionales definidas. Y tiene la siguiente sintaxis: <condición> ? <expresión 1> : <expresión 2> Si la expresión booleana <condición> es evaluada como verdadero, la expresión <expresión 1> es evaluada, si no la expresión <expresión 2> es evaluada. <expresión 1> y <expresión 2> deben ser de tipos compatibles. Ejemplo: boolean bisiesto = false; int diasEnFebrero = bisiesto ? 29 : 28; // 28 Este operador es equivalente a if – else

Otros operadores: new, [], instanceof El operador new es usado para crear objetos, por ejemplo instancias de clases y arreglos. El operador [] es usado para construir y declarar arreglos, y para acceder a elementos para un arreglo. El operador lógico instanceof es utilizado para comprobar el tipo de un objeto. Es un operador binario, el operando de la izquierda (Un objeto) se comprobara si es instancia del operando de la derecha (Una clase).

Ejemplo if (miString instanceof String) Se comprueba el objeto que denota la referencia, por lo tanto si miString==null, no se considera instancia, por lo tanto no hace un chequeo de tipos, si no una comprobación de si un objeto es instancia de una clase determinada o hereda o implementa una interfaz.

Paso de Parámetros Los objetos se comunican a través de mensajes Los mensajes son implementados como un llamado a un método de un objeto Los métodos estáticos pueden ser invocados directamente sobre una clase Los parámetros en la llamada del método proveen un mecanismo para intercambiar información entre el objeto “llamador” y el “llamado”

Sintaxis La sintaxis para llamar un método puede ser cualquiera de estas: <referencia de objeto>.<nombre del método> (<lista actual de parámetros>) <nombre de clase>.<nombre del método estático> (<lista actual de parámetros>) <nombre del método> (<lista de parámetros>)

Paso de Parámetros Si el objeto llamador y el llamado son el mismo, <referencia de objeto> puede ser omitido. El operador punto “.” tiene asociatividad a la izquierda, por ejemplo: unObjeto.hacer1().hacer2().hacer3(); La primera llamada hacer1() retorna un objeto sobre el cual se ejecutara el método hacer2(), y así sucesivamente. Los parámetros actuales son parámetros que serán pasados al método cuando este sea invocado y pueden variar en cada llamada. Las lista de parámetros formales definidos en la definición del método, son locales para el método.

Paso de Parámetros Las listas de parámetros Actual y Formal deben ser compatibles: El numero de parámetros deben ser iguales La correspondencia individual de los parámetros actual y formal deben ser de tipo compatible. En Java todos los parámetros son pasados por valor, sin embargo al pasae una referencia a un objeto podemos realizar cambios en dicha referencia. Un ejemplo de esto son los arreglos (que de hecho son objetos) no podremos realizar cambio al arreglo en si (como asignarle un nuevo arreglo), pero podemos cambiar el valor de alguno de sus elementos.

Pasando valores primitivos Cuando un parámetro actual es una variable de tipo primitivo, el valor de la variable es copiado al parámetro formal en el momento de la invocación. Como el parámetro formal es local en el método, cualquier cambio no se reflejara en el parámetro actual. El parámetro actual puede ser una expresión que puede ser evaluada y el resultado será pasado al método. Conversiones de tipo entre los parámetros actual y formal de tipos de datos primitivos es similar a la conversión de asignación numérica. Conversiones de ensanchamiento son aplicadas implícitamente.

Pasando valores de referencia Si un parámetro actual es una referencia a un objeto, entonces un valor de referencia de un objeto es pasado. En este caso el parámetro actual y formal son como “alias” al mismo objeto. Por lo tanto los cambios realizados dentro del método son reflejados en el objeto una vez finalizado el método. Pero solo es posible cambiar el “estado” del objeto y NO el valor de referencia. Nota: Los arreglos son objetos.

Parámetros formales finales Un parámetro formal puede declararse final anteponiendo la palabra final en la declaración. Un parámetro final, es una variable que no puede ser cambiada. Son constantes que pueden ser utilizadas por razones de rendimiento.

Conversiones “Boxing” Desde el tipo boolean al tipo Boolean Desde el tipo byte al tipo Byte Desde el tipo char al tipo Character Desde el tipo short al tipo Short Desde el tipo int al tipo Integer Desde el tipo long al tipo Long Desde el tipo float al tipo Float Desde el tipo double al tipo Double

Como funciona? Si p es un valor de tipo boolean, entonces la conversion boxing convierte p en una referencia r de la clase Boolean, de manera que: r.booleanValue() == p Si p es de un valor de tipo byte, entonces la conversion boxing convierte p en una referencia r de la clase Byte, de manera que: r.byteValue() == p Si p es un valor de tipo char, entonces la conversion boxing convierte p en una referencia r de la clase Character, de manera que: r.charValue() == p Si p es un valor de tipo short, entonces la conversion boxing convierte p en una referencia r de la clase Short, de manera que: r.shortValue() == p

Como funciona? Si p de un valor de tipo int, entonces la conversion boxing convierte p en una refrencia r de la clase Integer, de manera que: r.intValue() == p Si p es de un valor de tipo long, entonces la conversion boxing convierte p en una referencia r de clase Long, de manera que : r.longValue() == p Si p es de valor de tipo float entonces: Si p no es NaN, entonces la conversion boxing convierte p en una referencia r de clase Float, de manera que: r.floatValue() se evaluá a p De otro modo, la conversion boxing convierte p en una referencia r de clase Float de manera que: r.isNaN() es evaluado como true.

Como funciona? Si p es de un valor tipo double, entonces Si p no es NaN, la conversion boxing convierte p en una referencia r de la clase Double, de manera que: r.doubleValue() evaluates to p De otro modo, la conversion boxing convierte p en una referencia r de la clase Double de manera que: r.isNaN() es evaluado como true. Si p es un valor de cualquier otro tipo, la conversion boxing es equivalente a la conversion de de identidad

Cuidado Si el valor de p fue “transformada” a true, false, byte, char entre \u0000 a \u007f, ó un int ó short entre -128 y 127, Entonces r1 y r2 sean resultado de cualquier conversión boxing de p siempre seran r1 == r2.

Unboxing Desde el tipo Boolean al tipo boolean Desde el tipo Byte al tipo byte Desde el tipo Character al tipo char Desde el tipo Short al tipo short Desde el tipo Integer al tipo int Desde el tipo Long al tipo long Desde el tipo Float al tipo float Desde el tipo Double al tipo double

Como funciona? Si r es una referencia de tipo Boolean, entonces la conversion unboxing convierte r en: r.booleanValue() Si r es una referencia de tipo Byte, entonces la conversion unboxing convierte r en: r.byteValue() Si r es una referencia de tipo Character, entonces la conversion unboxing convierte r en: r.charValue() Si r es una referencia de tipo Short, entonces la conversion unboxing convierte r en: r.shortValue() Si r es una referencia de tipo Integer, entonces la conversion unboxing convierte r en: r.intValue()

Seccion Fundamentos SCJP

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Seccion Fundamentos SCJP

Seccion Fundamentos SCJP