Objetivos de Certificación

SUN CERTIFIED JAVA PROGRAMMER (SCJP) CAPÍTULO 7: COLECCIONES Y GENÉRICOS

Objetivos de Certificación
Overriding de los métodos hashCode() e equals(). Determinar el uso apropiado de colecciones (interfaces y clases), incluyendo el uso de la interface Comparable. Uso del Framework Collections.

Métodos de la clase Object cubiertos en el examen

Método toString() Usado para leer detalles útiles del objeto.
Cuando no es sobrescrito, imprime el nombre de la clase, seguido y la representación en hexadecimal (sin-signo) del hashcode del objeto. Ej: HardToRead h = new HardToRead(); System.out.println(h); // imprime : Ejemplo OverridingToString.java

Overriding equals() Recordemos que la clase String y las clases wrapper sobreescriben el método equals() para poder comparar dos objetos (del mismo tipo) y revisar si sus contenidos son significativamente equivalente. Cuando necesitas saber si dos referencias son identicas se usa el ==. Pero cuando necesitas saber si dos objetos (no las referencias) son iguales, se utiliza el método equals().

Overriding equals() En la clase Object, equals() usa solamente el operador == para realizar la comparación, por ello mientras no se sobreescriba este método, dos objetos serán considerados iguales si sus referencias apuntan al mismo objeto. Entonces, para que un objeto pueda ser usado como key en un hashtable, etc; se debe sobreescribir el método equals(), para que dos instancias diferentes puedan ser consideradas la misma.

Overriding equals() Ver ej: OverridingEquals.java Análisis:
Declaración válida del método equals() heredado de Object(): public boolean equals(Object o){ } Ojo: Los métodos equals(), hashcode() y toString() son todos públicos. Asegurarse que el objeto es del tipo correcto (Test Instance of).

The equals() Contract It is reflexive: x.equals(x) should return true.
Is symmetric: x.equals(y) should return true if and only if y.equals(x) returns true. Is transitive: if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) must return true. Is consistent: multiple invocations of x.equals(y) consistently return true or false, provided no information used in equals comparisons on the object is modified. For any non-null reference value x, x.equals(null) should return false.

Overriding hashCode()
Collections como HashMap and HashSet usan el hashcode de un objeto para determinar como debe ser almacenado en la colección, y luego es usado nuevamente para localizar el objeto en la colección.

Ver ej: OverridingHashCode.java Análisis: Dos objetos son iguales si tienen el mismo valor en x, y dos objetos con el mismo valor de x retornan hashcode idénticos. Esto es porque hashcode y equals se basan en la misma variable de isntancia x.

public int hashCode() {return name.length(); } public int hashCode() {return 4; } Son ambos legales? Cual será más rápido? El primer hashcode será un poco más rápido que el segundo. En general, mientras más unico sea el hashcode, más rápida será la recuperación de los elementos.

The hashCode() Contract
Siempre que hashcode() es invocado sobre el mismo objeto, debe retornar consistentemente el mismo entero. Si dos objetos son iguales, de acuerdo al método equals(Object), entonces la llamada al método hashCode() sobre cada uno de los dos objetos debe producir el mismo resultado. No es requerido que si dos objetos no son iguales de acuerdo al método equals(java.lang.Object), la llamada al método hashCode() debe producir resultados enteros distintos. Sin embargo, el programador debe tener cuidado de producir distintos resultados para objetos iniguales, lo cual podría mejorar el desempeño de hashtables.

The hashCode() Contract

Collections

Key Interfaces and Classes of the Collections Framework
Las 7 interfaces principales que se deben conocer para el examen: Collection Set SortedSet List Map SortedMap Queue

Key Interfaces and Classes of the Collections Framework
Las 13 clases concretas necesarias para el examen: Collections come in four basic flavors: Lists Lists of things (classes that implement List). Sets Unique things (classes that implement Set). Maps Things with a unique ID (classes that implement Map). Queues Things arranged by the order in which they are to be processed.

Esto es un poco confuso: Existen tres usos cobrecargados de la palabra "collection":
Collection (lowercase c), representa cualquier estructura de datos, en las cuales objetos son almacenados y sobre las cuales se itera. Collection (capital C), java.util.Collection interface de la cual extienden Set, List, and Queue. (extiende, no implementa). Collections (capital C and ends with s) es la clase java.util.Collections que almacena un conjunto de métodos estáticos.

