如何在java中创建抽象工厂来实例化对象

Question

我想创建一个抽象工厂。这是我试过的。

//抽象类工作者

public abstract class Worker {
    String phoneNumber;
    String firstName;
    String lastName;
    String workerType;
    String ifu;
    String imageParth;
    //....
  public String getWorkerType() {
        return workerType;
    }
}

//扩展工人的电工班

package worker.domain.worker;

public class Electrician extends Worker{
    
    
    public Electrician() {}
    public Electrician(String phoneNumber, String firstName, String lastName, String ifu, String workerType,
            String imageParth) {
        super(phoneNumber, firstName, lastName, ifu,workerType, imageParth);
    }
    
    
    public String getWorkerType() {
        return "Electrician";
    }
    
}

//梅森班

package worker.domaine.worker;

public class Mason extends Worker{
    
    public Mason() {};

    public Mason(String phoneNumber, String firstName, String lastName, String ifu,String workerType,
            String imageParth) {
        super(phoneNumber, firstName, lastName, ifu, workerType, imageParth);
    }
    
    String getworkerType() {
        return "Mason";
    }
}

//接口可操作性StractFactory

package worker.domaine.worker;

public interface WorkerAbstractFactory {
    Worker createWorker(String typeWorker);
}

//

public class WorkerFactory implements WorkerAbstractFactory{

    @Override
    public Worker createWorker(String typeWorker) {
        Worker worker = null;
        if(worker != null) {
            switch (typeWorker) {
            case "Electrician":
                Electrician electrician =new Electrician();
                electrician = new Electrician (electrician.getPhoneNumber(), electrician.getFirstName(), electrician.getLastName(), electrician.getIfu(), electrician.getWorkerType(),electrician.getImageParth());
                
            case "Mason":
                Mason mason =new Mason();
                mason = new Mason (mason.getPhoneNumber(), mason.getFirstName(), mason.getLastName(), mason.getIfu(), mason.getworkerType(),mason.getImageParth());
                }}

//应用程序类

public class WorkerFactoryProvider {
    
     public static WorkerAbstractFactory getWorkerFactory(String workerCategory) {
         //WorkerFactory workerFactory = new WorkerFactory();
         WorkerFactory workerFactory = new WorkerFactory();
         if (workerCategory != null) {
             switch (workerCategory) {
                case "Electrician":
                    Worker worker1 = workerFactory.createWorker("Electrician");
                    worker1.getWorkerType();
                    String a=worker1.getWorkerType();
                    System.out.println(a);  
                    
                case "Mason":
                    Worker worker2 = workerFactory.createWorker("Mason");
                    worker2.getWorkerType();
                    String b=worker2.getWorkerType();
                    System.out.println(b);               
             
             }
             
             
         }
         return null;
     }

你认为它能像那样工作吗？现在，如果我真的想要一个具体的物体，怎么能做到呢？因为我想写一个根据类型计算每个工人工资的方法，例如，我如何在方法中使用我的抽象工厂来返回每个类型。

Answer 1

您有一个工人类型的单一类层次结构。要实例化这些，您只需使用一个独立的工厂类，这里不需要抽象工厂。例如，这就足够了：

public class WorkerFactory {            
    public Worker createWorker(String workerType) {
        switch (workerType) {
            case "Electrician": return new Electrician();                    
            case "Mason": return new Mason();
        }
    }
}

抽象工厂模式更加精细，并且允许为对象的相关层次注入不同的具体工厂，这样客户端就不需要意识到差异。例如，你可以有一个抽象的TransportationFactory：

interface Transportation {
    void travelTo(String destination);
}

interface TransportationFactory {
    Transportation simple();
    Transportation luxurious();
}

和两个具体实现（匹配两个不同但相似的类层次结构）：

class WaterTransporationFactory {
   Transportation simple() {
       return new Kayak();
   }
   Transportation luxurious() {
       return new Yacht();
   }
}

以及：

class LandTransporationFactory {
   Transportation simple() {
       return new Bike();
   }
   Transportation luxurious() {
       return new RaceCar();
   }
}

这种模式的好处是，客户可以配置为使用水路或陆路运输（或稍后添加的新空运），而无需进行任何更改：

class Client {

    private TransportationFactory transportationFactory;

    public Client(TransportationFactory transportationFactory) {
        this.transportationFactory = transportationFactory;
    }

    public void travel(String destination) {
        transporationFactory.simple().travelTo(destination);
    }

    public void travelInStyle(String destination) {
        transporationFactory.luxurious().travelTo(destination);
    }

}

编辑：您可以更改简单/豪华方法以匹配示例的样式。我还希望避免使用条件逻辑，让创建的类自己决定它们的可用性。这将进一步解耦，允许以最小的代码更改添加层次结构成员：

interface Transportation {
    void travelTo(String destination);
    // extra method to allow the class to specify its own type
    TransporationType getType();
}

// intermediate interface to distinguish Water from Land
interface WaterTransporation extends Transportation {
}

class Kayak implements WaterTransportation {

    void travelTo(String destination) {
        // splash splash
    }

    TransporationType getType() {
        return TransporationType.SIMPLE;
    }
}

class WaterTransporationFactory {

   private WaterTransportation[] waterTransporations;

   // Inject all available beans implementing WaterTransporation
   // e.g. using Spring or some other dependency injection mechanism
   public WaterTransporationFactory( WaterTransportation[] waterTransporations) {
       this.waterTransporations = waterTransporations;
   }

   public Transportation create(TransporationType type) {
       for(WaterTransportation waterTransportation : waterTransporations) { 
           if (waterTransportation.getType() == type) {
               return waterTransportation;
           }
       }
       throw new IllegalArgumentException("No implementation for WaterTransportation type=" + type);
   }
}