传入参数错误的Java泛型

我得到一个编译错误，类似于： 某些类型中的方法

visitParents（Class）

不适用于参数

（Class）

MyClass类似于：

公共类可排序表{…}

我不希望将SortableTable的type参数更改为

，因为许多其他类将受到负面影响，也不能更改visitParents以将

类

以外的任何内容作为参数

任何可能的解决方案都将不胜感激

---

谢谢你的建议。 我会尽量具体，我可以不填写代码的页面

“visitParents（SortableTable.class，visitor）；”行上的错误说明：

类型组件中的方法visitParents（类“”，IVisitor“”）不适用于参数（类“”，IVisitor“”）

public类SelectAllFilterPanel扩展面板{private static final Logger log=Logger.getLogger（CorporateActionsPanel.class）；
私有静态最终长serialVersionUID=1L；
public SelectAllFilterPanel（字符串id，最终IModel模型）{
超级（id）；
添加（新建AjaxCheckBox（“selectAll”，型号）{
私有静态最终长serialVersionUID=1L；
@凌驾
受保护的void onUpdate（AjaxRequestTarget目标）{
//待办事项-正确执行此操作
最终AjaxRequestTarget requestTarget=目标；
IVisitor visitor=新的IVisitor（）{
@凌驾
公共空心构件（构件构件，IVisit访问）{
SortableTable=（SortableTable）组件；
table.visitChildren（CheckBox.class，new IVisitor（））{
@凌驾
公共空心构件（构件构件，IVisit访问）{
如果（！component.getId（）.equals（“selectAll”））{
复选框=（复选框）组件；
if（model.getObject（））
复选框.setModelObject（true）；
其他的
复选框.setModelObject（false）；
requestTarget.add（复选框）；
}
}
});
访问。停止（）；
}
};
访客租金（sortable.class，访客）；
目标。添加（此）；
}
});
}}

可排序类：

public class SortableTable<T> extends DataTable<T, String> {    private HeadersToolbar headerToolbar;   

@SuppressWarnings("unchecked")
public SortableTable(String tableId, SortableTableDataProvider<T> dataProvider, int maxRows) {
    this(tableId, dataProvider.getColumns(), dataProvider, maxRows);
}

@SuppressWarnings("unchecked")
public SortableTable(String tableId, List<IColumnConfig<T, String>> columns, ISortableDataProvider<T, String> dataProvider, int maxRows) {
    super(tableId, new java.util.LinkedList<IColumn<T, String>>(columns), dataProvider, maxRows);               

    addTopToolbar(new NavigationToolbar(this));                     
    addTopToolbar(headerToolbar = new HeadersToolbar(this, dataProvider));

    addBottomToolbar(new NoRecordsToolbar(this));

    setItemReuseStrategy(ReuseIfModelsEqualStrategy.getInstance());
}

public void setHeaderVisible(boolean visible) {
    headerToolbar.setVisibilityAllowed(visible);
}

public boolean isHeaderVisible() {
    return headerToolbar.isVisibilityAllowed();
}

@Override
protected Item<T> newRowItem(String id, int index, IModel<T> model)
{
    return new OddEvenItem<T>(id, index, model);
}}

公共类SortableTable扩展DataTable{private HeadersToolbar headerToolbar；
@抑制警告（“未选中”）
公共SortableTable（字符串tableId、SortableDataProvider、dataProvider、int maxRows）{
这（tableId、dataProvider.getColumns（）、dataProvider、maxRows）；
}
@抑制警告（“未选中”）
公共SortableTable（字符串tableId、列表列、ISortableDataProvider、dataProvider、int maxRows）{
super（tableId、newjava.util.LinkedList（列）、dataProvider、maxRows）；
addTopToolbar（新导航工具栏（this））；
addTopToolbar（headerToolbar=新的headerToolbar（此为数据提供程序））；
addBottomToolbar（新的NoRecordsToolbar（本））；
SetItemReuseStragey（ReuseIfModelsEqualStrategy.getInstance（））；
}
public void setheadervible（布尔可见）{
headerToolbar.setVisibilityAllowed（可见）；
}
公共布尔值可见（）{
返回headerToolbar.isVisibilityAllowed（）；
}
@凌驾
受保护项newRowItem（字符串id、整数索引、IModel模型）
{
返回新项目（id、索引、型号）；
}}

访客签名为：

    public final <R, C extends MarkupContainer> R visitParents(final Class<C> parentClass,
    final IVisitor<C, R> visitor)
        {
            return visitParents(parentClass, visitor, new AllVisitFilter());
        }

public final R visitParents（最终类父类、，
最后一名（访客）
{
返回visitParents（父类、visitor、new AllVisitFilter（））；
}

我不确定自己是否理解正确。但是您可以始终使用

Class您拥有的
visitParents（Class，Z.IVisitor）
，使用
C=Component
和
R=Void
（因为
visitor
是
IVisitor
）。
但是
sortable.class
的类型是
class
，因为而不能分配给
class

如果您可以更改
visitParents
的签名，请执行以下操作：

 <R, C extends MarkupContainer>
  R visitParents(Class<? extends C> parentClass, IVisitor<C, R> visitor)

虽然后一种方法在技术上不安全，但它可以工作，因为在运行时。
我找到了一个解决方案：

在实例化visitor时，我将第一个类型（组件）更改为SortableTable（它是组件的子级），因此VisitPartner方法现在可以很好地编译。问题是visitParents（）中的第二个参数，而不是第一个参数

                IVisitor<SortableTable, Void> visitor = new IVisitor<SortableTable, Void>(){

                @Override
                public void component(SortableTable component, IVisit visit) {
                    //SortableTable<?> table = (SortableTable<?>)component;
                    component.visitChildren(CheckBox.class, new IVisitor<Component, Void>(){

                        @Override
                        public void component(Component component, IVisit visit) {
                            if (component.getId().equals("selectAll")){
                                CheckBox checkbox = (CheckBox)component;
                                // TODO fix reference to client selection model
                                if (checkbox.getModelObject() && !clientSelectionModel.getObject())
                                    checkbox.setModelObject(false);
                                requestTarget.add(checkbox);
                                visit.stop();
                            }
                        }
                    });
                    visit.stop();
                }
            };
            visitParents(SortableTable.class, visitor);

IVisitor visitor=new IVisitor（）{
@凌驾
公共void组件（可排序组件，IVisit访问）{
//SortableTable=（SortableTable）组件；
visitChildren（CheckBox.class，new IVisitor（））{
@凌驾
公共空心构件（构件构件，IVisit访问）{
if（component.getId（）.equals（“selectAll”））{
复选框=（复选框）组件；
//TODO修复对客户端选择模型的引用
if（checkbox.getModelObject（）&&！clientSelectionModel.getObject（））
复选框.setModelObject（false）；
requestTarget.add（复选框）；
访问。停止（）；
}
}
});
访问。停止（）；
}
};
访客租金（sortable.class，访客）；

谢谢大家的帮助。
你需要更具体一些。发布实际错误，而不是“类似于”。告诉我们关于阶级继承人的事，你参与了吗
 @SuppressWarnings("unchecked")
 Class<Component> klass = (Class<Component>)(Class<?>)SortableTable.class;
 visitParents1(klass, visitor);

                IVisitor<SortableTable, Void> visitor = new IVisitor<SortableTable, Void>(){

                @Override
                public void component(SortableTable component, IVisit visit) {
                    //SortableTable<?> table = (SortableTable<?>)component;
                    component.visitChildren(CheckBox.class, new IVisitor<Component, Void>(){

                        @Override
                        public void component(Component component, IVisit visit) {
                            if (component.getId().equals("selectAll")){
                                CheckBox checkbox = (CheckBox)component;
                                // TODO fix reference to client selection model
                                if (checkbox.getModelObject() && !clientSelectionModel.getObject())
                                    checkbox.setModelObject(false);
                                requestTarget.add(checkbox);
                                visit.stop();
                            }
                        }
                    });
                    visit.stop();
                }
            };
            visitParents(SortableTable.class, visitor);