RSS

Archivo de la etiqueta: Tecnologia

Las clases de cadena: String, StringBuffer y StringBuilder

Java proporciona tres clases diferentes para tratar con cadenas de caracteres:

Los objetos String son cadenas de caracteres estáticas, al crearse e inicializarse no pueden cambiar su valor. Es porque son inmutables que pueden ser compartidas por varias referencias.

Los objetos StringBuffer y StringBuilder, por el contrario, son cadenas de caracteres dinámicas, pueden cambiar su contenido y su capacidad.

La diferencia entre los objetos StringBuffer y StringBuilder es que los primeros pueden ser utilizados de forma segura por varios hilos, siendo sus métodos sincronizados mientras que los objetos StringBuilder no.

La clase StringBuilder se añadió en la versión J2SE 1.5.

Read the rest of this entry »

Anuncios
 
5 comentarios

Publicado por en 27 marzo, 2012 en Tema 6

 

Etiquetas: , , , , , , , , , ,

30 preguntas sobre Assertions

He recopilado las siguientes 30 preguntas sobre Assertions de diferentes
fuentes, citadas al final del post.

Las primeras son más teóricas, preguntando sobre las características de las Assertions y su uso adecuado o no, mientras que las siguientes se concentran en que el aspirante conozca el resultado de la ejecución.

He creído mejor esta vez no colocar las respuestas, si alguna la encontráis difícil o dudosa, podemos hablar de ella en los comentarios.

1. Suponiendo que están habilitadas las assertions, ¿cúales de las siguientes sentencias lanzarán un error?

  1. assert true : true;
  2. assert true : false;
  3. assert false : true;
  4. assert false : false;

2. ¿Cuáles de las siguientes opciones son válidas?

  1. -ae
  2. -enableassertions
  3. -source 1.4
  4. -disablesystemassertions
  5. -dea

3. ¿Cuál es el nombre de la excepción lanzada por una sentencia assertion?

  1. Depends on the assertion statement.
  2. FailedAssertion
  3. AssertionException
  4. RuntimeException
  5. AssertionError
  6. Error

4. ¿Qué puede provocar que una sentencia assert sea ignorada?

  1. Nada.
  2. Usando las opciones de compilación correctas.
  3. Usando las opciones de tiempo ejecución correctas.
  4. Usando las opciones de compilación y tiempo de ejecución correctas.

5. Suponiendo que las assertions están habilitadas, dado el siguiente método, ¿qué sentencias lanzarán una excepción?


static int inv(int value) {
assert value > -50 : value < 100;
return 100/value;
}

  1. inv(-50)
  2. inv(0)
  3. inv(50)
  4. inv(100)
  5. inv(150)
 
2 comentarios

Publicado por en 24 marzo, 2012 en Preguntas

 

Etiquetas: , , , , , ,

Los Operadores en Java (II)

Operador Resto: %

Devuelve el resto de una división.

class Resto{
    public static void main (String[] args){
        int dividendo = 15;
        int divisor = 2;
        int resto = dividendo % divisor;
        System.out.println("Resto: " + resto);

        int expresion = 3 + dividendo % divisor;
        System.out.println("Expresion: " + expresion);
    }
}

Hay que recordar que los operadores *, /, % tienen una prioridad mayor que los operadores + y -, como se puede comprobar en el ejemplo.

Recordamos también que las expresiones se evalúan por defecto de izquierda a derecha y que para cambiar la prioridad en las evaluaciones se pueden utilizar paréntesis.


Operador Concatenador: +
Con este operador se realiza una concatenación de objetos String y resulta en un nuevo objeto String.

String sujeto = "Ellos";
String predicado = "estudiaban Java";
String frase = sujeto + " " + predicado;
System.out.println(frase); //Devuelve "

Si uno de los argumentos del operador + es String el otro argumento se convierte en objeto String.

Por ejemplo, entre números y String:

class PruebaConcatenador{
    public static void main (String[] args){
        String nombre = "Virginia";
        int a = 10;
        int b = 20;

        System.out.println(nombre + a + b);
        System.out.println(a + b + nombre);
        System.out.println(a + b + nombre + a + b);
    }
}

Devolvería:

Todos los objetos pueden convertirse en objeto String de forma automática, pero el resultado puede tener poco significado. Es por esto que para dar una representación significativa de un objeto en String se suele sobrecargar el método toString().


