Patrones de diseño por tutoriales: el poder de la programación orientada a objetos (parte 1)

Translation18 de octubre de 2019 a las 05:405 min read

El viaje de los patrones de diseño: el poder de la programación orientada a objetos 1

简体中文 العربية English Español Bahasa Indonesia Português

Patrones de diseño por tutoriales: el poder de la programación orientada a objetos (parte 1)

Requisitos previos: esta serie de blogs requiere un nivel intermedio de experiencia en programación orientada a objetos. Debe tener conocimientos básicos sobre clase, objeto, constructor, herencia, valor y tipo de referencia. Un intermedio adquirirá conocimientos y los expertos los perfeccionarán leyendo esta serie de principio a fin. Requisitos previos: esta serie de blogs requiere experiencia intermedia en programación orientada a objetos. Debe tener conocimientos básicos de clases, objetos, constructores, herencia, valores y tipos de referencia. Un intermedio adquirirá conocimientos y un experto perfeccionará sus conocimientos leyendo esta serie de principio a fin.

Los patrones de diseño se utilizan para representar las mejores prácticas adoptadas por la experimentada comunidad de desarrolladores de software orientado a objetos. Los patrones de diseño se utilizan para representar las mejores prácticas adoptadas por una comunidad de desarrolladores de software orientado a objetos con experiencia.

El patrón de diseño del constructor nos ayuda a construir un objeto de una manera más sencilla y legible. El patrón de diseño del constructor sigue dos reglas simples como se menciona a continuación. El patrón de diseño del constructor nos ayuda a construir objetos de una manera más sencilla y legible. El patrón de diseño del constructor sigue dos reglas simples, que se describen a continuación.

Separe la representación de clase original y sus métodos de construcción. Separe la representación de clase original y su constructor.
devuelve la instancia de la clase en el paso final Devuelve una instancia de la clase en el paso final.

El mejor ejemplo de un patrón de diseño de constructor es SwiftUI, sí, leíste bien. SwiftUI utiliza un patrón de diseño de constructor para la mayoría de sus clases, p. Texto, Imagen El mejor ejemplo de patrón de diseño de constructor es SwiftUI, sí, leíste bien. La mayoría de las clases en SwiftUI utilizan el patrón de diseño del constructor, como texto, imágenes, etc.

Problema: Pregunta:

Piense en la clase Persona que tiene diez o más propiedades, imaginando el diseño de su constructor cuando necesite crear una instancia de la clase Persona. Su constructor tomará diez o más argumentos, será difícil administrar tantos argumentos como una sola función o constructor y, eventualmente, perderá la legibilidad del código. consulte el siguiente ejemplo. Piense en esta clase, digamos que Persona tiene diez o más propiedades, cuando necesite crear una instancia de la clase Persona, imagine su diseño de constructor. Su constructor requiere 10 o más parámetros, que son difíciles de administrar como función o constructor y, eventualmente, pierdes la legibilidad de tu código. Mira el ejemplo a continuación.


WithoutDesignPatternExample1.swift:

class Person {
  //personal details
  var name: String = ""
  var gender: String = ""
  var birthDate: String = ""
  var birthPlace: String = ""
  var height: String = ""
  var weight: String = ""
  
  //contact details
  var phone: String = ""
  var email: String = ""
  
  //address details
  var streeAddress: String = ""
  var zipCode: String = ""
  var city: String = ""
  
  //work details
  var companyName: String = ""
  var designation: String = ""
  var annualIncome: String = ""
  
  //constructor
  init(name: String,
       gender: String,
       birthDate: String,
       birthPlace: String,
       height: String,
       weight: String,
       phone: String,
       email: String,
       streeAddress: String,
       zipCode: String,
       city: String,
       companyName: String,
       designation: String,
       annualIncome: String) {
    self.name = name
    self.gender = gender
    self.birthDate = birthDate
    self.birthPlace = birthPlace
    self.height = height
    self.weight = weight
    self.phone = phone
    self.email = email
    self.streeAddress = streeAddress
    self.zipCode = zipCode
    self.height = height
    self.city = city
    self.companyName = companyName
    self.designation = designation
    self.annualIncome = annualIncome
  }
}

