El método de fábrica se utiliza para ofrecer una sola interfaz para instanciar una de las múltiples clases. En el patrón Factory , el objetivo es hacer que el objeto no se exponga a la lógica de creación del Cliente y siempre pueda hacer referencia a un objeto recién creado con la ayuda de una interfaz común.
Tratemos de entenderlo con un ejemplo.
Supongamos que necesitamos crear una biblioteca para una aplicación de compra de automóviles. Se supone que la biblioteca ofrece tres opciones de tipos de automóviles.
- Estándar
- De lujo
- Lujo
Estamos siguiendo un diseño orientado a objetos y, por lo tanto, decidimos crear tres clases diferentes. Uno para cada tipo de coche. También queremos proporcionar métodos para obtener el precio de la reserva, las marcas y la disponibilidad. Las tres clases implementarán sus métodos individualmente, pero tenemos que decidirnos por un método simple para crear un objeto Car. Para que todos los autos se puedan comprar usando el mismo método. Aquí tienes un ejemplo de cómo queremos reservar un coche. la primera declaración devuelve una instancia de un automóvil estándar. la segunda declaración devuelve un auto de lujo y la tercera da un auto de lujo. en este caso estamos ofreciendo un solo método para crear una variedad de objetos. el método Car aquí es una fábrica de Cars. podemos reservar el tipo de coche que necesitemos y tantos como queramos. este tipo de creación de objetos hace que la programación sea muy fácil y los códigos compactos. uno no necesita preocuparse por las diferentes clases para diferentes tipos de automóviles. De eso se trata un método de fábrica.
// Scala program of Design factory pattern
// creating abstract class for the car
abstract class Car{
// Creating four abstract methods
def bookingPrice : Double
def Brands : List[String]
def availability : Int
def book(noOfCars:Int)
}
// Creating an object
object Car{
val STANDARD = 0
val DELUXE = 1
val LUXURY = 2
// Creating private class
private class standardCar extends Car{
private var _availability = 100
override def bookingPrice = 200000
override def Brands = List("Maruti", "Tata", "Hyundai")
override def availability = _availability
override def book(noOfCars:Int) = {
_availability = _availability - noOfCars
}
}
// Creating private class
private class DeluxeCar extends Car{
private var _availability = 50
override def bookingPrice = 500000
override def Brands = List("Honda", "Mahindra", "Chevrolet")
override def availability = _availability
override def book(noOfCars:Int) = {
_availability = _availability - noOfCars
}
}
// Creating private class
private class LuxuryCar extends Car{
private var _availability = 5
override def bookingPrice = 900000
override def Brands = List("Audi","BMW", "Mercedes")
override def availability = _availability
override def book(noOfCars:Int) = {
_availability = _availability - noOfCars
}
}
// create the apply method
// single method to create a variety of objects
def apply(carType:Int):Car = {
carType match {
case LUXURY => new LuxuryCar()
case DELUXE => new DeluxeCar()
case STANDARD => new standardCar()
case _ => new standardCar()
}
}
// Main method
def main(args: Array[String])
{
val s = Car(STANDARD)
println(s.bookingPrice)
println(s.availability)
}
}
Producción:
200000.0 100
Por lo tanto, el método de fábrica ayuda mucho a facilitar los conceptos de programación. De esta forma, siempre podemos guardar el espacio de códigos y el número de clases si declaramos varios objetos del mismo tipo con algunas diferencias.
Publicación traducida automáticamente
Artículo escrito por ShikharMathur1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA