Padrões de design são soluções diferentes para problemas de engenharia de software. Softwares podem ser construídos sem eles, mas é muito mais difícil.
Estarei lançando uma série de três partes relativas a padrões de design. Neste post, estarei discutindo sobre Padrões de design criativos.

Padrões de design criativos são padrões de design que lidam com mecanismos de criação de objetos, tentando criar objetos de uma maneira adequada à situação. A forma básica de criação de objectos pode resultar em problemas de design ou em complexidade acrescida ao design. Os padrões de design criativo resolvem este problema controlando de alguma forma a criação deste objecto.
Source: wikipedia.org

Aqui vamos discutir os cinco padrões de design criativo e como podemos usá-los no swift.

Este tipo de padrão de design é usado para instanciar um novo objecto através da clonagem de um objecto existente chamado protótipo.

Vemos uma função de clonagem abstrata do protocolo Fruit implementada pela classe Apple que realmente retorna o próprio objeto atual.

Deixe-nos rodar o código acima no playground.

// Create a prototype
let prototype = Apple(count: 4)// Create a copy of existing object
let redApple: Apple = prototype.clone() as! Apple
redApple.count // 4// add own properties
redApple.set(price: "")
redApple.price // // Create a copy of existing object
let greenApple: Apple = prototype.clone() as! Apple
greenApple.count // 4// add own properties
greenApple.set(price: "")
greenApple.price // 

– Quando você clona um objeto, todas as propriedades desse objeto são copiadas para
um outro objeto.
– Este padrão de desenho deve ser usado quando você precisa criar um objeto sem conhecer a hierarquia daquela classe

O Padrão do Método de Fábrica

É o padrão de desenho mais comumente usado. Basicamente, ele apenas abstrai a criação de um objeto.

Criar uma classe chamada FruitFactory que retorna o tipo do objeto necessário.
Adicionar um método estático que aceita um enumero chamado FruitType como parâmetro e retorna o objeto necessário em tempo de execução.

Uma instância retornada pela fábrica seria do tipo Interface(em protocolo rápido) que qualquer classe candidata de fábrica deve ter implementado.

Após executar o código acima no playground:

// get the object of class Orange from the FruitFactory class
let orange = FruitFactory.getFruit(forType: .orange)
orange?.getPrice() // "
orange?.getCount() // 2// get the object of class Grapes from the FruitFactory class
let grapes = FruitFactory.getFruit(forType: .grapes)
grapes?.getPrice() // ""
grapes?.getCount() // 1

– O tipo do objeto criado é determinado em tempo de execução.
– Este padrão de design torna a base de código mais flexível para adicionar ou remover novos tipos.

Isto nos introduz ao conceito de programa para uma interface, não para uma implementação.

Este padrão de design fornece uma interface para criar famílias de objetos relacionados sem especificar suas classes concretas. Eles são frequentemente implementados com o padrão Factory Method.

Temos uma fábrica abstrata chamada Furniture Factory para a criação de diferentes produtos. A classe concreta Factory Factory estará implementando o protocolo Furniture Factory.

Executando o código acima.

// create MyChair class object
let chair = Factory.createChair()
chair.count() // 4// create MyTable class object
let table = Factory.createTable()
table.count() // 1

– Revela a interface, não a sua implementação
– Abstract Factory é como um protocolo que iremos utilizar numa classe concreta para criar objectos

Padrão Construtor

Este padrão de design separa o processo de criação de objectos do seu uso real.

Primeiro declaramos um protocolo (ou interface) abstracto para a criação do produto. Neste caso é o protocolo ShoeShop.
Class Nike é um construtor de concreto para encapsular o processo de criação do produto.

Diretor cria o objeto usando o protocolo construtor. Diretor deve ser inicializado com objeto que esteja de acordo com o protocolo ShoeShop.

Após executar o código.

// create a nike object
let nike = Nike()// instantiate Director with nike object
let director = Director(shoeShop: nike)// encapsulated the process of producing the nike product
director.produce() // "Shoe produced"

– Use o padrão Builder ao construir APIs públicas porque não revela os detalhes de implementação
– Esconde a complexidade. Ele fornece uma API simples por trás de uma tarefa complexa.

Padrão de Projeto de um Único Botão

Em rápido definimos classes de Singleton usando a palavra-chave estática. Isso significa que o objeto vai ser instanciado apenas uma vez. As propriedades estáticas são inicializadas preguiçosamente e não serão instanciadas até serem chamadas.
Existe apenas uma cópia deste objeto e é utilizada pelos outros objetos globalmente.

Vemos o uso em frameworks Apple também:

// Shared url session
let urlSession = URLSession.shared// user defaults
let userDefaults = UserDefaults.standard

Após executar o código

Vehicle.sharedInstance.getName() // "Car"

– Usamos a palavra-chave let para ter certeza de que o valor do shredInstance não mudará
– Não se esqueça de adicionar o inicializador privado para evitar que outras classes chamem seus inicializadores padrão

Aqui está o link para os arquivos do playground.

A principal razão pela qual usamos o Creational Design Pattern é para desacoplar a lógica de criação de um objeto do seu uso. Ele ajuda a reduzir as complexidades criando objetos de forma controlada com as já mencionadas & soluções testadas.

Para ler sobre padrões de design comportamental, aqui está o link para o blog.