Curso Preparativo:

Java Programmer I
1Z0-808
Sebastián Araya R. Oracle Certified Professional
 Java SE 8 Programmer I

▰ Escalón inicial en el proceso de certificación Java

▰ Su objetivo principal es evaluar el conocimiento que tiene

respecto al lenguaje Java

▰ Al aprobar la evaluación, el candidato obtiene la certificación

Oracle Certified Associate

2
Contenidos

3
Contenidos a Evaluar

▰ Java Basics

▻ Define the scope of variables

▻ Define the structure of a Java class
▻ Create executable Java applications with a main method
▻ Import other Java packages to make them accessible in your code
▻ Compare and contrast the features and components of Java such as:
platform independence, object orientation, encapsulation, etc.

4
Contenidos a Evaluar

▰ Working With Java Data Types

▻ Declare and initialize variables (including casting of primitive data
types)
▻ Differentiate between object reference variables and primitive
variables
▻ Know how to read or write to object fields
▻ Explain an Object's Lifecycle (creation, "dereference by
reassignment" and garbage collection)
▻ Develop code that uses wrapper classes such as Boolean, Double,
and Integer
5
Contenidos a Evaluar

▰ Using Operators and Decision Constructs

▻ Use Java operators; use parentheses to override operator

precedence
▻ Test equality between Strings and other objects using == and
equals ()
▻ Create if and if/else and ternary constructs
▻ Use a switch statement

6
Contenidos a Evaluar

▰ Creating and Using Arrays:

▻ Declare, instantiate, initialize and use a one-dimensional array

▻ Declare, instantiate, initialize and use multi-dimensional arrays

7
Contenidos a Evaluar

▰ Using Loop Constructs

▻ Create and use while loops
▻ Create and use for loops including the enhanced for loop
▻ Create and use do/while loops
▻ Compare loop constructs
▻ Use break and continue

8
Contenidos a Evaluar

▰ Working with Methods and Encapsulation

▻ Create methods with arguments and return values; including
overloaded methods
▻ Apply the static keyword to methods and fields
▻ Create and overload constructors; differentiate between default and
user defined constructors
▻ Apply access modifiers
▻ Apply encapsulation principles to a class
▻ Determine the effect upon object references and primitive values
when they are passed into methods that change the values
9
Contenidos a Evaluar

▰ Working with Inheritance

▻ Describe inheritance and its benefits
▻ Develop code that makes use of polymorphism; develop code that
overrides methods; differentiate between the type of a reference
and the type of an object
▻ Determine when casting is necessary
▻ Use super and this to access objects and constructors
▻ Use abstract classes and interfaces

10
 Contenidos a Evaluar

▰ Handling Exceptions
▻ Differentiate among checked exceptions, unchecked exceptions,
and Errors
▻ Create a try-catch block and determine how exceptions alter normal
program flow
▻ Describe the advantages of Exception handling
▻ Create and invoke a method that throws an exception
▻ Recognize common exception classes (such as
NullPointerException, ArithmeticException,
ArrayIndexOutOfBoundsException, ClassCastException)
11
 Contenidos a Evaluar

▰ Working with Selected classes from the Java API

▻ Manipulate data using the StringBuilder class and its methods
▻ Create and manipulate Strings
▻ Create and manipulate calendar data using classes from
java.time.LocalDateTime, java.time.LocalDate, java.time.LocalTime,
java.time.format.DateTimeFormatter, java.time.Period
▻ Declare and use an ArrayList of a given type
▻ Write a simple Lambda expression that consumes a Lambda
Predicate expression

12
Sobre el Examen

13
CONDICIONES

▰ El examen dura 150 minutos

▰ 70 preguntas

▰ Se aprueba con un 65%

▰ Preguntas de Selección múltiple

▰ Se desarrolla totalmente en Inglés

14
 RECOMENDACIONES: Sobre Modalidad

Las preguntas de selección múltiple se dividen en 2 categorías:

1. Preguntas de conocimiento: Preguntas relacionadas con
Clases y Métodos de la API
2. Preguntas de ruteo: Preguntas que se basan en un Código
expuesto como base de la pregunta, la mayoría de las
preguntas del examen son de este tipo

