Eine kurze Einführung in die drei PHP-Factory-Modi

Im vorherigen Artikel haben wir Ihnen vorgestellt, was PHPFactory-Modus ist und warum Sie den PHP-Factory-Modus verwenden sollten. Heute werden wir die drei Situationen des PHP-Factory-Modus im Detail anhand von Beispielen vorstellen. analysieren!

Factory Pattern

Implementierung: Definieren Sie eine Schnittstelle zum Erstellen von Objekten und lassen Sie Unterklassen entscheiden, welche Klasse instanziiert werden soll.
Anwendungsszenario: Es gibt viele Unterklassen und diese werden erweitert, und die Erstellungsmethode ist komplizierter.

Fabrikmuster werden in drei Typen unterteilt: einfache Fabrik, Fabrikmethode und abstrakte Fabrik.

Der Unterschied zwischen den drei Fabriktypen besteht darin, dass die abstrakte Fabrik mehrere Produktlinien hat, während die Die Fabrikmethode hat nur eine Produktlinie und ist eine Vereinfachung der abstrakten Fabrik. Die Factory-Methode ist das Gegenteil der einfachen Factory. Auf den ersten Blick scheint es, dass die Factory-Methode viel Code hinzufügt, aber dieselben Funktionen wie die einfache Factory implementiert. Das Wesentliche ist jedoch, dass die einfache Fabrik nicht strikt dem Öffnungs- und Schließprinzip des Designmusters folgt. Wenn neue Produkte hinzugefügt werden müssen, muss auch der Fabrikcode geändert werden. Die Factory-Methode hält sich jedoch strikt an das Öffnungs- und Schließprinzip. Der Modus ist nur für die abstrakte Factory-Schnittstelle verantwortlich, und die spezifische Factory wird dem Kunden überlassen. Im Rahmen der Arbeitsteilung sind Kerningenieure für die Definition abstrakter Fabriken und abstrakter Produkte verantwortlich, während Wirtschaftsingenieure für die Implementierung spezifischer Fabriken und spezifischer Produkte verantwortlich sind. Solange die Abstraktionsschicht gut gestaltet ist, ist das Framework sehr stabil.

Der Code lautet wie folgt:

/**
 * 工厂模式
 */
//抽象产品
interface Person {
    public function getName(); 
}
//具体产品实现
class Teacher implements Person {
    function getName() {
        return "老师n";
    }
}
class Student implements Person {
    function getName() {
        return "学生n";
    }
}
//简单工厂
class SimpleFactory {
       public static function getPerson($type) {
              $person = null;
              if ($type == 'teacher') {
                     $person = new Teacher();
              } elseif ($type == 'student') {
                     $person = new Student();
              }
              return $person;
       }
}
//简单工厂调用
class SimpleClient {
       function main() {
              // 如果不用工厂模式，则需要提前指定具体类
              // $person = new Teacher();
              // echo $person->getName();
              // $person = new Student();
              // echo $person->getName();
              // 用工厂模式，则不需要知道对象由什么类产生，交给工厂去决定
              $person = SimpleFactory::getPerson('teacher');
              echo $person->getName();
              $person = SimpleFactory::getPerson('student');
              echo $person->getName();
       }
}
//工厂方法
interface CommFactory {
    public function getPerson();
}
//具体工厂实现
class StudentFactory implements CommFactory {
    function getPerson(){
        return new Student();
    }
}
class TeacherFactory implements CommFactory {
    function getPerson() {
        return new Teacher();
    }
}
//工厂方法调用
class CommClient {
    static function main() {
           $factory = new TeacherFactory();
           echo $factory->getPerson()->getName();
           $factory = new StudentFactory();
           echo $factory->getPerson()->getName();
    }
}
//抽象工厂模式另一条产品线
interface Grade {
       function getYear();
}
//另一条产品线的具体产品
class Grade1 implements Grade {
       public function getYear() {
              return '2003级';
       }
}
class Grade2 implements Grade {
       public function getYear() {
              return '2004级';
       }
}
//抽象工厂
interface AbstractFactory {
       function getPerson();
       function getGrade();
}
//具体工厂可以产生每个产品线的产品
class Grade1TeacherFactory implements AbstractFactory {
       public function getPerson() {
              return new Teacher();
       }
       public function getGrade() {
              return new Grade1();
       }
}
class Grade1StudentFactory implements AbstractFactory {
       public function getPerson() {
              return new Student();
       }
       public function getGrade() {
              return new Grade1();
       }
}
class Grade2TeacherFactory implements AbstractFactory {
       public function getPerson() {
              return new Teacher();
       }
       public function getGrade() {
              return new Grade2();
       }
}
//抽象工厂调用
class FactoryClient {
       function printInfo($factory) {
              echo $factory->getGrade()->getYear().$factory->getPerson()->getName();
       }
       function main() {
              $client = new FactoryClient();
              $factory = new Grade1TeacherFactory();
              $client->printInfo($factory);
              $factory = new Grade1StudentFactory();
              $client->printInfo($factory);
              $factory = new Grade2TeacherFactory();
              $client->printInfo($factory);
       }
}
//简单工厂
//SimpleClient::main();
//工厂方法
//CommClient::main();
//抽象工厂
FactoryClient::main();

Zusammenfassung:

Haben Sie anhand der detaillierten Beispiele etwas über den PHP-Factory-Modus gelernt? in diesem Artikel? Ist das nicht ganz einfach? Ich hoffe, es wird für Ihre Arbeit hilfreich sein!

Verwandte Empfehlungen:

Was ist ein PHP-Factory-Muster? Warum den PHP-Factory-Modus verwenden?

Detaillierte Erläuterung der drei Formen des Beispielcodes des PHP-Factory-Modus

Verwendungsbeispiele von PHP Zusammenfassung des Werksmodus

Das obige ist der detaillierte Inhalt vonEine kurze Einführung in die drei PHP-Factory-Modi. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!