Detaillierte Erklärung des Abstract Factory Musters in der Android-Programmierung

Dieser Artikel beschreibt ein Beispiel für das Abstrakte Fabrikmuster im Android-Programmierungsdesign. Hiermit teilen wir es mit Ihnen zur Referenz, wie folgt:

Eins, Einführung

Das Abstrakte Fabrikmuster (Abstract Factory Pattern) ist auch eines der Erstellungsmuster. Im vorangegangenen Abschnitt haben wir das Fabrikmethodenmuster kennengelernt. Wie ist es mit dem Abstrakten Fabrik? Denken Sie daran, dass Fabriken in der realen Welt sicherlich spezifisch sind, das bedeutet, jede Fabrik produziert ein spezifisches Produkt. Dann bedeutet die abstrakte Fabrik, dass die produzierten Produkte nicht bestimmt sind. Das ist doch sehr seltsam? Das Abstrakte Fabrikmuster geht zurück auf die grafischen Lösungen für verschiedene Betriebssysteme in der Vergangenheit, wie z.B. die Buttons und Textfeldsteuerelemente in verschiedenen Betriebssystemen, deren Implementierung und Anzeige unterschiedlich sind. Für jedes Betriebssystem stellt sich selbst eine Produktklasse dar, und die Buttons und Textfeldsteuerelemente bilden auch eine Produktklasse. Beide Produktklassen haben verschiedene Eigenschaften, wie z.B. Button und TextView in Android, Button und TextView in iOS, Button und TextView in Windows Phone.

Zwei, Definition

Bietet eine Schnittstelle für die Erstellung einer Gruppe von miteinander verbundenen oder abhängigen Objekten, ohne ihre spezifischen Klassen zu spezifizieren.

Drei, Anwendungsszenarien

Wenn eine Objektfamilie die gleichen Einschränkungen hat, kann das Abstrakte Fabrikmuster verwendet werden. Klingt das sehr abstrakt? Nennen wir ein Beispiel, SMS-Software und Dialer-Software sind unter Android, iOS und Windows Phone vorhanden, beide gehören zur Kategorie Software, aber sie befinden sich auf verschiedenen Betriebssystemplattformen, selbst wenn Software von demselben Unternehmen entwickelt wird, ist die Implementationslogik des Codes unterschiedlich. In diesem Fall kann erwogen werden, das Abstrakte Fabrikmethodenmuster zu verwenden, um SMS-Software und Dialer-Software für Android, iOS und Windows Phone zu erzeugen.

Vier, das UML-Klassendiagramm des Abstrakten Fabrikmusters

UML-Klassendiagramm:

Obwohl es viele Arten von Abstraktionsfabrikmethoden gibt, werden sie hauptsächlich in4Klasse:

AbstractFactory: Eine abstrakte Fabrikrolle, die eine Reihe von Methoden zur Erstellung eines Produkts deklariert, jede Methode entspricht einem Produkt.

ConcreteFactory: Eine spezifische Fabrikrolle, die die Methoden zur Erstellung von Produkten definiert, die im abstrakten Fabrikmodell festgelegt sind, und eine Reihe spezifischer Produkte generiert, die eine Produktart bilden und in einer Produktstruktur positioniert sind.

AbstractProduct：抽象产品角色，它为每种产品声明接口。

AbstractProduct: The abstract product role declares interfaces for each product.

ConcreteProduct: The concrete product role defines the concrete product object produced by the concrete factory, and implements the business methods declared in the abstract product interface.

5. Simple implementation

For example, in the case of car parts production by car factories A and B, the two factories produce different tires, engines, and braking systems. Although the parts produced are different and the models are different, fundamentally, there are common constraints, that is, tires, engines, and braking systems.

public interface ITire {
  /**
   * Tire 
   */
  void tire();
}
public class NormalTire implements ITire{
  @Override
  public void tire() {
    System.out.println("Normal tire");
  }
}
public class SUVTire implements ITire{
  @Override
  public void tire() {
    System.out.println("SUV tire");
  }
}

Engine related classes:

public interface IEngine {
  /**
   *Engine 
   */
  void engine();
}
public class DomesticEngine implements IEngine{
  @Override
  public void engine() {
    System.out.println("Domestic engine");
  }
}
public class ImportEngine implements IEngine{
  @Override
  public void engine() {
    System.out.println("Imported engine");
  }
}

Braking system related classes:

public interface IBrake {
  /**
   *Braking system 
   */
  void brake();
}
public class NormalBrake implements IBrake{
  @Override
  public void brake() {
    System.out.println("Normal braking");
  }
}
public class SeniorBrake implements IBrake{
  @Override
  public void brake() {
    System.out.println("Advanced braking");
  }
}

Abstract car factory class:

public abstract class CarFactory {
  /**
   * Manufacture tire
   * 
   * @return Tire
   * */
  public abstract ITire createTire();
  /**
   * Manufacture motor
   * 
   * @return Motor
   * */
  public abstract IEngine createEngine();
  /**
   * Produktion des Bremsensystems
   * 
   * @return Bremsensystem
   * */
  public abstract IBrake createBrake();
}

A-Autowerk:

public class AFactory extends CarFactory{
  @Override
  public ITire createTire() {
    return new NormalTire();
  }
  @Override
  public IEngine createEngine() {
    return new DomesticEngine();
  }
  @Override
  public IBrake createBrake() {
    return new NormalBrake();
  }
}

B-Autowerk:

public class BFactory extends CarFactory{
  @Override
  public ITire createTire() {
    return new SUVTire();
  }
  @Override
  public IEngine createEngine() {
    return new ImportEngine();
  }
  @Override
  public IBrake createBrake() {
    return new SeniorBrake();
  }
}

Kundengruppe:

public class Client {
  public static void main(String[] args) {
    //A-Autowerk
    CarFactory factoryA = new AFactory();
    factoryA.createTire().tire();
    factoryA.createEngine().engine();
    factoryA.createBrake().brake();
    System.out.println("---------------");
    //B-Autowerk
    CarFactory factoryB = new BFactory();
    factoryB.createTire().tire();
    factoryB.createEngine().engine();
    factoryB.createBrake().brake();
  }
}

Ergebnis:

Normale Reifen
Inländischer Motor
Normale Bremsen
------------------
Offroad-Reifen
Importmotor
Hochwertige Bremsen

Es kann gesehen werden, dass oben zwei Autowerke simuliert wurden. Wenn es C-Werk und D-Werk gibt und die Typen und Arten der Bauteile, die von den jeweiligen Herstellern produziert werden, unterschiedlich sind, wird die Anzahl der Dateien, die wir erstellen, verdoppelt. Dies ist auch ein Nachteil des Abstrakten Fabrikmusters, daher muss bei der tatsächlichen Entwicklung eine Abwägung vorgenommen werden.

Sechster Abschnitt: Unterschiede zum Fabrikmethodenmuster

Im vorherigen Kapitel wurde das Fabrikmethodenmuster vorgestellt. Was ist der Unterschied zwischen ihnen? Das abstrakte Fabrikmuster ist eine erweiterte Version des Fabrikmethodenmusters. Der Vergleich ist wie folgt:

Fabrikmethodenmuster	Abstraktes Fabrikmuster
Es gibt nur eine abstrakte Produktklasse	Es gibt mehrere abstrakte Produktklassen
Die spezifische Fabrik kann nur Instanzen einer spezifischen Produktklasse erstellen	Die abstrakte Fabrik kann Instanzen mehrerer spezifischer Produktklassen erstellen

Kapitel 7, Implementierung im Quellcode

Das abstrakte Fabrikmuster wird in der Android-Quellcode seltener verwendet, da es selten zu mehreren Produktarten kommt. In den meisten Fällen kann das Fabrikmethodenmuster gelöst werden.

MediaPlayer

Die MediaPlayer Factory erstellt4Verschiedene MediaPlayer-Basisklassen: StagefrightPlayer, NuPlayerDriver, MidiFile und TestPlayerStub, alle vier erben von MediaPlayerBase.

Kapitel 8, Zusammenfassung

Vorteile:

Trennen Sie die Schnittstelle und die Implementierung, verwenden Sie die abstrakte Fabrik, um die erforderlichen Objekte zu erstellen, und der Client weiß nicht, wer die spezifische Implementierung ist. Der Client programmiert nur auf die Schnittstelle des Produkts. Dies trennt ihn von der spezifischen Produktimplementierung und macht es aufgrund der Trennung von Schnittstelle und Implementierung flexibler und einfacher, das Fabrikmethodenmuster bei der Wechselung der Produktkategorien anzuwenden.

Nachteile:

Erstens ist die explosionsartige Zunahme der Klassendateien

Zweitens ist es nicht so einfach, neue Produktkategorien zu erweitern

Interessierte Leser, die mehr über Android-Themen erfahren möchten, können die Themenbereiche dieser Website besuchen: 'Einführung und Fortgeschrittene Android-Entwicklungstutorials', 'Android-Debugging-Techniken und Sammlung häufiger Problembehandlungsmethoden', 'Zusammenfassung der Verwendung von Android-Basiskomponenten', '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 für die Android-Programmierung nützlich sind.

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 Haftung für die rechtlichen Folgen. Wenn Sie urheberrechtlich geschützte Inhalte entdecken, sind Sie herzlich eingeladen, eine E-Mail an notice#w zu senden.3Wenn Sie eine Beschwerde einreichen möchten, ersetzen Sie bitte # durch @ und senden Sie eine E-Mail zusammen mit dem entsprechenden Beweismaterial. Sobald die Beanstandung bestätigt wird, wird die fragliche urheberrechtlich geschützte Inhalte sofort gelöscht.