▰ Si bien el examen permite retroceder entre preguntas, EVITE

HACERLO

15
 RECOMENDACIONES: Modo de Resolución

Al presentarse una pregunta de ruteo:

1. Descarte un error de compilación

2. Descarte una excepción/error en tiempo de ejecución
3. Evalúe el código fuente expuesto

16
 RECOMENDACIONES: Modo de Resolución

▰ En el caso de encontrar una pregunta en la cual no tiene claridad de

la respuesta, márquela y avance a la siguiente.

▰ El orden de los contenidos en la evaluación es aleatorio, por lo cual

las preguntas no salen por orden de unidad

▰ Si ya respondió la pregunta, no retroceda para cambiarla

17
 RECOMENDACIONES: Preguntas

▰ El examen está hecho para creer que el resultado de una pregunta es

evidente.

▰ Si la pregunta tiene un resultado muy obvio, significa que hay algo

▰ Cuidado con los nombres de los métodos y sus argumentos, sobre

todo en Clases que parecen tener métodos iguales pero no lo son
Ej: String y StringBuilder
18
Planificación del Curso

19
 Planificación

1. DECLARATIONS AND ACCESS CONTROL

• Java Features and Benefits
• Identifiers and Keywords
• javac, java, main(), and Imports
• Declare Classes and Interfaces
• Declare Class Members
• Create static Class Members
• Use enums
20
• Declare Constructors and Arrays
 Planificación

2. OBJECT ORIENTATION
• Describe Encapsulation
• Implement Inheritance
• Use Polymorphism
• Use Overriding and Overloading
• Understand Casting
• Use Interfaces
• Understand and Use Return Types
• Develop Constructors
21
• Use static members
 Planificación

3. ASSIGNMENTS
• Use Class Members
• Understand Primitive Casting
• Understand Variable Scope
• Differentiate Between Primitive Variables and Reference Variables
• Determine the Effects of Passing Variables into Methods
• Understand Object Lifecycle and Garbage Collection

22
 Planificación

4. OPERATORS
• Using Java Operators
• Use Parentheses to Override Operator Precedence
• Test Equality Between Strings and Other Objects
• Using == and equals()

23
 Planificación

5. Flow Control and Exceptions

• Use if and switch Statements
• Develop for, do, and while Loops
• Use break and continue Statements
• State the Effects of Exceptions
• Recognize Common Exceptions
• Use try, catch, and finally Statements
24
 Planificación

6. Strings, Arrays, ArrayLists, Dates, and Lambdas

• Create and Manipulate Strings
• Manipulate Data Using the StringBuilder Class and Its Methods
• Declare and Use an ArrayList
• Use Wrapper Classes
• Create and Use Calendar Data
• Use Encapsulation for Reference Variables
• Declare, Instantiate, Initialize, and Use a One-Dimensional Array
• Declare, Instantiate, Initialize, and Use a Multidimensional Array
25
• Use Simple Lambda Expressions
 1 DECLARATIONS AND
ACCESS CONTROL

• Java Features and Benefits

• Identifiers and Keywords
• javac, java, main(), and Imports
• Declare Classes and Interfaces
• Declare Class Members
• Create static Class Members
• Use enums
• Declare Constructors and Arrays 26
 Conceptos fundamentales de orientación a objetos
Concepto Definición

Class A template that describes the kinds of state and

behavior that objects of its type support.

Object At runtime, when the Java Virtual Machine (JVM)

encounters the new keyword, it will use the appropriate
class to make an object that is an instance of that class.
That object will have its own state and access to all of the
behaviors defined by its class.

State (instance variables) Each object (instance of a class) will have its own
unique set of instance variables as defined in the class.
Collectively, the values assigned to an object's instance
variables make up the object's state.

Behavior (methods)
When a programmer creates a class, she creates
methods for that class. Methods are where the class's
logic is stored and where the real work gets done. They
27
are where algorithms get executed and data gets
manipulated.
 Conceptos fundamentales de orientación a objetos

Concepto Definición

Inheritance
Allows code defined in one class or interface
to be reused in other classes. In Java, you
can define a general (more abstract)
superclass and then extend it with more
specific subclasses.

Interfaces Are usually like a 100 percent abstract superclass

that defines the methods a subclass must support,
but not how they must be supported

28
 Características y beneficios de Java

Característica Descripcion

Object Oriented OO design offers a natural way to think about how the
components in a system should be constructed and how
they should interact.

Encapsulation allows a software component to hide its data from other

components

Memory management Java provides automatic memory management.

29
 Características y beneficios de Java

Característica Descripción

Secure by design The JVM provides a secure "sandbox

cross-platform execution the Java code you write can run on many platforms

Strongly typed A strongly typed language usually requires the programmer

to explicitly declare the types of the data and objects being
used in the program.

30
 Características y beneficios de Java

Característica Descripción

Multithreaded Java provides built-in language features and APIs that

allow programs to use many operating-system processes
(hence, many "cores") at the same time

Distributed computing The Java API provides several ways to simplify tasks
related to distributed computing. One such example is
serialization, a process in which a Java object is converted
to a portable form

31
Declaración de Variables

La definición de variables en Java, tiene algunas reglas generales

que limitan los caracteres que se pueden utilizar:

▰ Después del primer caracter, los nombres de variables pueden

tener cualquier combinación de caracteres, conectores,
números o el símbolo $
▰ Una variable no puede empezar por un número
▰ Java es Case Sensitive

32
Nombres de variables (identificadores ) válidos y no validos

int _a;
int $c;
int :b;
int -d;
int .f;
int ______2_w;
int _$;
int this_is_a_very_detailed_name_for_an_identifier;
int e#;
int 7g;
33
int assert;
Palabras Reservadas

Las palabras reservadas del lenguaje (keywords) no pueden ser usadas

como identificadores. Debe tener mucho cuidado cuando sean usadas como
nombre de en un atributo o variable local.

34
 Sobre convenciones

El examen siempre intentará enredarlo con estructuras de código mal identadas, como la
siguiente:

class Batman{
private name=“”;
public void setName(String _name){
if( _name.length>0) System.out.println(“Batman”);
System.out.println(“I’m Batmaan”);
static public void main(String a[]){
new Batman().setName(“”);
}
}
35
 Sobre convenciones

A pesar de todo, el examen respeta las convenciones de nombres, por lo cual:

Clases e Interfaces: La primera letra en mayúscula y la primera letra de cada inicial de las
palabras que la componen en mayúscula

Métodos (y variables): primera letra en minúscula y resto de palabras que la componen en

Mayúscula

Constantes : todas las letras en mayúscula , cada palabra separada por guión bajo

36
 Declaraciones de Archivos Fuente (Source Files)

Cuando se define un fichero fuente, existen reglas que se deben respetar respecto al orden
de las clases, los imports y los package:

▰ Solo puede haber una clase pública por archivo

▰ Los comentarios pueden aparecer en cualquier parte del código
▰ Si existe una clase pública en un archivo, el nombre del archivo debe ser equivalente a la
clase pública.
▰ Si la clase es parte de un package, entonces la definición del package debe estar al inicio
del archivo.
▰ Si es que existen imports, los imports deben ir entre la definición del package y la definición
de clase
▰ Un archivo puede tener más de una clase no-pública
▰ Si un archivo no tiene clase publica alguna, puede llamarse como sea.
37
 Declaraciones de Archivos Fuente (Source Files)

Cat.java Dog.java Dog.java

import java.util.* import java.* package animals;
class Dog{} package animals; import java.*;
class Dog{} public class Dog{}

Cat.java Cat.java
Cat.java
import java.time.LocalDate; import java.util.ArrayList;
package animals;
class Dog{} class Dog{}
import java.*;
class Bulldog extends Dog{} import java.util.function.*;
private class Cat{}
class Bulldog extends Dog{}
class Dog{}
38
 Los comandos javac y java

El comando javac es usado para invocar al compilador Java. Su estructura:

javac [options] [source files]

Ejemplos:

▰ javac -help
▰ javac -version Foo.java Bar.java
▰ javac -version -help Foo.java

39
 Los comandos javac y java

El comando java es utilizado para invocar a la JVM

java [options] class [args]

Ejemplos:

▰ java -showversion MyClass x 1

▰ java MyClass

40
 El método main

La estructura base del método con superpoderes main es la siguiente:

public static void main(String[] args){}

Sin embargo las siguientes construcciones también son válidas!! (y son las que salen en el
examen):

▰ static public void main(String[] args)

▰ public static void main(String... x)
▰ static public void main(String bang_a_gong[])
41
 El método main

El método main también puede ser sobrecargado, sin embargo el único que tiene
superpoderes es el que recibe un arreglo de String, es público y estático

public static void main(String[] args){}

public static void main(String … args){}

public static void main(){ }

42
 Formas de referenciar una Clase

Es posible crear clases que tengan el nombre de clases ya existentes en la API. Es decir,
perfectamente puedo hacer esto (y de seguro lo harán en el examen):

public class String{

public java.lang.String b = “Word”;
}

Peso esto da error de compilación!:

public class String{

public String b = “Word”;
}
43
 Formas de referenciar una Clase

En base a lo anterior, se puede referenciar a una clase de dos formas:

▰ Con su nombre completo (incluyendo package)

java.util.List<java.lang.String> a = new java.util.ArrayList<>();

▰ Importando la clase y referenciándola.

import java.util.*;
List<String> a = new ArrayList<>();
TreeSet<String> t = new TreeSet<String>();

44
 Imports estáticos (static imports)

Los static imports permiten utilizar los miembros estáticos existentes de una clase como si se trataran de
miembros existentes en la clase de origen:
Teniendo la siguiente clase, ambos resultados son equivalentes:

Antes Después
public class TestStatic { import static java.lang.System.out;
public static void main(String[] args) { import static java.lang.Integer.*;
System.out.println(Integer.MAX_VALUE); public class TestStaticImport {
System.out.println(Integer.toHexString(42)); public static void main(String[] args) {
out.println(MAX_VALUE);
} out.println(toHexString(42));
} }
}

45
 Imports estáticos (static imports)

Ojo con la sintáxis!!!

Si bien se llaman static imports, la sintaxis es import static

En el exámen tratarán de hacer lo siguiente:

static import System.out;

Cuando en realidad es:

import static System.out.;

46
 Modificadores

Existen dos tipos de modificadores:

▰ Access Modifier:
▻ public
▻ protected
▻ private
▰ Non-Access Modifier:
▻ strictfp
▻ final
▻ abstract
Ojo:
Si bien existen 3 modificadores de acceso, existen 4 controles de acceso.
El acceso default se da cuando no se define ninguno de los 3
No confundir el acceso default con la palabra reservada default!! 47
 Modificadores de Acceso

▰ Existen 3 modificadores de acceso y 4 controles de acceso

▰ Los 3 modificadores (public, private y protected) se pueden aplicar a métodos y
variables
▰ Las clases solo pueden ser public y default

48
 Modificadores de Acceso: default

Una clase con acceso default es visible solo por las clases que se encuentran dentro del
mismo package. Por lo cual:

package games;
class Player{ }

package sports;
import games.Player;
public class Football{
private Player ronaldo;
}

No compila!!!
49
 Modificadores de Acceso: public

Una clase con acceso público es visible por todas las clases de todos los package (incluso las
sin package).

package games;
public class Player{ }

package sports;
Import games.Player;
public class Football{
private Player ronaldo;
}
50
 Class Non – Access Modifiers

Adicionalmente a los modificadores de acceso, una clase puede ser:

▰ final
▰ abstract
▰ strictfp
En java no existen las clases private!!!!

51
 Class Non – Access Modifier : final

Adicionalmente a public y default (que son modificadores de acceso) una clase también puede
ser final, esto implica que la clase no es heredable (subclassed).

public final class String{

//String stuff
}

Al desarrollar: en casos muy puntuales se debería marcar una clase como final
En el exámen: Ojo con códigos como el siguiente

public final class Beverage{}

class Beer extends Beverage{}
52
 Class Non – Access Modifier : abstract

Una clase abstracta no puede ser instanciada, su único objetivo es ser parte de una herencia.
Una clase abstracta puede tener definición de métodos y solo declaración de métodos:

abstract class Animal{

abstract void sleep();

void eat(){
//animal eating
}
}
53
 Interfaces

Las interfaces son estructuras 100% abstractas que permiten definir un contrato que una
clase que la implemente debe cumplir. Una interfaz puede incluir declaraciones de métodos,
constantes, métodos estáticos y métodos default

interface Bounceable {
public abstract void setBounceFactor(int bf);
public default void bounce(){
System.out.println(“Bouncing”);
}
}

A pesar de que el ejemplo lo incluye, no es necesario agregar public abstract a los métodos
de una interfaz. Por defecto lo son!!! 54
 Interfaces: Reglas

▰ Todos los métodos de una interfaz son public y abstract a menos que sean default o static.
▰ Todas las variables en una interfaz son public static final . Una interfaz solo contiene
constantes
▰ Las interfaces pueden tener métodos static
▰ Los métodos de una interfaz no pueden ser marcados final, strictfp o native.
▰ Una interfaz puede extender a otra, en ese caso se usa extends NO IMPLEMENTS
▰ Una interfaz NO PUEDE HEREDAR NADA QUE NO SEA OTRA INTERFAZ
▰ Las interfaces son por defecto abstract, no es necesario usar la keyword

55
 Interfaces: Métodos Default

En Java 8, las interfaces pueden tener métodos con implementación!!!

Estos métodos son llamados los métodos default

Reglas:
▰ Los métodos default son definidos con la keyword default
▰ La keyword default puede ser usada solo en interfaces, no en clases (ni en clases abstractas)
▰ Los métodos default son públicos por definición
▰ Los métodos default NO pueden ser marcados private,protected, static, final ni abstract

56
 Interfaces: Métodos Default

interface Motorizable{

public default void powerOn(){

System.out.println(“Powering on”);
}
}
class Car implements Motorizable{
public void run(){
powerOn();
System.out.println(“Running!”);
}
}
57
 Interfaces: Métodos Estáticos

En Java 8, las interfaces pueden tener métodos estáticos!

Estos métodos son llamados los métodos default

Reglas:

▰ Los métodos estáticos de interfaz son declarados utilizando la keyword static

▰ Los métodos estáticos de una interfaz son públicos por defecto
▰ Los métodos estáticos de una interfaz NO PUEDEN ser marcados private, protected, final ni
abstract
▰ Los métodos estáticos deben tener una implementación (no pueden finalizar solo en ;)
▰ Cuando es invocado el método estático se debe utilizar el nombre de la interfaz (NO SIRVE
UNA REFERENCIA A UNA IMPLEMENTACIÓN!!)
58
 Interfaces: Métodos estáticos y default

interface Doctor{
int salary = 100000;
static void makeSurgery(){
System.out.println(“Working”);
}
}
class DoctorSon implements Doctor{
public void work(){
this.makeSurgery();
}
}
59
 Interfaces: Métodos estáticos y default

interface Doctor{
int salary = 100000;
static void makeSurgery(){
System.out.println(“Working with salary ” + Doctor.salary);
}
}
class DoctorSon implements Doctor{
public void work(){
Doctor.makeSurgery();
}
}
60
 Interfaces: Métodos estáticos y default

interface Doctor{
int salary = 100000;
default void makeSurgery(){
System.out.println(“Working with salary ” + Doctor.salary);
}
}
class DoctorSon implements Doctor{
public void makeSurgery(){
System.out.println(“Working free”);
}
}
61
 Ejercicios

interface Doctor{
int salary = 100000;
void makeSurgery();
}

class DoctorSon implements Doctor{

void makeSurgery(){
System.out.println(“Making”);
}
}

62
 Ejercicios

interface Doctor{
int salary = 100000;
void makeSurgery();
}

class DoctorSon implements Doctor{

public void makeSurgery(){
System.out.println(“Making”);
}
public void addMoney(int salary){
this.salary = 2000000;
}
63
}
 Ejercicios

interface Doctor{
int salary = 100000;
default void makeSurgery(){}
}
Interface PublicDoctor extends Doctor{
void sleep();
}

public final abstract ChileanDoctor implements PublicDoctor{

public void sleep(){}
public void makeSurgery(){}
} 64
 Ejercicios

Interface PublicDoctor{
public default void sleep(){}
public void makeSurgery();
}

public abstract ChileanDoctor implements PublicDoctor{

public void sleep(){}
}

65
 Ejercicios

static import Integer.*;

static import System.out;
class MathSuperClass{
public int callSuperMethod(){
out.println(MAX_VALUE);
return 0;
}
}

66
 Ejercicios

import static Integer.*;

import static System.out;
import static Long.*
class MathSuperClass{
public int callSuperMethod(){
out.println(MAX_VALUE);
return 0;
}
}

67
 Ejercicios

import java.util.List;

class ArrayList extends String{

public void reallyEpicMethod(){
List<Integer> numberList = new java.util.ArrayList<>();
numberList.add(Integer.MAX_VALUE);
}
}

68
 Class Members:Modifiers

Los miembros (atributos y métodos) de una clase pueden utilizar los 4 modificadores de acceso
existentes:

▰ public : el miembro puede ser accedido desde cualquier clase de cualquier package (mientras
tenga una instancia de la clase)
▰ private: puede ser accedido solo dentro de la clase y no desde clases hijas
▰ protected: puede ser accedido desde dentro de la clase y desde las clases hijas que
extienden la clase original (herencia) o desde el mismo package
▰ default: solo puede ser accedido si la clase que está accediendo a el, está dentro del mismo
package

69
 Ejercicios

class Grandpa{
protected int getYears(){ return 100;}
}
class Son extends Grandpa{
public int getYears(){return 60;}
}
class Family{

public static void main(String[] a){

System.out.println(new Son().getYears());
}
} 70
 Ejercicios

class Grandpa{
protected int getYears(){ return 100;}
}
class Son extends Grandpa{
int getYears(){return 60;}
}
class Family{

public static void main(String[] a){

System.out.println(new Son().getYears());
}
} 71
 Modificadores en variables locales y métodos

▰ Los modificadores de acceso no pueden ser usados en variables locales

▰ Una variable local puede ser marcada como final
▰ Los parámetros de un método pueden ser marcados como final, esto implica que la variable
no puede ser modificada dentro del método.
▰ Si un método es marcado como final, implica que no puede ser sobrescrito
▰ Un método puede ser marcado como abstract, solo si es parte o de una clase abstracta o de
una interfaz
▰ Adicionalmente, los métodos pueden ser marcados como synchronized, strictfp y native

72
 Métodos con Lista variable de argumentos (var-args)

Desde la versión 7 Java permite definir métodos que reciben una cantidad variable de
argumentos.

Reglas:

▰ Cuando declaras un parámetro var-arg debes especificar el tipo del parámetro

▰ Para declarar un parámetro var-arg debes seguir la declaración con una ellipsis ( …), un
espacio y luego el nombre el arreglo que contendrá los parámetros recibidos.
▰ Es posible tener otros parámetros dentro de un método con var-args pero el var-arg
siempre debe ser el último parámetro en la lista

73
 Métodos con Lista variable de argumentos (var-args)

void foo(int… bar)

void foo(int… bar, char b)

void foo(Bar... bar)

void foo(Bar... bar, Foo… foo)

74
 Modificadores: Consejos

Cuidado con la definición de una variable local y su contexto:

class Test{

public int a=12;

public void superMethod(int a){
a = 45;
}

public void superEpicMethod(){

int a = 67;
}

public static void main(String z[]){

Test t = new Test();

t.superMethod(70);
t.superEpicMethod();
System.out.println(t.a); 75
}
 Constructores

En java los objetos son construidos

Cada vez que construyes un objeto, al menos un constructor es ejecutado
Toda clase tiene un constructor, si no provees uno, se genera el por defecto

class A{

A(){

}
}

Reglas:

• Los constructores no pueden ser marcados static, final ni abstract

• Lo constructores no pueden ser sobrescritos!

76
 Declaración de Variables

Existen dos tipos de variables en java:

Primitivas: Puede ser uno de los 8 tipos

• char
• boolean
• byte
• short
• int
• double
• float

Referencias: Usadas para acceder (referir) a un objeto

77
 Declaración de Referencias

Las referencias pueden ser declaradas como variables estáticas,parámetros de

métodos o variables locales.

Variables de instancia: También denominados atributos, son definidos dentro

de la declaración de la clase pero fuera de cualquier método.

Reglas:
• Pueden usar cualquiera de los 4 niveles de acceso
• Pueden ser marcadas final
• Pueden ser marcadas transient
• NO PUEDEN ser marcadas abstractas
• NO PUEDEN ser marcadas synchronized
• NO PUEDEN ser marcadas strictfp
• NO PUEDEN ser marcadas native
• NO PUEDEN ser marcadas static (bueno, si pero dejan de ser variables de
instancia)
78
Modificadores en variables locales y métodos

79
 Declaración de Referencias

Variables Locales (Automatic/Stack/Method): Es una variable declarada

dentro de un método. La variable inicia su vida dentro del método y la finaliza
una vez el método termina.

Reglas:

• Las variables locales siempre viven en el Stack, no en el Heap

• Las variables locales no pueden utilizar modificadores, exceptuando final
• Antes de que una variable sea usada, debe ser inicializada
• Una variable local no puede ser referenciada en un contexto externo al
método donde fue declarada
• Se puede declarar una variable local con el mismo nombre que una variable
de instancia, esto se denomina shadowing

80
 Arreglos

Los arreglos son declarados utilizando el tipo de elementos que el arreglo

puede almacenar seguido por brackets

Declaración de un arreglo:

int[] foo;
int foo[];

Declaración de un arreglo multidimensional:

String[][] bar;
String[] bar [];

81
 Variables final

Constantes, no es posible reasignar un valor una vez la variable fue inicializada.

• Si es una variable de tipo primitivo, no puede ser modificado su valor

• Si es una referencia, no puede ser modificado el objeto al cual refiere.

No existen objetos final solo referencias final

82
 Variables transient

Cuando una variable de instancia es marcada transient quiere decir que ella no
es serializada (cuando se serializa el objeto que la contiene).

La serialización permite guardar el estado de un objeto en un fichero o

transferirlo incluso a otra JVM.

No es requerido aprender a serializar objetos para el examen, solo

conocer la keyword

83
 Variables volatile

Keyword utilizado para permitir acceso concurrente a una variable.

En el examen no entra concurrencia, al igual que con transient es

importante conocer la keyword

84
 Variables estáticas y métodos estáticos

La palabra static es utilizada para crear variables y métodos que existen

independientes de la instancia de una Clase.
También son llamados métodos/variables de Clase
Todos los miembros estáticos existen antes de que se construya cualquier
instancia de la Clase

Cosas que pueden ser marcadas static:

• Métodos
• Variables
• Initialization blocks

Cosas que NO PUEDEN ser marcadas static:

• Constructores
• Clases
• Interfaces
• Variables locales 85
 Enums**

Permiten generar valores constantes que pueden ser reutilizados con el fin de evitar bugs. Comúnmente se utilizan con el fin de
definir categorías:

enum CoffeeSize { BIG, HUGE, OVERWHELMING };

Después, al utilizarlos, se comportan como el equivalente a crear instancias y son tratados como tipos:

CoffeeSize cs = CoffeeSize.BIG;

Los enum pueden ser definidos a nivel de archivo (fuera de una clase) o como miembro de una clase (al igual que un atributo):

class Coffee2 {
enum CoffeeSize {BIG, HUGE, OVERWHELMING }
CoffeeSize size;
}
86
 Enums**

Los Enums pueden tener constructores:

enum CoffeeSize {
BIG(8), HUGE(10), OVERWHELMING(16);
CoffeeSize(int ounces) { this.ounces = ounces; }
private int ounces;
public int getOunces() { return ounces; }
}

87
 Enums**: Reglas

▰ El constructor de un Enum NO SE PUEDE LLAMAR DIRECTAMENTE, debe ser llamado desde la

definición de sus valores

▰ Se pueden definir muchos parámetros a un constructor de un enum e incluso se pueden

sobrecargar

88