Nennen Sie zwei Beispiele, um das einfache Fabrikmuster in Java schnell zu verstehen:
Nuwa machte Menschen aus Erde
Es gibt ein Sprichwort: „Als die Welt geöffnet wurde, gab es keine Menschen, also.“ Nuwa erschuf Menschen aus Erde.“ Wa musste einen Menschen nach dem anderen aus Erde erschaffen, aber bevor Nu Wa Menschen erschuf, existierte das Konzept des Menschen nur in Nu Was Gedanken.
Nuwa erschafft Menschen, dies ist die Anwendung des einfachen Fabrikmodells.
Zunächst einmal gibt es in dieser Idee, Menschen zu erschaffen, mehrere wichtige Rollen: Nuwa selbst, das abstrakte Konzept des Menschen und die spezifischen Menschen, die von Nuwa geschaffen wurden.
1.) Nuwa ist eine Fabrikklasse, die die Kernrolle des einfachen Fabrikmodells darstellt.
2.) Jeder von Gu Xius Leuten, einschließlich Zhang San, Li Si usw. Diese Menschen sind die spezifischen Produktrollen im einfachen Fabrikmodell
3.) Abstrakte Menschen sind eine Idee, die zunächst nur in Nuwas Kopf existierte. Nuwa schuf bestimmte Menschen auf der Grundlage dieser Idee, und dann entsprechen alle dieser abstrakten Definition von Mensch Sein. Mit anderen Worten, diese abstrakte Idee legt die Schnittstellen (Merkmale oder Funktionen) fest, die alle bestimmten Personen haben müssen
Das UML-Klassendiagramm ist unten dargestellt:
Verstehen Nach dem Verstehen Lassen Sie uns die oben genannten Dinge verstehen und vergleichen. Ich glaube, dass Sie nach dem Lesen dieses Artikels ein gutes Verständnis des einfachen Java-Fabrikmusters haben werden:
Es gibt ein landwirtschaftliches Unternehmen, das sich darauf spezialisiert hat Um verschiedene Früchte auf dem Markt zu verkaufen, müssen die folgenden Früchte in diesem System beschrieben werden: Traube
Stuawberry
Apfel Apfel
Früchte unterscheiden sich von anderen Pflanzen und können schließlich gepflückt und gegessen werden, so ist es auch Ein natürlicher Ansatz besteht darin, eine Schnittstelle einzurichten, die auf alle Arten von Früchten anwendbar ist, um sie von anderen Pflanzen auf dem Bauernhof zu unterscheiden.
Zu diesem Zeitpunkt wird eine Schnittstelle für die Fruchtklasse. Im Code angezeigt:
public interface Fruit {
// 生长
void grow();
// 收获
void harvest();
// 种植
void plant();
}Nach dem Login kopieren
Die Fruchtschnittstelle gibt die Schnittstellen an, die alle Früchte implementieren müssen, einschließlich der Methoden plant(), grow() und Harvest(), die jede Fruchtklasse haben muss ;
Die Apple-Klasse ist eine Art Fruchtklasse und implementiert daher alle von der Fruchtschnittstelle deklarierten Methoden. Da Äpfel mehrjährige Pflanzen sind, gibt es außerdem eine zusätzliche treeAge-Eigenschaft, um das Alter des Apfelbaums zu beschreiben. Der Code lautet wie folgt:
package fac;
public class Apple implements Fruit { // 通过implements实现接口Fruit
private int treeAge;
public void grow() {
log( " Apple is growing " );
}
public void harvest() {
log( " Apple has been harvested " );
}
public void plant() {
log( " Apple ha been planted " );
}
public static void log(String msg) {
System.out.println(msg);
}
public int getTreeAge() {
return treeAge;
}
public void setTreeAge( int treeAge) {
this .treeAge = treeAge;
}
}Nach dem Login kopieren
Ähnlich Traube:
package fac;
public class Grape implements Fruit{
private boolean seedless;
public void grow(){
log("Grape is growing.");
}
public void harvest(){
log("Grape has been harvested");
}
public void plant(){
log("Grape ha been planted");
}
public static void log(String msg){
System.out.println(msg);
}
public boolean isSeedless() {
return seedless;
}
public void setSeedless(boolean seedless) {
this.seedless = seedless;
}
}Nach dem Login kopieren
Stuawberry:
package fac;
public class Strawberry implements Fruit{
public void grow(){
log("Strawberry is growing");
}
public void harvest(){
log("Strawberry has been harvested");
}
public void plant(){
log("Strawberry has been planted");
}
public static void log(String msg){
System.out.println(msg);
}
}Nach dem Login kopieren
Die Farm Der Gärtner ist ebenfalls Teil des Systems und wird durch eine Klasse repräsentiert, die FruitGardener-Klasse. Der Code lautet wie folgt:
package fac;
public class FruitGardener{
public static Fruit factory(String which)throws Exception{
if(which.equalsIgnoreCase("apple")){
return new Apple();
}else if(which.equalsIgnoreCase("strawberry")){
return new Strawberry();
}else if (which.equalsIgnoreCase("grape")){
return new Grape();
}else{
throw new Exception("Bad fruit request");
}
}
}Nach dem Login kopieren
Zu dieser Zeit kam jemand zum Spielen in den Obstgarten und sagte dem Gärtner, er solle es erzählen uns über Ihre Früchte. Also der Gärtner:
package fac;
public class People {
public static void main(String[] args) throws Exception {
FruitGardener fg=new FruitGardener();
Fruit ap=fg.factory("Apple");
ap.grow();
Fruit gp=fg.factory("Grape");
gp.plant();
Fruit dd=fg.factory("ddd");//抛出Bad fruit request异常
}
}Nach dem Login kopieren
(Hinweis: Der obige Code wird unter JDK5.0, Myeclise3.2 kompiliert und übergeben)
Analog zu Zwei Beispiele: Der Gärtner Es entspricht Nuwa und Früchte entsprechen bestimmten Personen. Die Schnittstellenfruchtklasse entspricht dem abstrakten Konzept von Menschen, das in Nuwa-ähnlichen Gedanken existiert.
Aus den beiden oben genannten Beispielen kann geschlossen werden, dass das einfache Fabrikmuster aus den folgenden Rollen bestehen muss:
Schnittstelle
ulous durch die folgenden zwei Beispiele 🎜>
Nach dem Verständnis Schauen wir uns die folgenden zwei Beispiele an, schauen wir uns das dritte Beispiel an:
Achten Sie auf die Unterschiede zwischen den folgenden drei Beispielen
Beispiel 1:
Beispiel 2:
package org.jzkangta.factorydemo01;
//定义接口
interface Car{
public void run();
public void stop();
}
//具体实现类
class Benz implements Car{
public void run(){
System.out.println("Benz开始启动了。。。。。");
}
public void stop(){
System.out.println("Benz停车了。。。。。");
}
}
//具体实现类
class Ford implements Car{
public void run(){
System.out.println("Ford开始启动了。。。");
}
public void stop(){
System.out.println("Ford停车了。。。。");
}
}
//工厂
class Factory{
public static Car getCarInstance(){
return new Ford();
}
}
public class FactoryDemo01 {
public static void main(String[] args) {
Car c=Factory.getCarInstance();
c.run();
c.stop();
}
}Nach dem Login kopieren
Beispiel drei:
package fac;
//定义接口
interface Car{
public void run();
public void stop();
}
//具体实现类
class Benz implements Car{
public void run(){
System.out.println("Benz开始启动了。。。。。");
}
public void stop(){
System.out.println("Benz停车了。。。。。");
}
}
class Ford implements Car{
public void run(){
System.out.println("Ford开始启动了。。。");
}
public void stop(){
System.out.println("Ford停车了。。。。");
}
}
//工厂
class Factory{
public static Car getCarInstance(String type){
Car c=null;
if("Benz".equals(type)){
c=new Benz();
}
if("Ford".equals(type)){
c=new Ford();
}
return c;
}
}
public class FactoryDemo02 {
public static void main(String[] args) {
Car c=Factory.getCarInstance("Benz");
if(c!=null){
c.run();
c.stop();
}else{
System.out.println("造不了这种汽车。。。");
}
}
}Nach dem Login kopieren
Vergleich von drei Beispielen:
Instanz eins: Obwohl eine einfache Fabrik implementiert ist, können wir jedes Mal nur einen Fahrzeugtyp erhalten, wenn wir ihn im ersten Fall ändern möchten In diesem Fall müssen wir die Fabrik ändern, was zu umständlich ist, aber im zweiten Beispiel ändern wir diese Situation, sodass wir das Auto entsprechend unseren Anforderungen ersetzen können, aber das Auto, das wir ersetzen, muss in der Implementierungsklasse If sein Wenn wir ein neues Auto hinzufügen möchten, müssen wir die Fabrik noch ändern. Beispiel 3 verwendet den Reflexionsmechanismus, um den Autotyp zu erhalten. Es ist nicht erforderlich, die Factory zu ändern, sondern nur die Klasse hinzuzufügen, die implementiert werden soll. Mit anderen Worten: Wenn Sie einen beliebigen Fahrzeugtyp hinzufügen möchten, können Sie einfach die Fahrzeugklasse hinzufügen, ohne das Werk zu ändern. Dadurch wird der Effekt einer Fabriktrennung erreicht.
interface Car{
public void run();
public void stop();
}
class Benz implements Car{
public void run(){
System.out.println("Benz开始启动了。。。。。");
}
public void stop(){
System.out.println("Benz停车了。。。。。");
}
}
class Ford implements Car{
public void run(){
System.out.println("Ford开始启动了。。。");
}
public void stop(){
System.out.println("Ford停车了。。。。");
}
}
class Toyota implements Car{
public void run(){
System.out.println("Toyota开始启动了。。。");
}
public void stop(){
System.out.println("Toyota停车了。。。。");
}
}
class Factory{
public static Car getCarInstance(String type){
Car c=null;
try {
c=(Car)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();//利用反射得到汽车类型
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return c;
}
}
public class FactoryDemo03 {
public static void main(String[] args) {
Car c=Factory.getCarInstance("Toyota");
if(c!=null){
c.run();
c.stop();
}else{
System.out.println("造不了这种汽车。。。");
}
}
}Nach dem Login kopieren
Weitere Artikel zum einfachen Fabrikmuster in Java finden Sie auf der chinesischen PHP-Website!