The interface and class hierarchy for collections

Structure of a List, a Set, and a Map

Sorted, Unsorted, Ordered, Unordered
Una implementación de clase (colecciones) puede ser unsorted and unordered, ordered but unsorted, or ambas ordered and sorted. Pero una implementación nunca será sorted but unordered, porque sorted es un tipo específico de ordering.

Ordered Cuando una colección está ordenada, significa que se puede iterar através de ésta en un específico (no random) orden. Natural order: Para una colección de Strings el natural order es alafabético. Para Integers el natural order es por valor numérico (1,2,3..) y así.. Para objetos creados no existe natural order; el programdor debe proveerlo através de la interfaz Comparable o la interfaz Comparator, las cuales definen como instancias de una clase puede ser comparadas con otras.

Sorted Una colección sorteada es una en la cual el orden está determinado por reglas, conocidad como sort order. Un sort order no tiene nada que ver con el orden en que un objeto es añadido o con el acceso a este. Sorting es hecho basado en propiedades de los objetos en sí. Al colocar objetos en una coleccion, ésta entiende en que orden debe colocarlo, basado en un sort order.

List Interface List pone atención en los índices.
Tiene métodos relacionados con índices: get(int index), indexOf(Object o), add(int index, Object obj), etc. Las tres implementaciones de List: ArrayList, Vector, LinkedList, están ordenadas por posición del índice

List Interface: ArrayList, Vector, LinkedList
ArrayList: Rápida iteración y acceso aleatorio, pero no tan rápido para inserción y borrado. Ordenado (por índice) pero no sorted. Vector: basicamente lo mismo que un ArrayList, pero sus métodos son synchronized por thread safety. Usar ArrayList en vez de Vector porque los métodos synchronized añaden un desempeño que podria no ser necesario. Vector es la unica clase (además de ArrayList) que implementa RandomAccess.

List Interface: ArrayList, Vector, LinkedList
LinkedList: elementos son doblemente enlazados unos con otros. Este linkeamiento otorga nuevos métodos para añadir y remover al inicio o final, lo que lo convierte en una elección fácil para la aplicación de una pila o cola. Tenga en cuenta que una LinkedList puede iterar más lentamente que un ArrayList, pero es una buena elección cuando usted necesita rápida inserción y borrado. A partir de Java 5, LinkedList ha sido mejorado para impelmentar la interfaz java.util.Queue. Soporta métodos comunes de colas: peek(), poll(), and offer().

Set Interface Un Set no permite duplicados. Su buen amigo el método equals () permite determinar si dos objetos son idénticos (en cuyo caso sólo uno puede estar en el set). Los tres Conjunto implementaciones de Set son: HashSet, LinkedHashSet, TreeSet

Set Interface: HashSet, LinkedHashSet, TreeSet
HashSet: unsorted, unordered Set. Usa el hashcode del objeto insertado; mientras más eficiente el hashCode() mejor será el desempeño. Use esta clase cuando se quiere una colección sin duplicados y no importa el orden cuando se itera a través de el.

LinkedHashSet: es una versión ordenada de HashSet que mantiene un List doblemente linkeada a lo largo de todos los elementos. Cuando iteras a través de un HashSet el orden es impredecible, mientras un LinkedHashSet te permite iterar a través de los elementos en el orden en el cual ellos fueron insertados.

TreeSet: Es una de las dos colecciones sorted (la otra es TreeMap). Garantiza que los elementos estarán en orden ascendente, de acuerdo al orden natural. Opcionalmete se puede definir el otro orden usando Comparable or Comparator.

Map Interface Cuida la unicidad de los identificadores. Se mapea un key único a un valor, donde ambos por supuesto son objetos. Las clases son: HashMap, Hashtable, LinkedHashMap, TreeMap

Map Interface: HashMap, Hashtable, LinkedHashMap, TreeMap
HashMap: unsorted, unordered Map. Usarlo cuando no se necesita tener cuidado acerca del orden (durante la iteración). HashMap permite una clave null y múltiples valores null en una colección. Hashtable: Hashtable es la contraparte sincronizada de HashMap. No permite valores ni claves nulas.

Map Interface: HashMap, Hashtable, LinkedHashMap, TreeMap
LinkedHashMap: mantiene insertion order (or, optionally, access order). Aunque será un poco mas lento que HashMap para añadir y remover elementos, es más rápido para iteración. TreeMap: es un sorted Map. Es decir que por default es sorted por el orden natural de los elementos.

Queue Interface Está diseñada para almacenar una lista de cosas a ser procesadas de alguna manera. Queue tipicamnte son FIFO (first-in, first-out), aunque otros ordenamientos son posibles. Soportan todos los métodos estandares de Collections y además añaden métodos propios de las colas.

Queue Interface: PriorityQueue
El propósito de una PriorityQueue es crear una cola con “prioridad de entrada” y “prioridad de salida”, lo cual es opuesto a una típica cola FIFO. Los elementos de una cola de prioridad son ordenados por orden natural (en este caso los elementos sorteados primeros serán accesados primero) o también podría ser de acuerdo a un Comparator.

Collection Interface Concrete Implementation Classes

Using the Collections Framework
Sorting Collections Ver ejemplo TestArrayList.java The Comparable Interface La interfaz comparable es usada por los metodos Collections.sort() y el java.utils.Arrays.sort() para sortear Listas y arreglos respectivamente. Uso: int x = thisObject.compareTo(anotherObject); compareTo() retorna un int bajo las sigtes. Características: negative If thisObject < anotherObject zero If thisObject == anotherObject positive If thisObject > anotherObject

The Comparable Interface
El método sort() usa el método compareTo() para determinar como un Array o List debe ser sorteado. Ver ejemplo DVDInfo.java, TestDVD.java Solo se puede implementar una sola vez el método compareTo() en una clase, entonces: cómo conseguinmos sortear nuestras clases en un orden diferente al ya especificado?? R. Interfaz Comparator

Sorting with Comparator
Se puede utilizar la interfaz Comparator para sortear instancias de cualquier clase, aún los que no se pueden modificar. Es fácil de implementar, pues tiene un solo método: compare(). Uso: one.getGenre().compareTo(two.getGenre()); Ver ejemplo: DVDInfo.java, TestDVD.java, GenreSort

Comparing Comparable to Comparator

Sorting with the Arrays Class
El método Arrays.sort() es sobresscrito en la misma manera que el método Collections.sort(). Arrays.sort(arrayToSort) Arra ys.sort(arrayToSort, Comparator) El método Arrays.sort(), en caso de primitivos, siempre realiza el sort por orden natural. Recordar que los métodos sort() de las clases Collections y Arrays son estaticos, y que alteran los objetos que son sorteados en lugar de retornar un objeto diferente. Para sortear un arreglo o colección los elementos deben ser mutuamente

Searching Arrays and Collections
Las búsquedas se realizan con el método binarySearch(). Las búsquedas exitosas retornarán el índice del elemento que es buscado. Las búsquedas no exitosas retornarán un índice que representa un punto de inserción. binarySearch() usa númerso negativos para indicar puntos de inserción, el primer punto de inserción disponible es -1 Por lo tanto, el punto d einserción actual es representado como (-(insertion point) -1). Ej. Si el punto de inserción de una búsqueda fuera el elemento 2, el actual punto de inserción sería -3

La collection/array debe ser sorteado antes de poder buscar en él. Si intentas realizar una búsqueda sobre un collection/array que no ha sido sorted los resultados de la búsqueda serán impredecibles. Si la collection/array fue sorteada en natural order, la búsqueda debe ser en natural order. Si la collection/array fue sorteada usando un Comparator, la búsqueda debe ser realizada usando el mismo Comparator.

Ver ejemplo: SearchObjArray.java Exam Gotchas: 1. Searching an array or collection that hasn’t been sorted. 2. Using a Comparator in either the sort or the search, but not both.

Converting Arrays to Lists to Arrays
Las clses List y Set tienen el método toArray(), y la clase Arrays tiene un método llamado asList(). El método Arrays.asList() copia un arreglo dentro d eun lista. Cuando usas el método asList(), si actualizas el array o la lista, ambos se actualizan automáticamente. Ver ejemplo: ArraysToList.java

Using Lists Métodos iteradores:
boolean hasNext() : retorna verdadero si existe al menos un elemento más en la colección que está siendo recorrida. La invocación a hasNext() no te mueve al sigte. Elemento. object next() : retorna el siguiente elemento en la colección, y te mueve al elemento siguiente. Ver ejemplo: Dog.java

