Upcoming SlideShare
×

# Clase3 asignaciones

576 views

Published on

0 Likes
Statistics
Notes
• Full Name
Comment goes here.

Are you sure you want to Yes No
• Be the first to comment

• Be the first to like this

Views
Total views
576
On SlideShare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
27
0
Likes
0
Embeds 0
No embeds

No notes for slide

### Clase3 asignaciones

1. 1. SCJP 6 Clase 3 – Asignaciones Ezequiel ArandaSun Microsystems Campus Ambassador
2. 2. Disclaimer & Acknowledgments>!Even though Ezequiel Aranda is a full-time employee of Sun Microsystems, the contents here are created as his own personal endeavor and thus does not reflect any official stance of Sun Microsystems.>!Sun Microsystems is not responsible for any inaccuracies in the contents.>!Acknowledgments – The slides of this presentation are made from “SCJP Unit 1” by Warit Wanwithu and Thanisa Kruawaisayawan and SCJP Workshop by P. Srikanth.>!This slides are Licensed under a Creative Commons Attribution – Noncommercial – Share Alike 3.0 >!http://creativecommons.org/licenses/by-nc-sa/3.0/
3. 3. AGENDA>! iterales L>! eferencias R>! rrays A>! rappers W>! oxing y Widening B>! obrecarga con boxing, widening y var-args S>! arbage Collection G
4. 4. Stack y Heap>! as variables de instancia y los objetos se L almeacenan en el heap.>! as variables locales, en el stack. L
5. 5. Literales Octales>!Los enteros octales sólo utilizan los dígitos del 0 al 7.>!En Java, se puede representar un entero en forma octal colocando un cero delante del número.int six = 06; // Equivale a 6int seven = 07; // Equivale a 7int eight = 010; // Equivale a 8int nine = 011; // Equivale a 9
6. 6. Literales Hexadecimales>! n valor hexadecimal comienza con 0x u OX. U>! or Ejemplo: Pint x = 0X0001;int y = 0x7fffffff;int z = 0xDeadCafe;x = 1 y = 2147483647 z = -559035650>! XCAFE y 0xcafe son validos y tienen el mismo 0 valor.
7. 7. Literales de punto flotante>! os literales de punto flotante están definidos L como double (64 bits) por defecto, por lo que al asignar un literal a una variable float (32 bits), debemos colocarle el sufijo F (o f).float f = 23.467890; // falla la compilaciónfloat g = 49837849.029847F;
8. 8. Literales de caracter>! s posible escribirlos como el valor Unicode E del caracter, usando el prefijo u.char letraN= u004E; // la letra N>! os caracteres son enteros sin signo de 16 L bits.char e = -29; // necesitará un castchar f = 70000 // necesitará un cast
9. 9. Primitivos vs. Referencias>! sto se llama Referencia: EButton b = new Button();String s = new String();>! utton b = null; BEsto significa que “Button no refiere a ningún objeto”
10. 10. Asignaciones sobre primitivos>! e puede asignar un valor a una variable S primitiva usando un literal o el resultado de una expresión.int x = 7;int y = x + 2;int z = x * y;byte b = 300;¿Esto compila?
11. 11. Asignaciones sobre primitivos (II)>! yte b = 3; // 3 entra en un b byte>! yte c = 8; // 8 entra en un b byte>! yte d = b + c; //No debería b haber problema al sumar dos bytes, pero ¿funciona? ¿Por qué?
12. 12. Casts en primitivos>! os casts (conversiones) pueden ser implícitos L o explícitos. Que sea implícito significa que sucede automáticamente.>! os casts implícitos se dan al poner un tipo L más “pequeño” en un contenedor “más grande”>! nt a = 100; i>! ong b = a;//cast implícito: un int l simpre entra en un long.
13. 13. Casts en primitivos (II)>! n valor que no cabe en un contenedor más U pequeño debe convertirse explícitamente, indicando que conocemos la posibilidad de perdida de información.>!float a = 100.001f;>! intb = (int) a; //cast explícito, el float podría perder información.
14. 14. Asignar un literal demasiado grande a una variable>! i intentamos asignar un literal demasiado S grande a una variable obtendremos un error de compilación.float f = 32.3;byte a = 128;// byte llega hasta 127>! Qué pasa si hacemos esto? ¿byte a = (byte) 128;
15. 15. Asignando una variable primitiva a otraclass ValueTest{ public static void main (String [] args) { int a = 25; // asignamos un valor a ‘a’ System.out.println(“first a = " + a); int x = a; x = 30; System.out.println(“second a = " + a); }}
16. 16. Asignación de variables de referenciapublic class Foo{ public void doFooStuff() { }}public class Bar extends Foo{ public void doBarStuff() { }}class Test { public static void main (String [] args{ Foo reallyABar= new Bar(); // Legal Bar reallyAFoo= new Foo(); // Ilegal}}
17. 17. Tiempo de vida de las variables>!Las variables estáticas se crean cuando se carga la clase y sobreviven mientras la clase se mantenga cargada en la JVM.>!Las variables de instancia se crean con cada instancia y sobreviven hasta que la instancia es removida por el garbage collector.>!Las variables locales viven mientras el método al que pertenecen este en el stack. Más adelante veremos que pueden estar vivas pero fuera de alcance.>!Las variables de bloque sólo viven mientras el bloque se este ejecutando.
18. 18. class Layout { static int s = 343; int x1; { x1 = 7; int x2 = 5; } Layout(){ x1 += 8; int x3 = 6; } void doStuff() { int y = 0; for(int z = 0; z < 4; z++) { y += z + x1; } System.out.println("y ="+y); }}
19. 19. Variables de instancia – tipos primitivospublic class BirthDate { int year; // variable de instancia public static void main(String [] args) { BirthDate bd= new BirthDate(); bd.showYear(); } public void showYear() { System.out.println("The year is " + year); }}
20. 20. Variables de instancia – referencias a objetospublic class Book { private String title; public String getTitle() { return title; } public static void main(String [] args){ Book b = new Book(); System.out.println("The title is "+ b.getTitle()); }}
21. 21. Variables de instancia – referencias a objetos (II)>!null no es lo mismo que un string vacio. Significa que la variable no hace referencia a ningún objeto en el heap.public class Book { private String title; // variable de instancia de referencia public static void main(String[] args) { Book b = new Book(); System.out.println(b.title); String s = b.title.toLowerCase(); // Null pointer Exception }}
22. 22. Primitivos Locales>! as variables locales, L incluyendo primitivos, siempre deben ser inicializados antes de utilizarlos.>! i intentamos utilizar un primitivo sin S inicializar, obtendremos un error de compilación.
23. 23. Referencias a objetos locales>!A las referencias locales no se les asigna un valor por defecto (es decir, no son null por defecto). El siguiente código no compila:import java.util.Date;public class TimeTravel{ public static void main(String[] args) { Date date; // falla la compilación. if (date == null) System.out.println("date es null"); }}
24. 24. Asignar una variable de referencia a otraimport java.awt.Dimension;class ReferenceTest{ public static void main (String [] args){ Dimension a = new Dimension(5,10); System.out.println("a.height = " + a.height); Dimension b = a; b.height = 30; System.out.println("a.height = " + a.height +" after change to b"); }}
25. 25. Asignar una variable de referencia a otra (II)>! e declara b, y se le asignan el valor de a. En S este punto ambas variables contienen valores identicos, porque los contenidos de a se copiaron en b. Aún hay solo un objeto Dimension, al que tanto a como b hacen referencia.>! i asignamos la variable a a b, el patrón de S bits en a es copiado, y la nueva copia se coloca en b.
26. 26. String>! na excepción a la forma en la que se U asignan las referencias a objetos es String.>! os objetos String son inmutables, no se L puede cambiar el valor de un objeto String.>! iempre que hagamos un cambio en un S String, la VM actualizará la variable de referencia para apuntar a un nuevo objeto.
27. 27. String (II)>! e crea un nuevo String se crea (o se S encuentra uno nuevo en el String Pool), dejando el original sin modificar.>! a referencia utilizada para modificar el L String se asigna al nuevo objeto.
28. 28. Pasando referencias>! uando pasamos una variable C (referencia a objeto) a un método, debemos tener en cuenta que estamos pasando una referencia y no el objeto en sí mismo.
29. 29. import java.awt.Dimension;class ReferenceTest{ public static void main (String [] args) { Dimension d = new Dimension(5,10); ReferenceTest rt= new ReferenceTest(); System.out.println("Before modify() d.height = "+ d.height); rt.modify(d); System.out.println("After modify() d.height = "+ d.height); } void modify(Dimension dim) { dim.height = dim.height + 1; System.out.println("dim = " + dim.height); }}
30. 30. class ReferenceTest { public static void main (String [] args) { int a = 1; ReferenceTest rt = new ReferenceTest(); System.out.println("Before = " +a); rt.modify(a); System.out.println("After = " + a); } void modify(int number) { number = number + 1; System.out.println("number = " + number); }}
31. 31. Variables de instancia – Arrays>! n Array es un objeto, por lo tanto una U variable de instancia declarada pero no inicializada explícitamente, tendrá un valor null.>! ero… si el Array es inicializado, a todos los P elementos que lo componen se les asigna su valor por defecto.
32. 32. Pregunta>! qué imprime este código? ¿public class NewClass{ static int x[]; static int y[] = new int[3]; public int z; public static void main(String[] args){ System.out.println(x); System.out.println(y); System.out.println(y[0]); System.out.println(x[1]); System.out.println(z); }}
33. 33. Arrays>!nt[][] myArray= new int[3][]; // Legal i
34. 34. Arrays (II)>!nt[][] scores = {{5,2,4,7}, {9,2}, {3,4}}; i>! cores[0] // un array de cuatro ints s>! cores[1] // un array de dos ints s>! cores[2] // un array de dos ints s>! cores[0][1] // valor entero 2 s>! cores[2][1] // valor entero 4 s
35. 35. Arrays (III) – JIT Arrayspublic class Foof{ void takesAnArray(int[] someArray) { // usa el parámetro } public static void main (String [] args) { Foof f = new Foof(); f.takesAnArray(new int[] {7,7,8,2,5}); }}
36. 36. Arrays de tipos primitivos>!nt[] weightList= new int[5]; i>! yte b = 4; b>! har c = c; c>! hort s = 7; s>! eightList[0] = b; // OK, byte < int w>! eightlist[1] = c; // OK, char < int w>! eightList[2] = s; // OK, short < int w
37. 37. Arrays de referencias a objetos>! i el tipo declarado para un Array es una S clase, dicho Array podrá almacenar objetos de cualquier subclase del tipo declarado.class Car {}class Subaru extends Car {}class Ferrari extends Car {}Car [] myCars = {new Subaru(), new Car(), new Ferrari()};
38. 38. Asignación de Arrays con referencias a objetos>! ualquier objeto de una clase que C implemente una interfaz pasará la prueba “es un” (instanceof) para dicha interfaz. Por ejemplo, si Box implementa Foldable: Foldable[] foldingThings; Box[] boxThings= new Box[3]; foldingThings= boxThings;>! ero no podremos hacer P boxThings = foldingThings;
39. 39. Bloques de inicialización>! n bloque de inicialización estático se ejecuta U una única vez, cuando se carga la clase.>! n bloque de inicialización de instancias se U ejecuta cada vez que se crea una instancia.>! e ejecutan en el orden en el que aparecen. S>! os bloques de instancia se ejecutan luego de L la llamada a super() en el constructor.
40. 40. class Init { Init(int x) { System.out.println("1-arg const"); } Init() { System.out.println("no-arg const"); } static { System.out.println("1st static init");} { System.out.println("1st instance init"); } { System.out.println("2nd instance init"); } static { System.out.println("2nd static init"); } public static void main(String [] args) { new Init(); new Init(7); }}
41. 41. ?static int [] x = new int[4];static { x[4] = 5; }>! Funciona? ¿ ? ?
42. 42. Wrappers>! n Java existe un wrapper por cada tipo E primitivo (Float de float, Integer de int, etc).>! odos los wrappers tienen dos constructores T (excepto Character): uno que toma un primitivo del tipo que envuelve y uno que toma una representación de tipo String del tipo a construir. Integer i1 = new Integer(42); Integer i2 = new Integer("42");
43. 43. Wrappers (II)>! a clase Character provee un único L constructor, que toma un char como argumento. Character c1 = new Character(c);
44. 44. Conversión de Wrappers a primitivos>! uando necesitamos convertir el valor de C wrappers a primitivos, podemos usar alguno de los métodos “____Value()” de esa clase. Integer i2 = new Integer(42); byte b = i2.byteValue(); short s = i2.shortValue(); double d = i2.doubleValue();
45. 45. parse____() y valueOf()>! mbos toman un String como argumento y A arrojan una excepción NumberFormatException si el String no tiene el formato correcto. long L2 = Long.parseLong("101010",2); // String binario a primitivo: L2 = 42 Long L3 = Long.valueOf("101010", 2); // String binario a objeto Long: L3 value = 42
46. 46. toString()>! a idea de este método es obtener una L representación coherente de un objeto dado.>! odos los wrappers poseen un método T toString estático sobrecargado que toma un primitivo del tipo apropiado.
47. 47. AutoBoxing>! n Java 5 aparece E esta característica conocida como autoboxing- autounboxing o simplemente boxing- unboxing.>!int pInt = 420;>!Integer wInt = pInt; // ‘autoboxing’>!int p2 = wInt; // ‘auto-unboxing’
48. 48. >!Integer y = new Integer(567);>!int x = y.intValue(); // unwrap>!x++; // incremento>!y = new Integer(x); // re-wrap>!System.out.println("y= " + y); // print>!Java 5:>!Integer y = new Integer(567);>!y++; // unwrap, incremento,rewrap>!System.out.println("y= " + y); // print>!Ambos imprimen: y = 568
49. 49. AutoBoxing (II)Integer y = 567; // wrapperInteger x = y;System.out.println(y==x);y++; // unwrap, uso, "rewrap"System.out.println(x + " " + y);System.out.println(y==x);
50. 50. Boxing, ==, equals()>! or ahora, sabemos que la intención de P equals() es determinar cuando dos instancias de una clase son “significativamente equivalentes”. Integer i1 = 1000; Integer i2 = 1000; if(i1 != i2) System.out.println("different objects"); if(i1.equals(i2)) System.out.println("meaningfully equal");
51. 51. Boxing, ==, equals() (II)>! os instancias de Boolean, Byte, Character D (de u0000 a u007f), Short e Integer (-128 a 127) serán == si sus valores primitivos son iguales. Integer i3 = 10; Integer i4 = 10; if(i3 == i4) System.out.println("same object"); if(i3.equals(i4)) System.out.println("meaningfully equal");
52. 52. Sobrecarga>! eamos 3 cosas que pueden hacer la V sobrecarga un poco engañosa.>! idening W>! utoBoxing A>! ar-args V
53. 53. Wideningclass EasyOver{static void go(intx) { System.out.print("int"); }static void go(long x) { System.out.print("long "); }static void go(double x){ System.out.print("double"); }public static void main(String [] args) {byte b = 5;short s = 5;long l = 5;float f = 5.0f;go(b);go(s);go(l);go(f);}}// En cada caso, cuando no se encuentra una correspondencia exacta, la JVM usa el método con el argumento que cumple con ser el “menor de los más amplios” que el parámetro.
54. 54. Sobrecarga con Boxingclass AddBoxing { static void go(Integer x) { System.out.println("Integer"); } static void go(long x) { System.out.println("long"); } public static void main(String [] args) { int i = 5; go(i); // ¿Cuál de los go() se invoca?}}>!El compilador, ¿Decide hacer widening o autoboxing?
55. 55. Sobrecarga con var-argsclass AddVarargs{ static void go(int x, int y) { System.out.println("int,int");} static void go(byte... x) { System.out.println("byte... "); } public static void main(String[] args){ byte b = 5; go(b,b); // ¿Cuál de los go() se invoca? }}
56. 56. Conclusión>! l orden en que el compilador elige es el E siguiente:1.! Mismo tipo2.! Widening3.! Boxing4.! Var-args
57. 57. Widening de referenciasclass Animal {static void eat() { } }class Dog3 extends Animal { public static void main(String[] args) { Dog3 d = new Dog3(); d.go(d); // ¿Esto vale? } void go(Animal a) { }}>! l compilador “ensancha” la referencia de E Dog3 a Animal, y la invocación funciona correctamente. La clave es que el widening de referencias depende de la herencia.
58. 58. Sobrecarga combinando widening y boxing>! a regla es que el compilador puede ajustar L una invocación siempre y cuando sólo requiera una única conversión. class WidenAndBox{ static void go(Long x) { System.out.println("Long"); } public static void main(String [] args) { byte b = 5; go(b); // requiere widening y boxing - ilegal }}
59. 59. Sobrecarga combinando Boxing y Wideningclass BoxAndWiden { static void go(Object o) { Byte b2 = (Byte) o; System.out.println(b2); } public static void main(String [] args) { byte b = 5; go(b); // ¿Puede este byte volverse un object? }}>! Funciona? ¿Por qué? ¿
60. 60. Sobrecarga combinando con Var-argsclass Vararg{ static void wide_vararg(long... x) {System.out.println("long...");} static void box_vararg(Integer... x) {System.out.println("Integer...");} public static void main(String [] args) { int i = 5; wide_vararg(5,5); // widening y var-args box_vararg(5,5); // boxing y var-args }}
61. 61. class Eggs { int doX(Long x, Long y) { return 1; } int doX(long... x) { return 2; } int doX(Integer x, Integer y) { return 3; } int doX(Number n, Number m) { return 4; } public static void main(String[] args) { new Eggs().go(); } void go() { short s = 7; System.out.print(doX(s,s) + " "); System.out.println(doX(7,7));} }>! Cuál es el resultado? ¿A. 1 1 B. 2 1 C. 3 3 D. 4 3
62. 62. Resumen>! l widening de primitivos usa el tipo más E pequeño posible.>! oxing y Var-args, usados individualmente, B son compatibles con sobrecarga.>! o se puede ensanchar de un wrapper a otro. N>! idening -> Boxing = falla W>! oxing -> Widening = funciona B>! uede combinarse Var-args con widening o P boxing.
63. 63. Garbage Collection>! n C, C++ y otros lenguajes, el programador E es responsable de la administración de memoria.>! n Java, se provee un hilo de sistema que se E encarga de esta tarea.
64. 64. Garbage Collection (II)>! urante los ciclos ociosos de la JVM, el D garbage collector revisa y libera la memoria que este en condiciones de ser liberada.>! Elegible” significa que puede ser “ recolectado.>! olo podemos pedir el garbage collector S usando System.gc();>! o puede forzarse, sino más bien, sugerirse. N
65. 65. Garbage Collection (III)>! n el examen tendremos que identificar E cuales objetos son “elegibles” para ser recolectados.>! a clave es encontrar los objetos que refieren L a NULL.
66. 66. class CardBoard{ Short story = 5; CardBoard go(CardBoard cb) { cb= null; return cb; } public static void main(String[] args) { CardBoard c1 = new CardBoard(); CardBoard c2 = new CardBoard(); CardBoard c3 = c1.go(c2); c1 = null; // do Stuff} }>!Cuando llegamos a “//do Stuff”, ¿Cuantos elementos son elegibles para gc?A. 0 B. 1 C. 2 D. no compila E. Excepción
67. 67. Preguntas