Contenido del curso
Factory
El patron Factory es creacional, se utiliza para ayudar a la creación de nuevas instancias de objetos.
Jhon Alexander Romero Gonzaga
Estudiante
CASAREZ HINOSTROZA ANGEL ARIEL
Estudiante
Damian Castellini
Estudiante
María Sierra
Estudiante
Cristian Andres Ladino Peña
Estudiante
Carlos Eduardo Gomez García
Profesor
Luz Sthephany Granados Castro
Estudiante
Daniel Aristizabal castaño
Estudiante
Enrique Devars
Estudiante
Mauro Chojrin
Profesor
Muñoz Ortiz Leonel
Estudiante
GARCIA CAMARENA EZEQUIEL
Estudiante
Bernardo Aguayo Ortega
EstudianteMarines Millan
Estudiante
Sergio Estrella
Profesor
Diego Forero
Team Platzi
Massimo Di Berardino
Estudiante
Juan Sebastián Joya Rodríguez
Estudiante
César Cubillos
Estudiante
Luis Alberto Guerra Luis
Estudiante
Christian David Sánchez
EstudianteMuñoz Ortiz Leonel
Estudiante
ORLANDO GOMEZ DIVANTOQUE
Estudiante
Jonathan Sebastian Sanchez Sanabria
Estudiante
Usuario anónimo
User
Daniel Hurtado
Estudiante
Renzo Martín Staiti
Estudiante
Juan Pablo Campuzano Monsalve
Estudiante
JHEYSON EDUARDO AVENDAÑO HERNÁNDEZ
Estudiante
Manuel Ducos
Estudiante
Sergio Null
Estudiante
Oscar Jaramillo
EstudianteCon este se evita cambiar cada año el año de los autos del año actual:
<?php class Automobile { private $vehicleMake; private $vehicleModel; public function __construct($make, $model) { $this->vehicleMake = $make; $this->vehicleModel = $model; } public function getMakeAndModel() { return $this->vehicleMake.' - '.$this->vehicleModel; } } class AutomobileFactory { private static $model; public static function create($make) { self::$model = date('Y'); return new Automobile($make, self::$model); } } $renault = new Automobile("Renault", 2019); $toyota = AutomobileFactory::create("Toyota"); echo $renault->getMakeAndModel().PHP_EOL; echo $toyota->getMakeAndModel().PHP_EOL;
buen ejemplo
Este sería el ejemplo a utilizar, ya que de la otra forma estaríamos chocando bastante con solid...
Factory
Se trata de un patrón creacional, o sea, que nos ayuda a crear nuevas instancias de objetos.
El patrón factory consiste en utilizar una clase constructora abstracta con unos cuantos métodos definidos y otro(s) abstracto(s).
!Ejemlo de un UML para crear un Factory
Interesante resumen 💪
El patrón factory plantea simplificar una instancia, y eso lo podemos hacer por medio de otra clase que se encargue de obtener la instancia haciendo los procesos complejos requeridos, así ante cualquier cambio solo modificamos esa clase factory y no nos preocupamos por modificar cada una de las instancias.
Acá un buen ejemplo de patrón de diseño Factory 😎:
https://www.youtube.com/watch?v=lLvYAzXO7Ek&ab_channel=BettaTech
Muchas gracias, estuvo interesante el video.
¿Esto no sería hardcodear un poco el código?
¿Podrías explayarte un poco más? ¿Qué parte te parece hardcodeo?
Supongo que te refieres al año 2019, si es asi, eso se puede mejorar teniendo un metodo que indique el año.
Nota: es un patrón creacional es decir nos ayuda a la creación de nuevos objetos. El patrón se utiliza cuando la creación del objeto es un proceso muy completo, es decir recibe muchos parámetros o realiza funciones complejas al realización de la creación del objeto, con todo estamos logrando un código un poco más abstracto, reutilizable y sobre todo que podemos cambiar las formas en que creamos los modelos y a través de factoty no nos afectan estos cambios estamos ganando mas logita y la otra cosa que podría afectar es que si cambiamos una clase con el factory no nos afecta.
gracias!!
Este es el codigo de las laminas:
class Automobile { private $vehicleMake; private $vehicleModel; public function __contruct($make, $model) { $this->vehicleMake = $make; $this->vehicleModel = $model; } public function getMakeAndModel() { return $this->vehivle.Make.' '.$this->vehicleModel; } } class AutomobileFactory { private static $model = 2019; public static function create($make) { return new Automobile($make, self::$model); } } $a = new Automobile('Renault', 2019); $b = AutomobileFactory::create('Toyota');
¿Cuáles con las difrencias entre el patrón Factory y Abstract Factory?
Abstract Factory, permite trabajar con objetos de diferentes familias de manera que no se mezclen entre sí. De esa manera se consigue la el tipo de familia que se esté utilizando sea transparente. Un ejemplo la clase Disco que puede ser usada para crear discos de tipo Bluerays o tipo DVDs si bien tienen cosas en común hay otras que no como la capacidad.
Factory Method, centraliza en una clase constructora la creación de objetos de un tipo determinado. Ocultando al invocante la necesidad de indicar un tipo u otro. Un ejemplo puede ser la clase DVD todos los discos son iguales lo que cambia es el contenido, si es informaciuón o es una pelicula pero el disco es igual.
¡Hola Sergio! Te comparto este post donde se explica con mas detalle la diferencia. El resumen, Factory Method es un patrón aplicable a métodos los cuales puedes sobre escribir y cambiar su funcionalidad, en cambio Abstract Factory es un patrón de objetos o clases el cual implementa Factory Method
Acrode con lo que entendí, implementas una clase que te ayuda a hacer mas facil la creacion de instancias de otras clases.
Pregunta ¿el colocar el año ahí no sería harcoding o en qué casos algo se llama harcoding?
tambien tengo la misma duda
tienes razon. Es un dato cambiante y se estaría "harcodeando"
El metodo create de un factory siempre debe ser public static?
Al ser static simplifica su uso, ya que de otra forma habría que crear una instancia para luego si llamar el método.
Factory
Tambien llamado: Método fabrica o Constructor virtual
Qué es?
Factory method es un patrón de diseño creacional que resuelve el problema de crear objetos de producto sin especificar sus clases concretas, define un método que debe utilizarse para crear objetos, en lugar de una llamada directa al constructor (operador new). Las subclases pueden sobrescribir este método para cambiar las clases de los objetos que se crearán.
Para que sirve?
Cuando la creación de un objeto es algo muy complejo.
El patrón Factory Method separa el código de construcción de producto del código que hace uso del producto. Por ello, es más fácil extender el código de construcción de producto de forma independiente al resto del código.
Como se logra en código?
interface Product { operation(): string; }
La responsabilidad de esta clase no es crear productos, por lo general contiene alguna lógica de negocio, las subclases pueden cambiar indirectamente esa lógica.
Añada un patrón Factory Method vacío dentro de la clase creadora.
El tipo de retorno del método deberá coincidir con la interfaz común de los productos.
abstract class Creator { public abstract factoryMethod(): Product; public someOperation(): string { // Llame al método de fábrica para crear un objeto Producto. const product = this.factoryMethod(); // Ahora, usa el producto. return `Creator: The same creator's code has just worked with ${product.operation()}`; } }
class ConcreteProduct1 implements Product { public operation(): string { return '{Result of the ConcreteProduct1}'; } } class ConcreteProduct2 implements Product { public operation(): string { return '{Result of the ConcreteProduct2}'; } }
El método usa el tipo de producto abstracto, aunque el tipo de producto en realidad se devuelve en este método. De esta manera, el Creador puede permanecer independiente de las clases de productos concretas.
class ConcreteCreator1 extends Creator { public factoryMethod(): Product { return new ConcreteProduct1(); } } class ConcreteCreator2 extends Creator { public factoryMethod(): Product { return new ConcreteProduct2(); } }
function clientCode(creator: Creator) { // ... console.log('Client: I\'m not aware of the creator\'s class, but it still works.'); console.log(creator.someOperation()); // ... }
La aplicación elige el tipo de creador según la configuración o variables de entorno.
console.log('App: Launched with the ConcreteCreator1.'); clientCode(new ConcreteCreator1()); console.log(''); console.log('App: Launched with the ConcreteCreator2.'); clientCode(new ConcreteCreator2());
[LOG]: "App: Launched with the ConcreteCreator1." [LOG]: "Client: I'm not aware of the creator's class, but it still works." [LOG]: "Creator: The same creator's code has just worked with {Result of the ConcreteProduct1}" [LOG]: "" [LOG]: "App: Launched with the ConcreteCreator2." [LOG]: "Client: I'm not aware of the creator's class, but it still works." [LOG]: "Creator: The same creator's code has just worked with {Result of the ConcreteProduct2}"
Pros
Contra
En javascript sería algo así...
class Automovil { constructor(make, year) { this.make = make this.year = year } getAutomovil() { return console.log(`This Automovil is make ${this.make} and year ${this.year}`); } } class AutomovilFactory { constructor(make) { this.make = make } create() { const year = 2019; return console.log(new Automovil(this.make, year)); } } const automovil = new Automovil('Renault', 2018); automovil.getAutomovil(); const autoRefactory = new AutomovilFactory('Toyota'); autoRefactory.create();
Se podría usar este mismo patrón sin la necesidad de una nueva clase? Es decir agregar la función create dentro de la misma clase Automobile, O no sería recomendable?
No tiene mucho sentido el ejemplo, el 2019, lo vas a tener que cambiar en algun momento, vas a necesitar ese parametro. Ahora si me decis que ese año, depende de otra cosa, y te evitas tener que pasarlo cada vez que llamas a la clase, tiene todo el sentido. De ser asi, lo hubiese digavado mas al ejemplo. No harcodeando
Según lo investigado y anotado de otras fuentes, estás son mis notas:
El patrón de diseño Factory, también conocido como Factory Method, es un patrón creacional que se utiliza para delegar la lógica de creación de objetos a clases específicas, permitiendo de esta forma flexibilizar y centralizar la creación de objetos en una aplicación. El objetivo principal de este patrón es separar la construcción de objetos de su representación, haciendo que el código sea más modular y fácil de mantener. El patrón Factory se implementa típicamente de la siguiente manera: 1. **Interfaz de producto**: Define la interfaz de los objetos que el método fábrica creará.2. **Implementaciones concretas del producto**: Estas son clases que implementan la interfaz de producto y definen objetos específicos que serán creados por la fábrica.3. **Creador (o Factory)**: Esta es una clase que declara el método fábrica, el cual retorna objetos de tipo producto. Este método puede ser diseñado como abstracto, obligando a las subclases a definir cómo se crean los objetos, o puede retornar un tipo de producto predeterminado.4. **Creadores concretos**: Son subclases del creador que implementan el método fábrica para crear y retornar productos específicos. El uso del patrón Factory tiene varias ventajas: - **Flexibilidad**: Los clientes trabajan con interfaces para instancias de objetos, lo que permite cambiar las clases concretas de productos sin cambiar el código que usa los productos.- **Desacoplamiento**: Los clientes no necesitan saber cómo se crean y ensamblan los objetos; solo necesitan saber cómo interactuar con ellos a través de sus interfaces.- **Consolidación del código de creación**: Toda la lógica relacionada con la creación de los objetos se mantiene en un lugar, lo que facilita las actualizaciones y el mantenimiento. El patrón Factory es especialmente útil cuando hay un conjunto complejo de criterios para crear diferentes objetos, lo que puede incluir la elección de la clase de objeto a crear en tiempo de ejecución en base a ciertos parámetros. También es útil cuando el proceso de creación debe estar aislado del código principal para facilitar la futura expansión o mantenimiento sin modificar el código que utiliza los objetos.
como asi que el patron factory no es una cancion de la factoria?
un poco malo el ejemplo...ni siquiera está formateada ni resaltada la sintaxis y encima usa nombres poco semanticos en algunos casos de este y otros videos ($a, $vel, etc...)
Factory Method es un patrón de diseño creacional que proporciona una interfaz para crear objetos en una superclase, mientras permite a las subclases alterar el tipo de objetos que se crearán.