//This is function in Xcode-Playground which executes our test code
func main() {
  let hitendra = Person(name: "Hitendra Solanki",
                        gender: "Male",
                        birthDate: "2nd Oct 1991",
                        birthPlace: "Gujarat, India",
                        height: "5.9 ft",
                        weight: "85kg",
                        phone: "+91 90333-71772",
                        email: "hitendra.developer@gmail.com",
                        streeAddress: "52nd Godrej Street",
                        zipCode: "380015",
                        city: "Ahmedabad",
                        companyName: "Fortune 500",
                        designation: "Software architect",
                        annualIncome: "45,000 USD")
  
  //use of Person object
  print("\(hitendra.name) works in \(hitendra.companyName) compay as a \(hitendra.designation).")
}

//call main to execute our test code in Xcode-Playground
main()

/* Console output:
Hitendra Solanki works in Fortune 500 compay as a Software architect.
*/

Intente ejecutar el ejemplo anterior en el patio de juegos, se ejecutará correctamente y le dará el resultado esperado. Lógicamente es correcto. Intente ejecutar el ejemplo anterior en el patio de juegos, se ejecutará correctamente y le dará el resultado esperado. Lógicamente correcto.

Podemos mejorar el ejemplo anterior superando los puntos siguientes. Podemos mejorar el ejemplo anterior superando los siguientes puntos.

Tenemos que pasar los valores en el orden mencionado, no podemos reordenar la secuencia de parámetros para mejorar la legibilidad. Debemos pasar los valores en el orden anterior, la secuencia de parámetros no se puede reordenar para mejorar la legibilidad.
Tenemos que pasar todos los valores, incluso si no conocemos algunos valores en el momento de la creación del objeto. Debemos pasar todos los valores, incluso si no conocemos algunos valores al crear el objeto.

P.ej. Supongamos que necesita crear un objeto de la clase Persona, pero la persona aún está encontrando trabajo. Cuando esa persona se incorpore a alguna empresa, solo nosotros tendremos los detalles del trabajo. Supongamos que necesita crear un objeto de clase Persona, pero el objeto todavía está buscando trabajo. Cuando esa persona se una a cualquier empresa, solo nosotros tendremos los detalles del trabajo.

Solución:

Cree grupos lógicos de propiedades relacionadas. Cree grupos lógicos de propiedades relacionadas.
Cree clases de constructores separadas para diferentes grupos de propiedades [ayuda en la normalización de propiedades, esto es opcional. Crear clases generadoras separadas para diferentes grupos de atributos [ayuda con la normalización de atributos, esto es opcional.
Recupere una instancia en el paso final. Se recupera una instancia en el paso final.

Simplifiquemos esto con un ejemplo, Simplifiquémoslo con un ejemplo,

Ya tenemos una clase llamada Persona en el ejemplo WithoutDesignPatternExample1.swift, en la que tenemos 14 propiedades. Si revisamos de cerca las 14 propiedades, las propiedades tienen 4 grupos lógicos. Por ejemplo, ya tenemos una clase llamada Persona sin patrón de diseño ejemplo1. Swift, tenemos 14 propiedades. Si examinamos cuidadosamente las 14 propiedades, hay 4 grupos lógicos de estas propiedades.

Propiedades de los datos personales Atributos de información personal

2.Propiedades de los datos de contacto Información de contacto propiedades

3.Propiedades de los detalles de la dirección Propiedades de detalles de dirección

Propiedades de detalles de la empresa Detalles de la empresa propiedades

El patrón de diseño Facetado y Fluido juntos nos ayuda a superar los dos problemas mencionados anteriormente. Los patrones de diseño Faceted y Fluent juntos nos ayudan a superar los dos problemas mencionados anteriormente.


BuilderDesignPattern[Faceted+Fluent]Example1.swift:

//This is function in playground which executes our test code
func main() {
  
  var hitendra = Person() //person with empty details
  let personBuilder = PersonBuilder(person: hitendra)
  
  hitendra = personBuilder
    .personalInfo
      .nameIs("Hitendra Solanki")
      .genderIs("Male")
      .bornOn("2nd Oct 1991")
      .bornAt("Gujarat, India")
      .havingHeight("5.9 ft")
      .havingWeight("85 kg")
    .contacts
      .hasPhone("+91 90333-71772")
      .hasEmail("hitendra.developer@gmail.com")
    .lives
      .at("52nd Godrej Street")
      .inCity("Ahmedabad")
      .withZipCode("380015")
    .build()
  
  //use of Person object
  print("\(hitendra.name) has contact number \(hitendra.phone) and email \(hitendra.email)")
  
  //later on when we have company details ready for the person
  hitendra = personBuilder
    .works
      .asA("Software architect")
      .inCompany("Fortune 500")
      .hasAnnualEarning("45,000 USD")
    .build()
  
  //use of Person object with update info
  print("\(hitendra.name) works in \(hitendra.companyName) compay as a \(hitendra.designation).")
}

//call main to execute our test code
main()

//Person class which only contains the details
class Person {
  //personal details
  var name: String = ""
  var gender: String = ""
  var birthDate: String = ""
  var birthPlace: String = ""
  var height: String = ""
  var weight: String = ""
  
  //contact details
  var phone: String = ""
  var email: String = ""
  
  //address details
  var streeAddress: String = ""
  var zipCode: String = ""
  var city: String = ""
  
  //work details
  var companyName: String = ""
  var designation: String = ""
  var annualIncome: String = ""
  
  //empty constructor
  init() { }
}

//PersonBuilder class helps to construct the person class instance
class PersonBuilder {
  var person: Person
  init(person: Person){
    self.person = person
  }
  
  //personal details builder switching
  var personalInfo: PersonPersonalDetailsBuilder {
    return PersonPersonalDetailsBuilder(person: self.person)
  }
  
  //contact details builder switching
  var contacts: PersonContactDetailsBuilder {
    return PersonContactDetailsBuilder(person: self.person)
  }
  
  //address details builder switching
  var lives: PersonAddressDetailsBuilder {
    return PersonAddressDetailsBuilder(person: self.person)
  }
  
  //work details builder switching
  var works: PersonCompanyDetailsBuilder {
    return PersonCompanyDetailsBuilder(person: self.person)
  }
  
  func build() -> Person {
    return self.person
  }
}

//PersonPersonalDetailsBuilder: update personal details
class PersonPersonalDetailsBuilder: PersonBuilder {
  func nameIs(_ name: String) -> Self {
    self.person.name = name
    return self
  }
  func genderIs(_ gender: String) -> Self {
    self.person.gender = gender
    return self
  }
  func bornOn(_ birthDate: String) -> Self {
    self.person.birthDate = birthDate
    return self
  }
  func bornAt(_ birthPlace: String) -> Self {
    self.person.birthPlace = birthPlace
    return self
  }
  func havingHeight(_ height: String) -> Self {
    self.person.height = height
    return self
  }
  func havingWeight(_ weight: String) -> Self {
    self.person.weight = weight
    return self
  }
}

//PersonContactDetailsBuilder: update contact details
class PersonContactDetailsBuilder: PersonBuilder {
  func hasPhone(_ phone: String) -> Self {
    self.person.phone = phone
    return self
  }
  func hasEmail(_ email: String) -> Self {
    self.person.email = email
    return self
  }
}

//PersonAddressDetailsBuilder: update address details
class PersonAddressDetailsBuilder: PersonBuilder {
  func at(_ streeAddress: String) -> Self {
    self.person.streeAddress = streeAddress
    return self
  }
  func withZipCode(_ zipCode: String) -> Self {
    self.person.zipCode = zipCode
    return self
  }
  func inCity(_ city: String) -> Self {
    self.person.city = city
    return self
  }
}

//PersonCompanyDetailsBuilder: update company details
class PersonCompanyDetailsBuilder: PersonBuilder {
  func inCompany(_ companyName: String) -> Self {
    self.person.companyName = companyName
    return self
  }
  func asA(_ designation: String) -> Self {
    self.person.designation = designation
    return self
  }
  func hasAnnualEarning(_ annualIncome: String) -> Self {
    self.person.annualIncome = annualIncome
    return self
  }
}

/* Console output:
 
 Hitendra Solanki has contact number +91 90333-71772 and email hitendra.developer@gmail.com
 Hitendra Solanki works in Fortune 500 compay as a Software architect.
 
 */

En el ejemplo anterior, hemos separado las responsabilidades de la clase Persona en diferentes clases. La clase de persona ahora solo contiene las propiedades de los datos, mientras que hemos creado múltiples clases de constructores que tienen responsabilidades para construir/actualizar el grupo relativo de propiedades. En el ejemplo anterior, dividimos las responsabilidades de la clase Persona en diferentes clases. La clase Persona ahora solo contiene atributos de datos y hemos creado varias clases de creación que son responsables de crear/actualizar grupos de atributos relacionados.Tenemos una clase de constructor base PersonBuilder y cuatro clases de constructor derivadas más llamadas PersonPersonalDetailsBuilder, PersonContactDetailsBuilder, PersonAddressDetailsBuilder y PersonCompanyDetailsBuilder. Tenemos una clase de constructor básica PersonBuilder y cuatro clases de constructor derivadas, a saber, PersonPersonalDetailsBuilder, PersonContactDetailsBuilder, PersonAddressDetailsBuilder y PersonCompanyDetailsBuilder.

La clase base PersonBuilder nos ayuda a cambiar entre varios constructores en cualquier momento, mientras que otros cuatro constructores derivados de PersonBuilder tienen la responsabilidad de actualizar las propiedades relativas. La clase base PersonBuilder nos ayuda a cambiar entre varios constructores en cualquier momento, mientras que los otros cuatro constructores derivados de PersonBuilder son responsables de actualizar las propiedades relacionadas.

En el ejemplo anterior, podemos ver claramente que la construcción de un objeto Persona es más legible en comparación con nuestro primer ejemplo WithoutDesignPatternExample1.swift. Además, podemos actualizar el grupo de propiedades o cualquier propiedad individual en cualquier momento de una manera más legible. En el ejemplo anterior, podemos ver claramente que la estructura del objeto Persona es mucho más legible en comparación con nuestro primer ejemplo.

En el ejemplo anterior, tenga en cuenta que devolvemos la instancia del constructor después de llamar a cada método de actualización de propiedad. Lo que nos ayuda a escribir encadenamiento de múltiples métodos del mismo constructor en lugar de escribir múltiples líneas por separado. Este concepto se conoce como patrón fluido. En el ejemplo anterior, tenga en cuenta que después de llamar a cada método de actualización de propiedad, devolvemos la instancia del generador. Esto nos ayuda a escribir encadenamientos de múltiples métodos del mismo generador en lugar de escribir múltiples líneas separadas. Este concepto se llama modo de coherencia.

Beneficios:

Inicialice fácilmente un objeto de una clase que tenga demasiadas propiedades de una manera más legible. Inicializa fácilmente un objeto de una clase con demasiadas propiedades, para una mejor legibilidad.
Sigue el principio de responsabilidad única. Siga el principio de responsabilidad única.
Inicialice el objeto o actualice las propiedades en cualquier orden según su conveniencia. Inicialice objetos o actualice propiedades en cualquier orden según su conveniencia.

Bono:

Para que el patrón del generador sea consistente en todo el proyecto, puede crear un protocolo como se muestra a continuación. Para que el patrón del generador sea coherente en todo el proyecto, puede crear un protocolo como el siguiente.