Operadores de Incremento y Decremento: ++, —
Estos operadores se pueden colocar delante de la variable (notación prefjia) o después de la variable (notación sufija) y realizan un incremento o decremento en 1 en el valor de la variable.

Cuando tenemos la notación prefija (++i ó –i), primero se realiza el aumento o decremento en el valor y luego se evalúa.
Cuando tenemos la notaciión sufija (i++ ó i–), primero se evalúa y luego se realiza el aumento o decremento en el valor.

Por ejemplo:

class OperadoresIncrDecr{
    public static void main (String[] args){
        int a = 10;
        int b = 10;
        System.out.println("a++: " + a++); //1º Evalua con a y luego la incrementa.
        System.out.println("++b: " + ++b); //1º Incrementa y luego evalua con el nuevo valor.

        System.out.println(a); //Comprobamos que el valor se ha incrementado.
        System.out.println(b); //Comprobamos que el valor se ha incrementado.
    }
}

Devuelve:


Operador Condicional: ?:
El siguiente operador evalúa una condición y asigna un valor si es verdadera u otro valor si es falsa.

x = (expresion logica) ? valorSiVerdadero : valorSiFalso

Por ejemplo:

int nota = 80;
String resultado = (nota >= 65)? "Aprobado!!!" : "Suspenso";



Operadores Lógicos: &, |, &&, ||, ^, !

& y | son los operadores And y Or lógicos. Evalúan siempre ambas condiciones. No tienen evaluación perezosa.

&& y || son los operadores And y Or lógicos con evaluación perezosa.
Quiere decir que si pueden dar el resultado evaluando solo la primera condición no evaluarán la segunda.

Esto se da cuando:

  • La primera condición en || es cierta, independientemente de la segunda condición el resultado ya es cierto.
  • La primera condición en && es falsa, independientemente de la segunda condición el resultado es falso.

Un ejemplo con operadores de incremento para comprobar los diferentes resultados que podemos obtener si usamos un operador con evaluación normal o perezosa:

class Logicos{
    public static void main (String[] args){
        int a = 0; //Valores para operadores &, |
        int b = 5;
        int c = 0; //Valores para operadores perezosos &&, ||
        int d = 5;

        if ( a == 0 | b++ > 2) //Evalúa las dos condiciones y b se incrementa.
        {    System.out.println("Cierto (a==0 |  b++ > 2)-> a: " + a + " b: " + b);  }

        if (c == 0 || d++ > 2) //Evalúa solo la 1ª condición al ser cierta (c==0), b no incrementa.
        {    System.out.println("Cierto (c==0 || d++ > 2)-> c: " + c + " d: " + d);  }

        System.out.println();

        if (a > 0 & b++ < 5) //Evalúa las dos condiciones, b se incrementa de nuevo.
        {  }
        else
        {    System.out.println("Falso (a>0 &  b++  a: " + a + " b: " + b);  }

        if (c > 0 && d++ < 5) //Evalúa solo la 1ª condición por ser falsa (c > 0), d no incrementa.
        {    }
        else
        {    System.out.println("Falso (c>0 && d++ <5) -> c: " + c + " d: " + d);  }
    }
}

Devuelve:

^ es el operador Xor. Devueve cierto cuando una de las condiciones es falsa y la otra verdadera.
Siempre evalúa ambos operandos.

! es el operador Not. Si la condición es cierta devuelve falso y si es falsa devuelve cierto.
Con esto terminamos el tema de Operadores.
Recordaros que los operadores de desplazamiento de bits no entran en el examen para la versión 6. Os podéis encontrar preguntas sobre desplazamiento de bits en cuestionarios por ser de versiones anteriores.

En este post tenéis algunos ejercicios resueltos sobre Operadores.

 
6 comentarios

Publicado por en 4 noviembre, 2011 en Tema4

 

Etiquetas: , , , , , , , , ,

Los Operadores en Java (I)

Operadores

Los operadores son símbolos especiales que producen un nuevo valor a partir de uno o varios operandos.
Los valores producidos son, en la mayoría de los casos, booleanos o numéricos.


En la imagen tendríamos un ejemplo de un operador binario, que a partir de dos operandos produciría un nuevo valor.

En la siguiente tabla mostramos los operadores en Java, su orden de precedencia y su asociatividad.
(I-D: de izquierda a derecha, D-I: de derecha a izquierda).



