Question

我有很多班UNO，HAV，MAS，KOS 我想创建一个工厂模式。

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

我需要动态地将类加载到验证器类中并返回一个实例（动态设置类的名称并返回实例）
我的问题是：如果我有不兼容的类型，我怎么能返回一个类的实例？

我不知道在返回类型的方法中写什么。

验证程序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

看看here。简而言之，我们的想法是在工厂类中创建一个映射（Map<String,String>，key是标识符，值是完全限定的类名），并在初始化期间添加支持的类。然后使用反射在工厂方法中实例化对象。此外，您可以使用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();

未经测试!!

Java工厂模式 - 动态加载类

3 个答案: