Breaking News: Grepper is joining You.com. Read the official announcement!

factory design pattern

Add Answer

ruperto2770 answered on May 26, 2021 Popularity 1/10 Helpfulness 1/10

answer factory design pattern

related where design pattern factory is used

related Factory Pattern

related factory design pattern

factory design pattern

Comment

Factory pattern 
- a DP (design pattern) that may be the chosen solution approach by an app architect. 
- there are factory functions and there are factory classes. 
- - A factory class could be used to return a customized object (based on args)

In terms of code readability, factory pattern reveals the exact nature of the new object 
we are creating. Also using this DP makes it easier to organize back-end development.

Popularity 1/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: factory whatever

Link to this answer
Share Copy Link

Contributed on Dec 26 2021

ruperto2770

0 Answers Avg Quality 2/10

Closely Related Answers

where design pattern factory is used

Comments(1)

where design pattern factory is used

The Factory Method pattern is generally used in the following situations: A class cannot anticipate the type of objects it needs to create beforehand. A class requires its subclasses to specify the objects it creates. You want to localize the logic to instantiate a complex object.

The factory design pattern is used when we have a superclass with multiple sub-classes and based on input, we need to return one of the sub-class. This pattern takes out the responsibility of the instantiation of a class from the client program to the factory class.

The Factory Method design pattern is used by first defining a separate operation, a factory method, for creating an object, and then using this factory method by calling it to create the object. This enables writing of subclasses that decide how a parent object is created and what type of objects the parent contains.

Popularity 10/10 Helpfulness 2/10 Language whatever

Source: Grepper

Tags: factory

Link to this answer
Share Copy Link

Contributed on May 26 2021

Grieving Gentoo

0 Answers Avg Quality 2/10

Factory Pattern

Comment

public interface IShape
{
    void Draw();
}

public class Circle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

public class Square : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a square.");
    }
}

public class ShapeFactory
{
    public IShape CreateShape(string shapeType)
    {
        if (shapeType.Equals("Circle", StringComparison.OrdinalIgnoreCase))
        {
            return new Circle();
        }
        else if (shapeType.Equals("Square", StringComparison.OrdinalIgnoreCase))
        {
            return new Square();
        }
        else
        {
            throw new ArgumentException("Invalid shape type.");
        }
    }
}

Popularity 10/10 Helpfulness 2/10 Language csharp

Source: chat.openai.com

Tags: c# c

Link to this answer
Share Copy Link

Contributed on Jul 30 2023

mahnaz foroutan

0 Answers Avg Quality 2/10

factory design pattern

Comment

from abc import ABC, abstractmethod


class MazeGame(ABC):
    def __init__(self) -> None:
        self.rooms = []
        self._prepare_rooms()

    def _prepare_rooms(self) -> None:
        room1 = self.make_room()
        room2 = self.make_room()

        room1.connect(room2)
        self.rooms.append(room1)
        self.rooms.append(room2)

    def play(self) -> None:
        print(f"Playing using {self.rooms[0]}")

    @abstractmethod
    def make_room(self):
        raise NotImplementedError("You should implement this!")


class MagicMazeGame(MazeGame):
    def make_room(self) -> "MagicRoom":
        return MagicRoom()


class OrdinaryMazeGame(MazeGame):
    def make_room(self) -> "OrdinaryRoom":
        return OrdinaryRoom()


class Room(ABC):
    def __init__(self) -> None:
        self.connected_rooms = []

    def connect(self, room: "Room") -> None:
        self.connected_rooms.append(room)


class MagicRoom(Room):
    def __str__(self) -> str:
        return "Magic room"


class OrdinaryRoom(Room):
    def __str__(self) -> str:
        return "Ordinary room"


ordinaryGame = OrdinaryMazeGame()
ordinaryGame.play()

magicGame = MagicMazeGame()
magicGame.play()

Popularity 10/10 Helpfulness 1/10 Language python

Source: en.wikipedia.org

Tags: factory

Link to this answer
Share Copy Link

Contributed on Nov 06 2022

Rois Cordova

0 Answers Avg Quality 2/10

factory design pattern

Contents

More Related Answers

factory design pattern

Closely Related Answers

where design pattern factory is used

Factory Pattern

factory design pattern

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.