Java工廠模式-動態加載類

Question

我要創建工廠模式的類很多，UNO，HAV，MAS，KOS。

 validator.load("UNO").validate();

我需要將類動態加載到驗證器類中並返回一個實例。
（動態設置類的名稱並返回一個實例）
我的問題是：如果類型不兼容，如何返回類的實例？

我不知道在返回類型的方法中該寫些什么。

Validator CLASS中的主要問題。

public SegmentAbstract load(String str) {

和

return SegmentAbsClass.forName(identify);

主班

try{
   validator.load("UNO").validate();
}catch(Exception e){
   System.out.print("No class ");
}

抽象類（SegmentAbstract）

public abstract class SegmentAbstract {

  public abstract Boolean validate();
}

UNO類

public class UNA extends SegmentAbstract{

  public Boolean validate() {
    System.out.print("UNO!!");
    return true;
  }

}

類驗證器

public class Validator {

  public SegmentAbstract load(String str) {
    String identify = str.substring(0, 3);
    try {

      return SegmentAbsClass.forName(identify);
    }
    catch(Exception e) {
      return this;
    }

  }
}

Answer 1

嘗試這個 ：

public interface Validator {
    boolean validate(Object obj);
}

public final class ValidatorFactory {
    private ValidatorFactory(){}

    public static Validator load(String type){
        try {
            Class<?> clazz = Class.forName(type);
            if (Arrays.asList(clazz.getInterfaces()).contains(Validator.class)){
                return (Validator) clazz.newInstance();
            }
            throw new IllegalArgumentException("Provided class doesn't implement Validator interface");
        } catch (Exception e) {
            throw new IllegalArgumentException("Wrong class provided", e);
        } 
    }
}

也許這會有所幫助？？？

Answer 2

在這里看看。 簡而言之，該想法是在工廠類（ Map<String,String> ，鍵是標識符，值是完全限定的類名）中創建一個映射，並在初始化期間添加支持的類。 然后，使用反射在工廠方法中實例化一個對象。 另外，您可以通過使用Map<String, SegmentAbstract>而不是Map<String,String>並將public abstract getNewSegment()添加到SegmentAbstract類中來避免反射。

Answer 3

我會做這樣的事情：

// ISegment.java
public interface ISegment {
    Boolean validate();
}

// Uno.java
public class Uno implements ISegment {
    public Boolean validate() {
        System.out.print("UNO!!");
        return true;
    }
}

// SegmentFactory.java
public final class SegmentFactory {
    public static enum Supported {
        UNO("uno", Uno.class), /* ... */, HAV("hav", Hav.class);

        private final Class<?> clazz;
        private final String name;

        private Supported(final String name, final Class<?> clazz) {
            this.name = name;
            this.clazz = clazz;
        }

        public Class<?> getClazz() {
            return clazz;
        }

        public static Supported for(final String name) {
            for (final Supported s : values()) {
                if (s.name.equals(name) {
                    return s;
                }
            }
            return null; // a default one
        }
    }

    public static ISegment create(final Supported supp) {
        if (supp == null) {
            return null;
        }
        return supp.getClazz.newInstance();
    }

    private SegmentFactory() {
        // avoid instantiation
    }
}

用法：

final ISegment sa = SegmentFactory.create(SegmentFactory.Supported.for("uno"));
sa.validate();

未經測試！