Using Sets Si intenta añadir un elemento existente en un set, el elemento no será añadido y el método add() retornará falso. Ver ejmplo: SetTest.java Es importante saber que el orden de impresión de los objetos en el segundo lazo no es predecible. HashSets y LinkedHashSets no garantizan ningún ordenamiento. Con respecto a TreeSet se debe recordar que es un Set cuyos elementos están sorteados, por lo tanto sus elementos deben ser mutuamente comparablea.

Using Maps Cualqueir clase que sea usada como key debe sobreescribir los métodos hashCode() y equals(). Ver ejemplo: MapTest.java La quinta salida es null. El método get() falla en encontrar el objeto Cat que fue insertado. Pero por qué cuando se usa una instancia de Dog como key si funciona?? Esto es porque Dog sobreescribe los métodos equals() y hashcode().

Using the PriorityQueue Class
Al contrario de una estructura básica de cola (FIFO), una PriorityQueue ordena sus elementos uasando una prioridad definida por el usuario. La prioridad puede ser simple como natural order. Además una PriorityQueue puede ser ordenada usando Comparator, el cual premite definir el orden que se requiera.

Using the PriorityQueue Class
Queues tienen método no encontrados en otras colecciones: Offer() añade elementos. peek() retorna el elemento de más alta priridad en la cola sin removerlo. poll() returns retorna el elemento de más alta priridad en la cola y lo remueve. Ver ejemplo: PQ.java

Method Overview for Arrays and Collections

Method Overview for List, Set, Map, and Queue

Generic Types

List myList = new ArrayList(); // can't declare a type
myList.add("Fred"); // OK, it will hold Strings myList.add(new Dog()); // and it will hold Dogs too myList.add(new Integer(42)); // and Integers… Una colección no-genérica puede almacenar cualquier tipo de Objetos (no primitivos).

Genericos prestan atención y cuidado en el tipo de datos durante las operaciones de añadir y sacar elementos de las colecciones. List<String> myList = new ArrayList<String>(); myList.add("Fred"); // OK, it will hold Strings myList.add(new Dog()); // compiler error!! String s = (String)myList.get(0); // pre-generics String s = myList.get(0); //wit-generics

for (String s : myList) {
int x = s.length(); } void takeListOfStrings(List<String> strings) { strings.add("foo"); // no problem adding a String } strings.add(new Integer(42)); // NO!! strings is type safe

List<Object> myList = new ArrayList<Object>();
Declarar una Lista con un tipo de parametro <Object> hace que la coleccion trabaje casi en el mismo modo que una coleccion no-generica (pre-java5), se puede colocar cualquier tipo de objeto en la colección.

Generics and Legacy Code
A pre-Java 5 List meant to hold only Integers: List myList = new ArrayList(); becomes List<Integer> myList = new ArrayList<Integer>(); and a list meant to hold only Strings goes from public List changeStrings(ArrayList s) { } to this: public List<String> changeStrings(ArrayList<String> s) { }

Mixing Generic and Non-generic Collections
Ver ejemplo: TestLegacy.java, Adder.java Es legal combinar código genérico con código no-genérico. En la clase Adder, el método addAll() asume/espera que la lista pasada este restringida solo a Integers, pero esto no está garantizado.

Ver ejemplo: TestLegacy.java -> método insert2()
El compilador no sabe si el método insert() está añadiendo el tipo correcto o incorrecto. La razón por la cual el compilador produce un warning es porque el método está añadiendo algo a la calección. En otras palabras el compilador solo sabe que existe la posibilidad de que se añada algo incorrecto.

Para la declaración: List<Integer> myList = new ArrayList<Integer>();
La JVM ve lo que siempre vio: List myList = new ArrayList(); El compilador siempre inserta el cast (el cast que dberiamos hacer si usaramos colecciones pre-java 5). Piensa en genéricos estrictamente como una protección en tiempo de compilación. Pero ninguna de estas protecciones existen en runtime. Usando genéricos es una protección en tiempo de compilación que garantiza que no insertes cosas erradas dentro de una colección, y elimina la necesidad de hacer cast cuando tomamos objetos de la colección.

Unboxing List test = new ArrayList(); test.add(43);
int x = (Integer)test.get(0); // you must cast !! List<Integer> test2 = new ArrayList<Integer>(); test2.add(343); int x2 = test2.get(0); // cast not necessary

Polymorphism and Generics
class Parent { } class Child extends Parent { } List<Parent> myList = new ArrayList<Child>(); It Work?? NO, existe una regla simple ---- el tipo de la variable de declaración debe concordar con el tipo que se le pasa al actual tipo de objeto. List<Animal> aList = new ArrayList<Animal>(); // yes List<Animal> aList = new ArrayList<Dog>(); // no

this is NOT how it works with arrays, import java.util.*; class Parent { } class Child extends Parent { } public class TestPoly { public static void main(String[] args) { Parent[] myArray = new Child[3]; // si permite polimorfismo }}

Polimorfismo en colecciones con genéricos solo puede ser aplicada en el "base" type (el tipo de clase colección). Ej. List<JButton> myList = new ArrayList<JButton>(); Set<Animal> mySet = new HashSet<Animal>();

Generic Methods Ver ejemplo: AnimalDoctor.java
Ver ejemplo: AnimalDoctorGeneric.java El compilador muestra los errores, pues simplemente no se puede asignar los ArrayLists de sustipos de Animal (<Dog>, <Cat>, or <Bird>) a un ArrayList del supertipo <Animal>.

Generic Methods public void foo() { Cat[] cats = {new Cat(), new Cat()}; addAnimal(cats); // no problem, send the Cat[] to the method } public void addAnimal(Animal[] animals) { animals[0] = new Dog(); // Eeek! We just put a Dog // in a Cat array! Este es el escenario que se busca prevenir…..asi sea un Array o un ArrayList. La diferencia es que el compilador te permite hacer esto con Arrays pero no con colecciones genéricas.

Generic Methods La razón por la cual este tipo d eproblema no aparece en compilación es porque está definido como una runtime exception (ArrayStoreException). Si intentas añadir un Cat a un objeto que actualemente es un Array de Dog, se obtenrdrá está excepcion. Es decir, en runtime la JVM conoce los tipos en los arrays, pero no el tipo de una colección.

public void addAnimal(List<Animal> animals) {
animals.add(new Dog()); // still OK as always } public static void main(String[] args) { List<Dog> animals = new ArrayList<Dog>(); animals.add(new Dog()); AnimalDoctorGeneric doc = new AnimalDoctorGeneric(); doc.addAnimal(animals); // THIS is where it breaks! El problema está en el método add(). Necesitamos una menera de decirle al compilador que prometemos no añadir nada a la colección.

WildCard syntax <?>
Permite a los métodos genéricos, aceptar subtipos (o supertipos) del tipo declarado en el argumento del método: void addD(List<Dog> d) {} // can take only <Dog> void addD(List<? extends Dog>) {} // take a <Dog> or <Beagle>

El keyword extends en el contexto de wildcard representa subclasses (o superclases) e implementaciones d einterfaces. No existe la sintaxis <? implements Serializable>. Sino: void foo(List<? extends Serializable> list) Cuando se utiliza un wildcard, List<? extends Dog>, la colecciónpuede ser accesada pero no modificada. Cuando usas un wildcard, List<?>, cualquier tipo generico puede ser asignado a la referencia, pero solo para acceso y no modificación.

the keyword super. public void addAnimal(List<? super Dog> animals) { animals.add(new Dog()); // adding is sometimes OK with super } public static void main(String[] args) { List<Animal> animals = new ArrayList<Animal>(); animals.add(new Dog()); AnimalDoctorGeneric doc = new AnimalDoctorGeneric(); doc.addAnimal(animals); // passing an Animal List Esto esencialmente le dice al compilador que acepte una Lista con tipos genérios, los cuales pueden ser de tipo Dog, o un supertipo de Dog. Nada más abajo en el arbol de herencia será permitido pero si cualquier cosa que está más arriba de Dog.

public void foo(List<?> list) { } public void foo(List<Object> list) { } Son iguales?? No, List<?>, donde el wildcard wildcard <?> sin el keyword extends or super, significa "any type.“ List<Object> es completamente diferente de List<?>. List<Object> significa que el método puede solo tomar una lista de Objetcs. Pero, List<? extends Object> and List<?> son absolutamente idénticos.

Cuáles compilarán??? 1) List<?> list = new ArrayList<Dog>(); 2) List<? extends Animal> aList = new ArrayList<Dog>(); 3) List<?> foo = new ArrayList<? extends Animal>(); 4) List<? extends Dog> cList = new ArrayList<Integer>(); 5) List<? super Dog> bList = new ArrayList<Animal>(); 6) List<? super Animal> dList = new ArrayList<Dog>(); 1, 2, and 5.

Generic Declarations Making Your Own Generic Class
public interface List<E> The <E> is a placeholder for the type you pass in. The List interface is behaving as a generic "template" (sort of like C++ templates), and when you write your code, you change it from a generic List to a List<Dog> or List<Integer>, and so on. The E, by the way, is only a convention. Any valid Java identifier would work here, but E stands for "Element," and it's used when the template is a collection. The other main convention is T (stands for "type"), used for, well, things that are NOT collections. boolean add(E o) In other words, whatever E is when you declare the List, that's what you can add to it.

Declaration conventions for generics use T for type and E for element:
public interface List<E> // API declaration for List boolean add(E o) // List.add() declaration q The generics type identifier can be used in class, method, and variable declarations: class Foo<t> { } // a class T anInstance; // an instance variable Foo(T aRef) {} // a constructor argument void bar(T aRef) {} // a method argument T baz() {} // a return type The compiler will substitute the actual type.

Making Your Own Generic Class
Ver ejemplo: CarRental.java You really don't want to make separate subclasses for every possible kind of rentable thing (cars, computers, bowling shoes, children, and so on). you can make the Rental class a generic type—a template for any kind of Rentable thing—and you're good to go

Ver ejemplo TestRental.java
Ver ejemplo UseTwo.java

Creating Generic Methods
But it's possible to define a parameterized type at a more granular level—a method. Imagine you want to create a method that takes an instance of any type, instantiates an ArrayList of that type, and adds the instance to the ArrayList. Using a generic method, we can declare the method without a specific type and then get the type information based on the type of the object passed to the method.

if you invoke the makeArrayList() method with a Dog
public class CreateAnArrayList { public <T> void makeArrayList(T t) { // take an object of an // unknown type and use a // "T" to represent the type List<T> list = new ArrayList<T>(); // now we can create the // list using "T" list.add(t); }} if you invoke the makeArrayList() method with a Dog instance, the method will behave as though it looked like this all along: public void makeArrayList(Dog t) { List<Dog> list = new ArrayList<Dog>(); }

The strangest thing about generic methods is that you must declare the type
variable BEFORE the return type of the method: public <T> void makeArrayList(T t) The <T> before void simply defines what T is before you use it as a type in the argument. You MUST declare the type like that unless the type is specified for the class. In CreateAnArrayList, the class is not generic, so there's no type parameter placeholder we can use. You're also free to put boundaries on the type you declare, for example if you want to restrict the makeArrayList() method to only Number or its subtypes (Integer, Float, and so on) you would say public <T extends Number> void makeArrayList(T t)

You can declare a generic method using a type not defined in the class:
public <T> void makeList(T t) { } is NOT using T as the return type. This method has a void return type, but to use T within the method's argument you must declare the <T>, which happens before the return type.

It’s tempting to forget that the method argument is NOT where you
declare the type parameter variable T. In order to use a type variable like T, you must have declared it either as the class parameter type or in the method, before the return type. The following might look right, public void makeList(T t) { } But the only way for this to be legal is if there is actually a class named T, in which case the argument is like any other type declaration for a variable. And what about constructor arguments? They, too, can be declared with a generic type, but then it looks even stranger since constructors have no return type at all: public class Radio { public <T> Radio(T t) { } // legal constructor }

classes or methods is to use a <
classes or methods is to use a <?> in the wildcard syntax rather than a type variable <T>, <E>, and so on. This code might look right, but isn’t: public class NumberHolder<? extends Number> { } While the question mark works when declaring a reference for a variable, it does NOT work for generic class and method declarations. This code is not legal: public class NumberHolder<?> { ? aNum; } // NO! But if you replace the <?> with a legal identifier, you’re good: public class NumberHolder<T> { T aNum; } // Yes

Objetivos de Certificación

Presentaciones similares

Presentación del tema: "Objetivos de Certificación"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

Objetivos de Certificación

Presentaciones similares

Presentación del tema: "Objetivos de Certificación"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback