Question

我有这个班级public class IndexedColumn extends Column<List<String>, String>。我希望该类根据不同的键变量super个不同的对象。

以下代码没问题，但只有1 super (new ClickableTextCell())

public class IndexedColumn extends Column<List<String>, String>{
   private final int index;
   public IndexedColumn(int index) {
       super(new ClickableTextCell());
       this.index = index;
   }

   @Override
   public String getValue(List<String> object) {
       return object.get(this.index);
   }

   public int getIndex(){
       return index;
   }
}

在其他班级

int myIndx=getIndex();
IndexedColumn nameColumn=null;
if(text.equals("clickText")){
     nameColumn=new IndexedColumn(myIndx);
}

但是，如果我想同时super(new ClickableTextCell())＆amp; super(new ButtonCell())，然后出现错误

public class IndexedColumn extends Column<List<String>, String>{
   private final int index;
   public IndexedColumn(int index, int cellType) {
       if(cellType==1)
          super(new ClickableTextCell());
       else{
          super(new ButtonCell());
       }
       this.index = index;
   }
}

所以eclipse建议我有另外一个这样的构造函数：

public class IndexedColumn extends Column<List<String>, String>{
   private final int index;
   public IndexedColumn(int index) {
       super(new ClickableTextCell());
       this.index = index;
   }  

   public IndexedColumn(int index, int forNothingKey) {
       super(new ButtonCell());
       this.index = index;
   }  

}

然后在其他班级

int myIndx=getIndex();
IndexedColumn nameColumn=null;
if(text.equals("clickText")){
     nameColumn=new IndexedColumn(myIndx);
}
else if(text.equals("clickButton")){
     int forNoGoodReason=1;
     nameColumn=new IndexedColumn(myIndx, forNoGoodReason);
}

正如您所看到的，为了能够使用ButtonCell列，我必须使用int forNoGoodReason变量。

这样做是一种好习惯吗？

或者你能找到更好的解决方法吗？

Answer 1

在Java中，类的超类在类头中显式声明; e.g。

  public class Foo extends Bar ... {
     ....
  }

除Object之外的每个类都只有一个在编译时确定的超类。它无法在运行时动态更改或选择。

基于Java和Java类型系统的GWT具有相同的限制。

另一方面，您可以声明一个具有多个构造函数的类，如下所示：

public class Bar ... {
     public Bar (Integer i) { ... }
     public Bar (Double d) { ... }
}

并执行此操作：

public class Foo extends Bar ... {
     public Foo (Integer i) {
        super(i);
        ...
     }
     public Foo (Double d) {
        super(d);
        ...
     }
}

但是，你不能做这样的事情：

public class Foo extends Bar ... {
     public Foo (Integer i, Double d, boolean b) {
        super(b ? i : d);
        ...
     }
}

问题是构造函数中的super调用必须在编译时中解析为超类中的单个构造函数重载，基于提供给它的参数的静态类型。 super致电。

如果要使用new创建对象，获得类似内容的唯一方法是在超类中使用统一的构造函数来处理所有情况; e.g。

public class Bar ... { public Bar (Object o) { if (o instanceof Integer) { ... } else if (o instanceof Double) { ... } // etcetera } }

......但这非常难看，更不用说脆弱性和有害的耦合了。

另一种选择是使用工厂方法......就像这样：

public class Foo extends Bar ... { public Foo (Integer i) { super(i); ... } public Foo (Double d) { super(d); ... } public static Foo createFoo(Integer i, Double d, boolean b) { return b ? new Foo(i) : new Foo(d); } }

一个类中的构造函数可以有多个超级（）吗？（Java或GWT）

1 个答案:

一个类中的构造函数可以有多个超级（）吗？ （Java或GWT）

1 个答案:

一个类中的构造函数可以有多个超级（）吗？（Java或GWT）