Factory Method
Clase 9 de 24 • Curso de Patrones de Diseño de Software 2016
Contenido del curso
Christian Armando Consuelo Mayén
student•
hace 11 años
Christian Armando Consuelo Mayén
student•
hace 11 años
Clase 9 de 24 • Curso de Patrones de Diseño de Software 2016
Contenido del curso
Christian Armando Consuelo Mayén
Christian Armando Consuelo Mayén
Carlos Alberto Romero Díaz
Sergio Parada Silva Parada Silva
Juan Ignacio Benítez Carbonell
Roberto Prince
Roberto Prince
Juan Carlos Correa Herrera
Juan Carlos Correa Herrera
JESUS ALMIRCAR CASTELLANOS
JESUS ALMIRCAR CASTELLANOS
Jesus Gutierrez
Miguel Sosa
Jose Andres Gonzalez Guevara
Mire, encontré esta gran página para referencia de cada uno de los patrones de diseño vistos en este curso. Espero les sirva de algo. =)
Perdonen, la liga lo copié mal. La liga es esta:
MyFactory está violando el OCP (open closed principle).
¿Qué pasa si queremos agregar otro tipo de auto? tenemos que abrir la clase.
tendrías que crear otra clase con la cual especificas el tipo que quieres de auto , darle un nombre y una velocidad lo pones en el Factory el el If y ya te lo reconoce como un tipo mas sin violar ningún principio
Estoy usando el patrón factoryMethod en JS, mi duda es, el factory puede tener funciones propias, que heredarían los concreteProduct, a parte de las de creación?
yo lo hice en typescript, seria igual en javascript ES6 menos los tipos como name:string
class Car{
name:string
maxspeed:string
constructor(){
this.name = null
this.maxspeed = null
}
toString() :string {
return `Name is ${this.name}, max speed is ${this.maxspeed}`
}
}
class SportCar extends Car{
constructor(){
super()
this.name = 'Deportivo'
this.maxspeed = '250 km/hr'
}
}
class FamilyCar extends Car{
constructor(){
super()
this.name = 'Familiar'
this.maxspeed = '170 km/hr'
}
}
class MyFactory {
car: Car
constructor(){
this.car = null
}
createCar(carType: string){
carType = carType.toLowerCase()
if (carType === 'sports') {
this.car = new SportCar
}else if(carType === 'family'){
this.car = new FamilyCar
}else{
console.error(`Car type ${carType} is not supported`)
}
return this.car
}
doSomething(){
console.log(this.car.toString())
}
}
let myFactory = new MyFactory
let s = myFactory.createCar('sports')
let f = myFactory.createCar('family')
console.log(s.toString())
console.log(f.toString())
mi implementacion con functiones de javascript
function createCar(carType){
const types = {
'sports' : sportsCar,
'family' : familyCar
}
return types[carType]();
}
function carToString(){
return `Name is ${this.name}, max speed is ${this.maxSpeed}`
}
function sportsCar(){
return {
name:'Deportivo',
maxSpeed:'250 km/hr',
toString: carToString
}
}
function familyCar(){
return {
name:'Familiar',
maxSpeed:'170 km/hr',
toString: carToString
}
}
let s = createCar('sports')
let f = createCar('family')
console.log(s.toString())
console.log(f.toString())
Javascript es super lindo si lo sabes utilizar y no estas obsesionado con clases
Aquí el código en Php con algunas modificaciones, por ejemplo el uso de switch en lugar de if ya que python no soporta este último; y un método adicional que sólo imprime un mensaje en pantalla:
<?php abstract class Car { protected $name; protected $max_speed; public function __construct($name, $max_speed) { $this->name = $name; $this->max_speed = $max_speed; echo "name is {$this->name} and max speed is {$this->max_speed}"; } public abstract function startEngine(); } class SportCar extends Car { public function __construct($name, $max_speed) { parent:: __construct($name, $max_speed); } public function startEngine() { return 'Wow! Listen to that engine'; } } class FamilyCar extends Car { public function __construct($name, $max_speed) { parent:: __construct($name, $max_speed); } public function startEngine() { return 'Well, not bad this sound'; } } class Factory { public static function createCar($car, $name, $max_speed) { switch ($car) { case 'SportCar': return new SportCar($name, $max_speed); break; case 'FamilyCar': return new FamilyCar($name, $max_speed); break; default: return 'Error'; break; } } } $sportcar = Factory::createCar('SportCar', 'mustang', 350); echo $sportcar->startEngine(); ?>
Incluso puedes abstraer más los métodos en común que vayan a implementar las clases hijas, pero que se ejecutarán de diferente modo en cada una de las clases hijas.
Por ejemplo, todos los carros arrancan, pero arrancan diferente.
Para esto usas una interfaz. Modificando el código anterior, queda así:
<?php interface iCar { public function startEngine(); } abstract class Car implements iCar { protected $name; protected $max_speed; public function __construct($name, $max_speed) { $this->name = $name; $this->max_speed = $max_speed; echo "name is {$this->name} and max speed is {$this->max_speed}"; } } class SportCar extends Car { public function __construct($name, $max_speed) { parent:: __construct($name, $max_speed); } public function startEngine() { return 'Wow! Listen to that engine'; } } class FamilyCar extends Car { public function __construct($name, $max_speed) { parent:: __construct($name, $max_speed); } public function startEngine() { return 'Well, not bad this sound'; } } class Factory { public static function createCar($car, $name, $max_speed) { switch ($car) { case 'SportCar': return new SportCar($name, $max_speed); break; case 'FamilyCar': return new FamilyCar($name, $max_speed); break; default: return 'Error'; break; } } } $mustang = Factory::createCar('SportCar', 'mustang', 350); echo $mustang->startEngine(); $mamamovil = Factory::createCar('FamilyCar', 'mamamovil', 100); echo $mamamovil->startEngine(); ?>
La ventaja de usar interface es que defines mejor la lógica de tus clases, abstraes los métodos que todas deben forzosamente tener y cuando añadas más funcionalidad (acelerar, frenar, girar, etc) simplemente lo agregas a la interfaz y todas las clases lo heredarán. Es más efectivo ❤️
Participantes del Factory Method
Definición del patrón Factory Method
Muy deficiente la clase, deben invertir mas tiempo en preparar los materiales y los ejemplos que proponen, con carros, animales y pizzería no se le ve ninguna utilidad a los patrones de diseño, al contrario, se vuelve muy complejo entender el sentido de usar un patrón de diseño con esos ejemplos tan terribles
Yo creo que para ejemplificar los patrones de diseño, los ejemplos están perfectos, ya si necesitas saber cómo utilizarlos y dónde eso depende de tus necesidades.
Cómo lo ejemplificarías tú?
ZZzz