Java SCJP clase3

8/18/2019 Java SCJP clase3

1/68

SCJP 6Clase 3 – Asignaciones

Ezequiel Aranda

Sun Microsystems Campus

Ambassador


2/68

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 inthe 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/68


4/68


5/68

Literales Octales

> Los enteros octales sólo

utilizan los dígitos del 0 al 7.

> En Java, se puede

representar un entero enforma 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/68

Literales Hexadecimales

> Un valor hexadecimal comienza con 0x u OX.

> Por Ejemplo:

int x = 0X0001;

int y = 0x7fffffff;

int z = 0xDeadCafe;

x = 1 y = 2147483647 z = -559035650

>

0XCAFE y 0xcafe son validos y tienen el mismovalor.


7/68

Literales de punto flotante

> Los literales de punto flotante están definidos

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ón

float g = 49837849.029847F;


8/68

Literales de caracter

> Es posible escribirlos como el valor Unicode

del caracter, usando el prefijo \u.

char letraN= '\u004E'; // la letra

'N'> Los caracteres son enteros sin signo de 16

bits.

char e = -29; // necesitará un cast

char f = 70000 // necesitará un cast


9/68

Primitivos vs. Referencias

> Esto se llama Referencia:

Button b = new Button();

String s = new String();

> Button b = null;

Esto significa que “Button no refiere a ningún

objeto”


10/68

Asignaciones sobre primitivos

> Se puede asignar un valor a una variable

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/68

Asignaciones sobre primitivos (II)

> byte b = 3; // 3 entra en un byte

> byte c = 8; // 8 entra en un

byte> byte d = b + c; //No deberíahaber problema al sumar dos

bytes, pero ¿funciona? ¿Porqué?


12/68

Casts en primitivos

> Los casts (conversiones) pueden ser implícitos

o explícitos. Que sea implícito significa que

sucede automáticamente.

>

Los casts implícitos se dan al poner un tipomás “pequeño” en un contenedor “más

grande”

>

int a = 100;>

long b = a;//cast implícito: un intsimpre entra en un long.


13/68

Casts en primitivos (II)

> Un valor que no cabe en un contenedor más

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/68

Asignar un literal demasiado grande a

una variable

> Si intentamos asignar un literal demasiado

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/68

Asignando una variable primitiva a otra

class 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/68

Asignación de variables de referencia

public 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/68

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 elgarbage 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/68

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/68


20/68

Variables de instancia – referencias a objetos

public 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/68

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/68

Primitivos Locales

> Las variables locales,

incluyendo

primitivos, siempre

deben serinicializados antes de

utilizarlos.

>

Si intentamos utilizar un primitivo sininicializar, obtendremos un error de

compilación.


23/68

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{


Date date; // falla la compilación.

if (date == null)

System.out.println("date es null");

}

}


24/68

Asignar una variable de referencia a otra

import 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/68

Asignar una variable de referencia

a otra (II)> Se declara b, y se le asignan el valor de a. Eneste punto ambas variables contienen valores

identicos, porque los contenidos de a se

copiaron en b. Aún hay solo un objetoDimension, al que tanto a como b hacen

referencia.

> Si asignamos la variable a a b, el patrón de

bits en a es copiado, y la nueva copia se

coloca en b.


26/68

String

>

Una excepción a la forma en la que se

asignan las referencias a objetos es String.

> Los objetos String son inmutables, no se

puede cambiar el valor de un objeto String.> Siempre que hagamos un cambio en un

String, la VM actualizará la variable de

referencia para apuntar a un nuevo objeto.


27/68

String (II)

>

Se crea un nuevo String se crea (o se

encuentra uno nuevo en el String Pool),

dejando el original sin modificar.

>

La referencia utilizada para modificar elString se asigna al nuevo objeto.


28/68

Pasando referencias

>

Cuando pasamos una variable

(referencia a objeto) a un método,

debemos tener en cuenta que estamos

pasando una referencia y no el objeto ensí mismo.


29/68

import java.awt.Dimension;

class ReferenceTest{


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/68

class ReferenceTest {


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/68

Variables de instancia – Arrays

>

Un Array es un objeto, por lo tanto una

variable de instancia declarada pero no

inicializada explícitamente, tendrá un valor

null.> Pero… si el Array es inicializado, a todos los

elementos que lo componen se les asigna su

valor por defecto.


32/68

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/68

Arrays> int[][] myArray= new int[3][]; // Legal


34/68

Arrays (II)

>

int[][] scores = {{5,2,4,7}, {9,2}, {3,4}};

> scores[0] // un array de cuatro ints

> scores[1] // un array de dos ints

>

scores[2] // un array de dos ints

> scores[0][1] // valor entero 2

> scores[2][1] // valor entero 4


35/68

Arrays (III) – JIT Arrays

public class Foof{

void takesAnArray(int[] someArray) {

// usa el parámetro

}


Foof f = new Foof();

f.takesAnArray(new int[] {7,7,8,2,5});

}

}


36/68

Arrays de tipos primitivos

>

int[] weightList= new int[5];

> byte b = 4;

> char c = 'c';

>

short s = 7;

> weightList[0] = b; // OK, byte < int

> weightlist[1] = c; // OK, char < int

>

weightList[2] = s; // OK, short < int


37/68

Arrays de referencias a objetos

>

Si el tipo declarado para un Array es una

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/68

Asignación de Arrays con

referencias a objetos> Cualquier objeto de una clase que

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;

> Pero no podremos hacer

boxThings = foldingThings;


39/68

Bloques de inicialización

>

Un bloque de inicialización estático se ejecuta

una única vez, cuando se carga la clase.

> Un bloque de inicialización de instancias se

ejecuta cada vez que se crea una instancia.> Se ejecutan en el orden en el que aparecen.

> Los bloques de instancia se ejecutan luego de

la llamada a super() en el constructor.


40/68

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/68

?

static int [] x = new int[4];

static { x[4] = 5; }

>

¿Funciona?

? ?


42/68

Wrappers

>

En Java existe un wrapper por cada tipo

primitivo (Float de float, Integer de int, etc).

> Todos los wrappers tienen dos constructores

(excepto Character): uno que toma unprimitivo 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/68

Wrappers (II)

>

La clase Character provee un único

constructor, que toma un char como

argumento.

Character c1 = new Character('c');


44/68

Conversión de Wrappers a primitivos

>

Cuando necesitamos convertir el valor de

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/68

parse____() y valueOf()

>

Ambos toman un String como argumento y

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/68

toString()

>

La idea de este método es obtener una

representación coherente de un objeto dado.

> Todos los wrappers poseen un método

toString estático sobrecargado que toma unprimitivo del tipo apropiado.


47/68

AutoBoxing

>

En Java 5 aparece

esta característica

conocida como

autoboxing-autounboxing o

simplemente boxing-

unboxing.

>

int pInt = 420;

> Integer wInt = pInt; // ‘autoboxing’

>

int p2 = wInt; // ‘auto-unboxing’


48/68

> 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/68


50/68

Boxing, ==, equals()

>

Por ahora, sabemos que la intención de

equals() es determinar cuando dos instancias

de una clase son “significativamente

equivalentes”.Integer i1 = 1000;

Integer i2 = 1000;

if(i1 != i2)System.out.println("differentobjects");

if(i1.equals(i2))

System.out.println("meaningfullyequal");


51/68


52/68

Sobrecarga

>

Veamos 3 cosas que pueden hacer la

sobrecarga un poco engañosa.

> Widening

>

AutoBoxing

> Var-args


53/68

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"); }


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/68

Sobrecarga con Boxing

class 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/68

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/68


57/68

Widening de referencias

class Animal {static void eat() { } }class Dog3 extends Animal {


Dog3 d = new Dog3();

d.go(d); // ¿Esto vale?

}

void go(Animal a) { }

}

>

El compilador “ensancha” la referencia deDog3 a Animal, y la invocación funciona

correctamente. La clave es que el widening

de referencias depende de la herencia.


58/68


59/68

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/68

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...");}


int i = 5;

wide_vararg(5,5); // widening y var-args

box_vararg(5,5); // boxing y var-args

}

}


61/68

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; }


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/68

Resumen

>

El widening de primitivos usa el tipo más

pequeño posible.

> Boxing y Var-args, usados individualmente,

son compatibles con sobrecarga.> No se puede ensanchar de un wrapper a otro.

> Widening -> Boxing = falla

>

Boxing -> Widening = funciona> Puede combinarse Var-args con widening o

boxing.


63/68

Garbage Collection

>

En C, C++ y otros lenguajes, el programador

es responsable de la administración de

memoria.

>

En Java, se provee un hilo de sistema que seencarga de esta tarea.


64/68

Garbage Collection (II)

>

Durante los ciclos ociosos de la JVM, el

garbage collector revisa y libera la memoria

que este en condiciones de ser liberada.

>

“Elegible” significa que puede serrecolectado.

> Solo podemos pedir el garbage collector

usando System.gc();

>

No puede forzarse, sino más bien, sugerirse.


65/68

Garbage Collection (III)

>

En el examen tendremos que identificar

cuales objetos son “elegibles” para ser

recolectados.

>

La clave es encontrar los objetos que refierena NULL.


66/68


67/68

class CardBoard{

Short story = 5;

CardBoard go(CardBoard cb) {

cb= null;

return cb; }


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


68/68

Preguntas

Documents

Java SCJP clase3