Beispiel zur detaillierten Erklärung des Factory Methodenmodells im Android-Programmierungsentwurf

Dieser Artikel beschreibt das Factory Method Pattern im Android-Programmierungsdesign. Hiermit teilen wir es mit Ihnen zur Referenz, wie folgt:

Eins, Einführung

Das Factory Method Pattern ist eines der Erzeugungsmuster. Das Factory Method Pattern ist ein einfaches Strukturmuster und wird in unserem täglichen Entwicklungsalltag sehr häufig verwendet. Vielleicht wissen Sie es nicht, aber Sie haben dieses Muster bereits unzählige Male verwendet, wie z.B. die verschiedenen Lebenszyklummethoden in den Activitys von Android, um das onCreate-Methodbeispiel zu nennen, die als Factory Method angesehen werden kann. Wir können darin unsere View konstruieren und durch setContentView an das Framework übergeben, um weitere Inhalte zu besprechen, sehen wir uns zunächst die Definition des Factory Method Patterns an.

Zwei, Definition

Definieren Sie eine Schnittstelle zur Erstellung von Objekten, lassen Sie die Unterklassen bestimmen, welche Klasse instanziert werden soll.

Drei, Anwendungsszenarien

Der Factory Method Pattern kann überall verwendet werden, wo komplexe Objekte generiert werden müssen. Komplexe Objekte sind gut für den Einsatz des Factory Patterns geeignet, und für Objekte, die mit 'new' erstellt werden, ist der Einsatz des Factory Patterns nicht erforderlich.

Vier, einfache Implementierung des Musters

Abstrakte Produktklasse:

public abstract class Product {
  /**
   * Abstrakte Methoden der Produktklasse
   * von spezifischen Produktklassen implementiert werden
   * */
  public abstract void method();
}

Spezifische Produktklasse A:

public class ConcreteProductA extends Product {
  @Override
  public void method() {
    System.out.println("Ich bin das spezifische Produkt A");
  }
}

Spezifische Produktklasse B:

public class ConcreteProductB extends Product {
  @Override
  public void method() {
    System.out.println("Ich bin das spezifische Produkt B");
  }
}

Abstrakte Fabrikklasse:

public abstract class Factory {
  /**
   * Abstrakte Fabrikmethode
   * Wird von den Unterklassen implementiert
   * 
   * @return Das spezifische Produktobjekt
   * */
  public abstract Product createProduct();
}

Spezifische Fabrikklasse:

public class ConcreteFactory extends Factory {
  /**
   * Konkrete Fabrikklasse
   * */
  @Override
  public Product createProduct() {
    return new ConcreteProductA();
  }
}

Kundenklasse:

public class Client {
  public static void main(String[] args) {
    Factory factory = new ConcreteFactory();
    Product product = factory.createProduct();
    product.method();
  }
}

Ergebnis:

Ich bin das spezifische Produkt A

Diese Rollen sind recht einfach und können in vier Hauptmodule unterteilt werden: das abstrakte Fabrik, das das Zentrum des Fabrikmethodenmusters darstellt; die spezifische Fabrik, die die spezifische Geschäftslogik implementiert; das abstrakte Produkt, das die Elternklasse der von der Fabrikmethode erstellten Produkte ist; und das spezifische Produkt, das ein Objekt für ein bestimmtes Produkt des abstrakten Produkts darstellt.

Im obigen Code haben wir in der Klasse Client eine Fabrikinstanz erstellt und ein Produktobjekt hergestellt. Das Produktobjekt, das wir erhalten, ist eine Instanz von ConcreteProductA. Wenn eine Instanz von ConcreteProductB erhalten werden soll, kann die Logik in ConcreteFactory geändert werden:

public class ConcreteFactory extends Factory {
  /**
   * Konkrete Fabrikklasse
   * */
  @Override
  public Product createProduct() {
    //return new ConcreteProductA();
    return new ConcreteProductB();
  }
}

Diese Methode ist recht häufig, sie produziert das benötigte Produkt, manchmal kann auch durch Reflection eine einfachere Methode zur Produktion spezifischer Produktobjekte verwendet werden. In diesem Fall muss in der Parameterliste der Fabrikmethode eine Class-Klasse übergeben werden, um zu bestimmen, welche Produktklasse produziert werden soll:

public abstract class Factory {
  /**
   * Abstrakte Fabrikmethode
   * Wird von den Unterklassen implementiert
   * 
   * @param clz Typklasse des Produktobjekts
   * 
   * @return Das spezifische Produktobjekt
   * */
  public abstract <T extends Product> T createProduct(Class<T> clz);
}

Für spezifische Fabrikklassen kann das Beispiel der Klasse durch Reflection ermittelt werden:

public class ConcreteFactory extends Factory {
  /**
   * Konkrete Fabrikklasse
   * */
  @SuppressWarnings("unchecked")
  @Override
  public <T extends Product> T createProduct(Class<T> clz) {
    Product product = null;
    try {
      product = (Product) Class.forName(clz.getName()).newInstance();
    } catch (Exception e) {
      e.printStackTrace();
    }
    return (T)product;
  }
}

Schauen wir uns nun die Implementierung in Client an:

public class Client {
  public static void main(String[] args) {
    Factory factory = new ConcreteFactory();
    Product product = factory.createProduct(ConcreteProductB.class);
    product.method();
  }
}

Geben Sie einfach den Typ der Klasse ein, die Sie benötigen, und dies ist eine sehr einfache und dynamische Methode. Wenn Ihnen dieser Weg nicht gefällt, können Sie auch versuchen, für jedes Produkt eine spezifische Fabrik zu definieren, die ihre eigenen Aufgaben erledigt.

public class ConcreteFactoryA extends Factory {
  /**
   * Konkrete Fabrikklasse
   **/
  @Override
  public Product createProduct() {
    return new ConcreteProductA();
  }
}
public class ConcreteFactoryB extends Factory {
  /**
   * Konkrete Fabrikklasse
   **/
  @Override
  public Product createProduct() {
    return new ConcreteProductB();
  }
}
public class Client {
  public static void main(String[] args) {
    Factory factoryA = new ConcreteFactoryA();
    Product productA = factoryA.createProduct();
    productA.method();
    Factory factoryB = new ConcreteFactoryB();
    Product productB = factoryB.createProduct();
    productB.method();
  }
}

Diese Art, mehrere Fabriken zu haben, nennen wir das Muster mehrerer Fabriken. Genauso, wenn wir zurückkehren zum ursprünglichen Fabrikmethodenmuster, wenn unsere Fabrik nur eine hat, haben wir der Fabrik immer noch eine abstrakte Klasse bereitgestellt. Können wir sie nicht vereinfachen? Wenn Sie sicher sind, dass Ihre Fabrikklasse nur eine hat, ist es definitiv kein Problem, die abstrakte Klasse wegzulassen. Wir müssen nur die entsprechenden Fabrikmethoden in statische Methoden ändern:

public class Factory {
  /**
   * Konkrete Fabrikklasse
   **/
  @Override
  public static Product createProduct() {
    return new ConcreteProductA();
  }
}

Diese Art und Weise wird auch als einfaches Fabrikmethodenmuster oder statisches Fabrikmethodenmuster bezeichnet. Es ist eine abgeschwächte Version des Fabrikmethodenmusters.

Tatsächlich sollten Sie hier erkennen, dass das Fabrikmethodenmuster vollständig den Designprinzipien entspricht, die Kopplung zwischen Objekten verringert und das Fabrikmethodenmuster auf einer abstrakten Architektur basiert. Es überträgt die Instanziierungsaufgabe an die Unterklassen, was eine sehr gute Erweiterbarkeit bietet.

Fünfter Abschnitt: Fabrikmethodenmuster im Android-Quellcode

Die verschiedenen Lebenszyklen von Activity

ArrayList und HashSet

Sechster Abschnitt: Zusammenfassung

Vorteile:

Das Fabrikmethodenmuster entspricht vollständig den Designprinzipien und verringert die Kopplung zwischen Objekten. Hochrangige Module müssen nur die abstrakte Produktklasse kennen, andere Implementierungen müssen sich nicht darum kümmern.

Gute Verpackung, klare Code-Struktur. Gute Erweiterbarkeit.

Nachteile:

Jedes Mal, wenn wir neue Produkte für das Fabrikmethodenmuster hinzufügen, müssen wir eine neue Produktklasse schreiben. Gleichzeitig müssen wir die Abstraktionsebene einführen, was zu einer Komplexifizierung der Klassendynamik führt. Daher muss der Designer in bestimmten einfachen Situationen abwägen, ob er das Fabrikmethodenmuster verwenden sollte.

Interessierte Leser, die mehr über Android-Themen erfahren möchten, können die Themenbereiche dieser Website überprüfen: "Android-Entwicklung für Anfänger und Fortgeschrittene", "Android-Debugging-Techniken und Sammlung häufiger Problemebehandlungsmethoden", "Zusammenfassung der Verwendung von Android-Grundkomponenten", "Zusammenfassung der Techniken der Android-View-View", "Zusammenfassung der Techniken der Android-Layout-Layout" und "Zusammenfassung der Verwendung von Android-Kontrollen".

Ich hoffe, dass die in diesem Artikel beschriebenen Inhalte allen bei der Android-Programmgestaltung helfen.

Erklärung: Der Inhalt dieses Artikels wurde aus dem Internet übernommen und gehört dem Urheberrechtsinhaber. Der Inhalt wurde von Internetnutzern freiwillig beigesteuert und hochgeladen. Diese Website besitzt keine Eigentumsrechte und hat den Inhalt nicht manuell bearbeitet. Sie übernimmt auch keine rechtlichen Verantwortlichkeiten. Wenn Sie verdächtige Urheberrechtsinhalte finden, sind Sie herzlich eingeladen, eine E-Mail an notice#w zu senden.3codebox.com (Bitte ersetzen Sie # durch @, wenn Sie eine Beschwerde einreichen, und fügen Sie relevante Beweise bei. Sobald die Beschwerde überprüft wurde, wird die Website den verdächtigen Inhalten sofort löschen.)