Operador de Asignación: =
Cuando asignamos valor a variables de tipo primitivo hay casos en los que se produce un casting implícito, otros en los que es necesario un casting explícito y casos en los que se puede producir un truncamiento.
Cuando asignamos valores a variables de tipos de referencia debemos tener cuidado con el tipo.

Esto lo podemos ver en los posts del Tema3.



Operadores de Asignación Compuestos: +=, -=, *=, /=
Se tratan en el examen los cuatro anteriores por ser los más usuales.

Algunos ejemplos:

x += 10; //sería igual a  x = x + 10;
y -= 50; //sería igual a  y = y - 50;
z *= 7;  // equivale a  z = z * 7;
w /= 100; // equivale a w = w/100;

En los operadores compuestos la expresión de la derecha siempre se evalúa primero.

x *= 3 + 5; //sería equilvalente a x *= (3+5), es decir x = x * (3 + 5)  y no x = (x * 3) + 5.



Operadores Relacionales: <, <=, >, >=
Siempre devuelven true or false. Se suelen utilizar en sentencias ifs para comprobar condiciones o en expresiones para asignar el valor resultante a una variable boolean.

Pueden comparar cualquier combinación de enteros, reales o carácteres. Cuando se compara con un carácter se utiliza su valor Unicode numérico.

Ejemplos:

boolean resultado;
int x = 200;
if (x<=100)
{
  resultado = true;
}
else
{
  resultado = false;
}

También se podría hacer directamente:

boolean resultado;
resultado = (x<=100);

Con caracteres:

char a = 'A';
char b = 'B';
boolean resultado = a>b;



Operadores de Igualdad: ==, !=

Se pueden comparar dos números, dos carácteres, dos boolean o dos variables de referencia.
Cuando se comparan tipos primitivos devolverá true si ambos valores son iguales.
Cuando se comparan referencias devolverá true si las variables apuntan al mismo objeto.
(No si dos objetos son iguales).

Ejemplos:

class Igualdad{
    public static void main (String[] args)
    {
         int a = 100;
         char b = 'b';
         boolean res = true;

         char[] letras1 = {'a','b','c','d'};
         char[] letras2 = {'a','b','c','d'};

         if (a == 100L)
         { System.out.println("100 y 100L, Iguales");}

         if (res != (b&gt;a))
         { System.out.println("res distinto a (b>;a)");}

         if (letras1 == letras2) //Imprime distinto aunque ambos tengan el mismo contenido.
         { System.out.println("Iguales");} //porque cada referencia apunta a un obj distinto.
         else
         { System.out.println("Distintos");}

         letras2 = letras1; //hacemos que letras2 apunte a letras1

         if (letras1 == letras2) //Imprimirá iguales porque ahora
         { System.out.println("Iguales");} //apuntan al mismo objeto.
         else
         { System.out.println("Distintos");}
    }
}

 


Operador instanceof:

Se utiliza solo con referencias y comprueba si un objeto es de una clase o interfaz determinada.

Por ejemplo, supongamos la siguiente jerarquía de clases:


La clase Persona tiene una subclase Empleado. Empleado a su vez tiene una subclase Tecnico.
Además la clase Persona implementa la interfaz Modales.

Con las siguientes declaraciones:

Persona p1 = new Persona();
Persona p2 = new Empleado();
Empleado e1 = new Empleado();
Tecnico t1 = new Tecnico();
Boolean b;

¿Qué devolvería el operador instanceof en las siguientes líneas de código?

b = p1 is instanceof Persona;
b = p1 is instanceof Modales;
b = p1 is instanceof Object;
b = p1 is instanceof Empleado;
b = p1 is instanceof Tecnico;

b = p2 is instanceof Persona;
b = p2 is instanceof Empleado;
b = p2 is instanceof Modales;
b = p2 is instanceof Tecnico;

b = e1 is instanceof Empleado;
b = e1 is instanceof Modales;
b = e1 is instanceof Persona;
b = e1 is instanceof Tecnico;

b = t1 is instanceof Persona;
b = t1 is instanceof Modales;
b = t1 is instanceof Empleado;
b = t1 is instanceof Tecnico;

b = null is instanceof Persona;
b = e1 is instanceof String;

Seguimos con el resto de operadores en la siguiente entrada…

 
1 comentario

Publicado por en 2 noviembre, 2011 en Tema4

 

Etiquetas: , , , , , , , , ,

El recolector de basura

Muchos lenguajes de programación permiten asignar memoria dinámica en tiempo de ejecución pero es el programador el que tiene la responsabilidad de liberarla.

Sin embargo, Java proporciona un hilo en el nivel del sistema que administra esta memoria, busca la que está en desuso y la libera. Es el recolector de basura o Garbage Collector (GC).

Cuándo se ejecuta:
El GC está bajo el control de la JVM y ella decide cuándo ejecutarlo. Dentro de un programa se puede solicitar la ejecución pero no hay ninguna garantía de que se ejecute.

Cómo funciona:
Los modelos de reciclaje de la memoria pueden variar considerablemente en cada implementación de la JVM. Lo que debemos tener claro es cuándo un objeto es elegible por el GC.

Un objeto es elegible cuando ningún thread vivo puede acceder a él.


Cómo hacer un objeto elegible:

  • Estableciendo la referencia a null:
    Cuando asignamos la referencia de un objeto a null estamos perdiendo cualquier posibilidad de acceder a él.

    public class aNull{
        public static void main (String[] args){
            Integer a = new Integer(10); //1
            a = null; //2
           //ahora el objeto Integer(10) es elegible por el GC.
        }
    }
    

    //1 Creación del objeto.

    //2 La referencia ya no apunta al objeto. La referencia es igual a null. El objeto es ahora elegible por el GC.

  • Reasignando la referencia:
    Cuando hacemos que la referencia que apunta a un objeto apunte a otro distinto dejando el primero inaccesible.

    public class Reasigno{
        public static void main (String[] args){
            Integer a = new Integer(10); //1
            Integer b = new Integer(20); //2
            a = b; //3
            //ahora el objeto Integer(10) es elegible por el GC.
        }
    }
    

    //1 y //2 Creación de los objetos.


    //3 La referencia a y b están ahora apuntando al segundo objeto, siendo el primero elegible para el GC.

  • Cuando la referencia está aíslada:
    Se produce cuando un objeto tiene como miembros otros objetos de su misma clase y aunque se pierdan las referencias de estos objetos aún conservan entre ellos referencias vivas que son elegibles para el GC.

    public class Aislada{
        Aislada vecina;
        public static void main (String[] args){
            Aislada a = new Aislada(); //1
            Aislada b = new Aislada();
    
            a.vecina = b; //2
            b.vecina = c;
            a = null; //3
            b = null; // Aunque las pongamos a null entre los objetos tienen referencias.
        }
     }
    

    //1 y //2: Creación de los objetos Aislada y asignación de la vecina.

       

    //3: Se ponen las referencias a null. Los dos objetos Aisladas son elegibles para el GC.

       

Solicitar la ejecución del GC:
Como hemos dicho antes no se puede forzar la ejecución del recolector de basuras. Se solicita su ejecución mediante la siguiente instrucción pero no se nos garantiza que se ejecute.

Se puede ejecutar mediante:

System.gc();

U obteniendo una instancia de Runtime:

Runtime rt = Runtime.getRuntime();
rt.gc();

Método finalize():
Este método está definido en la clase Object y por tanto todos los objetos lo heredan. En él
podemos escribir cualquier código que queramos que se ejecute antes de que el GC borre el objeto.

Como la ejecución del GC no está garantizada que se ejecute la ejecución de finalize() tampoco está garantizada.

Cada objeto sólo podrá llamar a este método una vez. En este código se podría hacer inelegible el objeto, por ejemplo, volviendo a asignarle una referencia.

 
10 comentarios

Publicado por en 20 octubre, 2011 en Estudio, Tema 3

 

Etiquetas: , , , , , , ,

Asignaciones – Sobrecarga de Métodos con Widening, Boxing y Clases Envoltorio

Vamos a ver algunos casos concretos relacionados con el Widening, las Clases Envoltorio y los Argumentos-Variables que pueden hacernos dudar en el momento de saber qué método elije el compilador cuando tenemos métodos sobrecargados…

Sobrecarga y tipos primitivos:

Escogerá el menor tipo que sea mayor que el argumento en la llamada.

class SobrecargaPrimitivos {
    public static void main(String[] args){

        byte byteVar = 10;
        short shortVar = 10;
        char charVar = 10;
        long longVar = 10;
        float floatVar = 10.0f;

        System.out.println ("\nmetodo (byteVar)\u003B");
        metodo (byteVar); //Llamada con un argumento byte

        System.out.println ("\nmetodo (shortVar)\u003B");
        metodo (shortVar); //Llamada con argumento short

        System.out.println ("\nmetodo (charVar)\u003B");
        metodo (charVar); //Llamada con argumento char

        System.out.println ("\nmetodo (longVar)\u003B");
        metodo (longVar); //Llamada con argumento long

        System.out.println ("\nmetodo (floatVar)\u003B");
        metodo (floatVar); //Llamada con argumento float

    }

 static void metodo (int v) { System.out.print ("-> amplia a int y ejecuta metodo (int v) \n");}
 static void metodo (long v) { System.out.print ("-> amplia a long y ejecuta metodo (long v) \n");}
 static void metodo (double v){System.out.print ("-> amplia a double y ejecuta metodo (double v)\n");}

}

Sobrecarga Boxing y tipos primitivos:

Si el compilador tiene que elegir entre hacer un boxing (un método con un parámetro Envoltorio) y un widening (método con un tipo primitivo mayor) elegirá el widening.

class SobrecargaBoxing_Primitivos {
    public static void main (String[] args){
        int intVar = 10;
        System.out.println ("\nmetodo (intVar)\u003B");
        metodo (intVar); // A qué método llamará?
    }

   static void metodo (long v) { System.out.print ("-> amplia a long y ejecuta metodo (long v)\n");}
   static void metodo (Integer v) {System.out.print ("-> boxing a Integer y ejecuta metodo (Integer v)\n");}
}


Sobrecarga Argumentos-Variables y tipos primitivos:  

Si el compilador tiene que elegir entre un método con argumentos variables y un widening (método con un tipo primitivo mayor) elegirá el widening.

class SobrecargaVarArgs_Primitivos {

public static void main (String[] args){

int intVar = 10;

System.out.println ("\nmetodo (intVar)\u003B");
metodo (intVar);

}

 static void metodo (long v) { System.out.print ( "-> amplia a long y ejecuta metodo (long v) \n");}
 static void metodo (int ... v) {System.out.print ( "-> ejecuta metodo (int.. v) \n");}

}


Sobrecarga Boxing y Argumentos-Variables:

Cuando el compilador tiene que elegir entre hacer boxing y un método con argumentos variables, se queda con el boxing.

class SobrecargaBoxing_VarArgs {
public static void main (String[] args){
int intVar = 10;
System.out.println ("\nmetodo (intVar)\u003B");
        metodo (intVar);
}
static void metodo (Integer v) { System.out.print ( "-> boxing a Integer y ejecuta metodo (Integer v) \n");}
  static void metodo (int ... v) {System.out.print ( "-> ejecuta metodo (int.. v) \n");}
}


Sobrecarga y Tipos de Referencia:

El compilador hace widening si encuentra un objeto de una subclase y el método tiene como parámetro un objeto de la superclase. Esto es debido a que un objeto hijo se puede utilizar donde se espera un objeto padre y no al contrario.


Sobrecarga con widening y boxing a la vez:

Veamos qué ocurre en los casos en los que el compilador necesita hacer estas dos conversiones para llamar al método.

  • Amplía y luego Boxing: en este caso el compilador no puede hacer esta operación. Da error de compilación.
public class wideAndBox{
    public static void main(String[] args){
        byte byteVar = 5;
        System.out.println ("\nmetodo (byteVar)\u003B");
        metodo(byteVar);
    }
    static void metodo(Long v){
        System.out.println("-> ejecuta metodo (Long v) \n");
    }
}

El compilador tampoco puede hacer las operaciones cambiando el orden, primero Boxing y luego ampliando  porque un Byte no se puede ampliar a Long (Un Byte no es un Long, no están relacionados por herencia).

  • Boxing y luego amplía: el compilador sí puede hacer estas dos conversiones si despúes de hacer Boxing se puede ampliar porque estén relacionados por herencia. Un Byte es un Object.
public class BoxAndWide{
    public static void main(String[] args){
        byte byteVar = 5;
        System.out.println ("\nmetodo (byteVar)\u003B");
        metodo(byteVar);
    }
    static void metodo(Object  v){
        System.out.println("-> ejecuta metodo (Object v) \n");
    }
}


Combinando Boxing y Widening con VarArgs:

El compilador no tiene problema cuando un método tiene argumentos variables ya haga falta hacer widening o boxing.

public class ejem{

    public static void main(String[] args){
        int entero = 10;
        metodo1 (entero, entero);
        metodo2 (entero, entero);
    }

    static void metodo1(long... v) { System.out.println("metodo(Long... )");}
    static void metodo2(Integer... v) {System.out.println("metodo(Integer... )");}
}


Resumen:

  • Entre diferentes métodos con tipos primitivos, el compilador escoge el menor tipo que sea mayor al argumento de llamada.

En los tres siguientes casos gana la característica más antigua en Java:

  • Entre Boxing y Widening, gana Widening.
  • Entre Args Variables y Widening, gana Widening.
  • Entre Boxing y Argumentos Variables, gana Boxing.
  • Argumentos Variables con Boxing o Argumentos Variables con widening, ambos funcionan.
  • Widening y Boxing, no funciona (int pasaría a long, pero long no puede convertirse en Long).
  • Boxing y Widening, funciona (int pasaría a Integer e Integer puede convertirse en Object).
 
1 comentario

Publicado por en 13 octubre, 2011 en Estudio, Tema 3

 

Etiquetas: , , , , , , , ,

Asignaciones – Clases Envoltorio y Boxing

En Java los datos numéricos, de caracteres, lógicos se tratan de forma primitiva por eficiencia.
Normalmente usamos tipos primitivos y no objetos.

Sin embargo, existe una manera de que estos datos puedan ser objetos, usando las llamadas clases envoltorio. Cada tipo primitivo en Java tiene su correspondiente clase envoltorio.

Son las siguientes:

Tipo primitivo Clase envoltorio
boolean Boolean
byte Byte
char Character
short Short
int Integer
long Long
float Float
double Double

Los objetos se construyen pasando el valor al constructor correspondiente.

int entero = 500;
Integer Entero = new Integer(entero); //de primitivo a objeto se llama boxing.
int aEntero = Entero.intValue();            //de objeto a primitivo se llama unboxing.

Muchas veces es útil convertir a estas clases ya que tienen muchos métodos interesantes.

String str = “1000”;
int x = Integer.parseInt(str);

En este último ejemplo hemos podido convertir de String a int utilizando su clase envoltorio Integer y el
método parseInt.

Constructores:

Cada clase envoltorio (menos Character) tienen dos constructores: uno que admite el tipo primitivo como parámetro y otro que admite un String.

Integer a = new Integer(500);
Integer b = new Integer(“500”);

Float c = new Float(7.5f);
Float d = new Float(“7.5f”);

Character e = new Character(‘t’);

Para el constructor Boolean cuando el String es true (sin importar mayúsculas o minúsculas) será true, cualquier otro valor será falso.

Boolean f = new Boolean(false);
Boolean g = new Boolean(“TrUe”); //g será true.

Boolean h = new Boolean (“NO”); //h será false.

ValueOf:

Otra forma de construir un objeto de una clase envoltorio es mediante este método estático, valueOf. Este método puede aceptar un String, o un String y un parámetro que indique la base numérica.

Integer nuevo = new Integer.valueOf(“150”);
Integer binario = new Integer.valueOf(“1010”, 2);

Métodos Útiles:

  • Convierte un Envoltorio en primitivo:
    byteValue(), shortValue(), intValue(), longValue(), floatValue(), doubleValue()
  • Convertir un String en primitivo:
    parseByte(), parseShort(), parseInt(), parseLong(), parseFloat(), parseDouble()
  • Dar una representación en String: toString()
  • Convertir números a otras bases. Con objetos Integer y Long se pueden utilizar: toBinaryString(), toOctalString(), toHexString():

Autoboxing y unboxing:

Para pasar de un tipo primitivo a su objeto equivalente se necesita utilizar las clases envoltorio (boxing).
Para obtener de la referencia del objeto su tipo primitivo (unboxing) se necesitan usar los métodos de las clases envoltorio.

Todas estas operaciones complicaban excesivamente el código. Por ello a partir de J2SE 5.0 se introdujo una conversión automática (autoboxing) que permite asignar y obtener los tipos primitivos sin necesidad de utilizar las clases envoltorio.

Por ejemplo:

int enteroPrimitivo = 420;
Integer Entero = enteroPrimitivo;  //Se permite la asignación directa. Se llama autoboxing.
int otroEnteroPrimitivo = Entero;  //Se asigna directamente. Se llama autounboxing.

De modo que ahora el compilador según el caso se encarga de crear el objeto envoltorio o de extraer el tipo primitivo.

También se permite en el paso de parámetros y en expresiones aritméticas.

 
1 comentario

Publicado por en 11 octubre, 2011 en Estudio, Tema 3

 

Etiquetas: , , , , , , , , ,

 
A %d blogueros les gusta esto: