Corrige Factory<I>

Author: sio2sio2

source/03.xml/01.jaxp.rst

@@ -227,11 +227,11 @@ original.
 
 .. admonition:: Advertencia
 
-   El código incluye una variable ``ruta``, que es un objeto ``Path`` que
+   El código incluye una variable ``ruta``, que es un objeto |Path| que
    contiene la ruta del archivo |XML| en consonancia con :ref:`el ejemplo
    ilustrativo que escribimos sobre lectura <jaxp-read>`.
 
-   Si en cambio, ``ruta`` fuera una objeto ``URI`` podríamos obtener la cadena
+   Si en cambio, ``ruta`` fuera una objeto :java-net:`URI <URI>` podríamos obtener la cadena
    con la ruta del |DTD| de este otro modo:
 
    .. code-block:: java
@@ -365,13 +365,13 @@ si nuestra intención es usarla una sola vez:
 
 .. code-block:: java
 
-   Element profesor = (Element) xPath.evaluate("//profesor[@id='p81']", xml, XPathConstants.NODE); 
+   Element profesor = (Element) xPath.evaluate("//profesor[@id='p81']", xml, XPathConstants.NODE); // Mejor que NODESET, porque sabemos que es único
    System.out.println(profesor.getTagName());  // profesor
    
    String apelativo = (String) xPath.evaluate("//profesor[@id='p81']/apelativo", xml, XPathConstants.STRING); 
    System.out.println(apelativo);  // Verónica
 
-   int cantidad = ((Double) xPath.evaluate("count(//profesor)", xml, XPathConstants.STRING)).intValue();
+   int cantidad = ((Double) xPath.evaluate("count(//profesor)", xml, XPathConstants.NUMBER)).intValue();
    System.out.println(cantidad);
 
 .. rubric:: Notas al pie
@@ -394,3 +394,4 @@ si nuestra intención es usarla una sola vez:
 .. |NodeList| replace:: :java-jaxp:`NodeList`
 .. |NamedNodeMap| replace:: :java-jaxp:`NamedNodeMap`
 .. |Document| replace:: :java-jaxp:`Document`
+.. |Path| replace:: :java-nio:`Path`

source/98.apendices/01.funcional/01.function.rst

@@ -161,14 +161,14 @@ definidas que podemos usar:
    (los genéricos ``T`` y ``U``).
 
 :java-function:`BinaryOperator<T> <BinaryOperator>`
-   Como el anterior, pero los tres tipos deben iguales (el genérico ``T``).
+   Como el anterior, pero los tres tipos deben ser iguales (el genérico ``T``).
 
 :java-function:`Predicate<T> <Predicate>`
    Toma un argumento de entrada (el genérico ``T``) y devuelve un valor
    booleano. Para aplicarla debe ejecutarse el método ``test`` (no ``apply``).
 
 :java-function:`BiPredicate<T, U> <BiPredicate>`
-   Como el anterior, pero toma dos argumento de entrada.
+   Como el anterior, pero toma dos argumentos de entrada.
 
 :java-function:`Consumer<T> <Consumer>`
    Toma un argumento de entrada (el genérico ``T``) y no devuelve ningún valor.

source/98.apendices/01.funcional/05.collection.rst

@@ -32,7 +32,7 @@ Collection
 ==========
 :java-util:`Collection` es una interfaz que representa un grupo de objetos, cada
 uno de los cuales se llama "elemento". Dependiendo de implementaciones más
-específicas los elementos podrán estar ordenador (:java-util:`List`) o
+específicas los elementos podrán estar ordenados (:java-util:`List`) o
 desordenados (:java-util:`Set`).
 
 .. image:: files/Collection.png

source/98.apendices/05.pattern.rst

@@ -121,29 +121,35 @@ sirva en cualquier aplicación:
    :language: java
    :class: toggle
    :caption: Clase Factory
-   :start-at: public class
+   :start-at: public class Factory
 
 La principal diferencia (además de ser mucho más complicado que el anterior) es
-que esta clase sí se instancia con el constructor ``Factory(String packageName,
-Class<I> interfaceClass)`` para indicar en qué paquete se encuentran las clases
-que implementan la interfaz y cuál es esta. En el ejemplo de nuestros
-traductores:
+que esta clase sí se instancia con el constructor ``Factory(Class<I>, String)``
+para indicar cuál es la interfaz implementada y en qué paquete se encuentran las
+clases que la implementan.  En el ejemplo de nuestros traductores:
 
 .. code-block:: java
 
-   Factory<Traductor> trFactory = new Factory<>("edu.acceso.ejemplo.traductor", Traductor.class);
+   Factory<Traductor> factory = new Factory<>(Traductor.class, "edu.acceso.ejemplo.traductor");
+
+Ahora bien, si se coloca la interfaz en el mismo paquete que las clases, se
+puede omitir el segundo argumento:
+
+.. code-block:: java
+
+   Factory<Traductor> factory = new Factory<>(Traductor.class);
 
 La creación de este objeto *Factory* provoca que gracias a la reflexión se
 analice el paquete y se localicen las clases que implementan la interfaz
 (``Traductor`` en este caso). El objetivo es relacionar estas clases con su
 nombre y, en su caso, con los nombres alternativos contenidos en el atributo
-``aliases``. Por ejemplo:
+``alias``. Por ejemplo:
 
 .. code-block:: java
 
    public class TYaml implements Traductor {
       // También podría ser String si sólo hay una alternativa
-      private static final String[] = {"yml", "yaml"};
+      private static final String[] alias = {"yml", "yaml"};
 
       // Implementación de la traducción para YAML...
    }
@@ -157,11 +163,34 @@ traducción, nos bastaría con hacer:
 
    String formato = "yml"; // Por ejemplo.
 
-   Factory<Traductor> trFactory = new Factory<>("edu.acceso.ejemplo.traductor", Traductor.class);
-   Traductor traductor = trFactory.getObject(formato);
+   // Suponemos que Traductor y TYaml están en el mismo paquete.
+   Factory<Traductor> factory = new Factory<>(Traductor.class);
+   Class<? extends Traductor> traductorClass = factory.get(formato);
+
+Y ya tendríamos disponible la clase que implementa |YAML| para instanciarla
+cuando nos sea necesario. También existe la posibilidad de pedir directamente la
+instancia:
+
+.. code-block:: java
+
+   Traductor traductor = factory.getInstance(formato);
+
+.. caution:: Este método sólo funcionará si el constructor de las clases no
+   tiene argumentos y, además, la construcción no tiene dependencias cruzadas
+   en el programa. Por ejemplo, si utilizamos :ref:`una clase para gestionar la
+   configuración de usuario <cliargs>` es probable que echemos mano de esta
+   clase ``Factory``. Si el constructor del traductor hace
+   uso a su vez de la configuración entonces tendremos una dependencia circular:
+   para construir el objeto de configuración necesitamos un objeto traductor,
+   pero para construir un objeto traductor necesitamos la configuración.
+
+   Por lo general es más seguro obtener la clase del traductor e instanciar
+   nosotros luego. Justamente en el caso anterior, podríamos obtener la clase
+   del traductor para definir el atributo del objeto ``Config`` y en el *getter*
+   de ese atributo, hacer la instanciación.
 
-La clase tiene, además, dos métodos adicionales que sirven básicamente para
-brindar información:
+La clase tiene, además, otros dos métodos adicionales que sirven básicamente
+para brindar información:
 
 ``getClasses()``
    que devuelve un mapa en que las claves son las cadenas y los valores las
@@ -171,15 +200,4 @@ brindar información:
    que devuelve un mapa en que cada clave es una clase y los valores un array
    con todos los nombres con los que está relacionada.
 
-.. warning:: El ćodigo tiene una limitación: el constructor de las clases no
-   puede tener argumentos. En caso de que debiera tenerlos, no obstante, es
-   fácil soslayar la limitación: bastaría con incluir en la interfaz un método
-   inicializador. Por ejemplo:
-
-   .. code-block:: java
-
-      public interface Foobar {
-
-         public void initialize( /* Los argumentos que sea */ );
-         // Resto de métodos que definen la interfaz.
-      }
+.. |YAML| replace:: :abbr:`YAML (YAML Ain't Markup Language)`