标签: nested-generics

我正在尝试创建一个方法，该方法根据给定的泛型类型从数据库返回数据。

接口：（此定义编译）

public interface IOrderPosition<TOrder, TArticle, TOrderPosition>
  where TOrder : IOrder
  where TArtile : IArticle
  where TOrderPosition : IOrderPosition<TOrder, TArticle, TOrderPosition>
{
  long? id { get; set; }
  TOrder order { get; set; }
  TArtile article { get; set; }
  List<TOrderPosition> subPositions { get; set; }
}

一个可能的具体实现：（这个定义编译）

public class OrderPosition : IOrderPosition<Order, Article, OrderPosition>
{
  public long? id { get; set; }
  public Order order { get; set; }
  public Article article { get; set; }
  public …

我有以下课程：

class Walls { }
class Furniture { }
class Layout<T extends Walls | Furniture> { }
class Space extends Layout<Walls> { }
class Room extends Layout<Furniture> { }

我需要创建这两个类：

class SpaceController extends LayoutController<Space> { }
class RoomController extends LayoutController<Room> {}

为此，我无法创建LayoutController这样的类：

class LayoutController<T extends Layout>{ }

因为Layout需要一个 Type 参数。

我可以创建这个：

class LayoutController<U, T extends Layout<U extends Walls | Furniture>>{ }

但这意味着我必须这样做：

class SpaceController extends LayoutController<Walls, Space> { }
class RoomController extends LayoutController<Furniture, Room> {}

我觉得这是多余的。此外，它还为错误提供了空间。没有什么能阻止我写作： …

Java嵌套泛型吗？以下是Eclipse中的一个错误:

ArrayList<ArrayList<Integer>> numSetSet = ArrayList<ArrayList<Integer>>();

错误是:

Syntax error on token "(", Expression expected after this token

您如何用简单的英语描述这些列表内容之间的区别？

我正在寻找一个可以作为参考的简单比较.

/* 1 */ List<          List<          Dog>>
/* 2 */ List<          List<? extends Dog>>
/* 3 */ List<? extends List<          Dog>>
/* 4 */ List<? extends List<? extends Dog>>

通用声明super类似.那么这些呢:

/* 5 */ List<? super   List<? extends Dog>>
/* 6 */ List<? extends List<? super   Dog>>

相关问题和资源

• 获取原则的解释
• 泛型:列表<？extends Animal>和List <Animal>相同？
• http://www.angelikalanger.com/GenericsFAQ/JavaGenericsFAQ.html
• http://docs.oracle.com/javase/tutorial/java/generics/

我写了一个递归mergeSort函数:

func mergeSort<T: Comparable>(inout array: [T]) {
    if array.count <= 1 {
        return
    }

    var leftSlice = [T](array[0..<array.count / 2])
    var rightSlice = [T](array[array.count / 2...array.endIndex - 1])

    mergeSort(&leftSlice)
    mergeSort(&rightSlice)
    array = merge(leftSlice, rightSlice)
}

func merge<T: Comparable>(var left: [T], var right: [T]) -> [T] {
    var mergedValues = [T]()

    while !left.isEmpty && !right.isEmpty {
        mergedValues.append(left.first! < right.first! ? left.removeAtIndex(0) : right.removeAtIndex(0))
    }

    if !left.isEmpty {
        mergedValues += left
    } else if !right.isEmpty {
        mergedValues += right
    } …

我有一个接口Value和一个类Record

public interface Value<T> {
    T getRawValue();
}

public class Record<Value<T>> {

    private Value<T> value;     

    T getRecordRawValue() {
        return value.getRawValue();
    }

}

Java不会编译这个并抱怨Generics声明>.有人可以告诉我为什么这是无效的语法？

说我有一些课程如下:

class A { }

class B<TA extends A> { }

class C<TB extends B<? extends A>> {
    TA varOfTypeTA; // this throws an error obviously
}

如何定义varOfTypeTATB的TA类型？

我知道我可以将其定义为A varOfTypeTA,但我希望它TA不是类型的A.

我试图强制它定义TA,class C<TB extends B<TA extends A>>所以我可以使用TA,但这会引发语法错误.

为了澄清,如果我然后定义这些类:

class Horse extends A { }

class HorseHerd extends B<Horse> { }

class HorseHerder extends C<HorseHerd> {
    Horse getFavoriteHorse() { return varOfTypeTA; } // varOfTypeTA defined in class C must be …

我正在完成我的家庭作业,并陷入了一些泛型和继承问题.

我有一个通用的红黑树类,因为它是红黑树,它的键应该是可比的,所以

public class RedBlackTree<T> where T : IComparable<T>

然后我想要另一个类,比方说,一个间隔树,它是红黑树的增强版本.所以我定义了这样的间隔:

public class Interval<T> : IComparable where T : IComparable<T>

并且由于区间树确实是一个红色黑色的树,其间隔为其键,但只是使用更具体的方法,我定义了这样的类:

public class IntervalTree<T> : RedBlackTree<Interval<T>> where T : IComparable<T>

但它不会让我这样做,它说"不能隐含地转换Interval<T>为System.IComparable<Interval<T>>",但我也写不出类似的东西where Interval<T> : IComparable<Interval<T>>.

我如何在C#中执行此类操作,或者如果在C#中无法执行此继承,我应该使用哪些其他模板？

interface IModel
{ 
}

class ModelA : IModel
{
}

interface IService<T> where T: IModel
{
}

class ServiceA : IService<ModelA>
{
}

鉴于上面的类和接口的定义，以下工作：

IModel model = new ModelA();

表明ModelA可以强制转换为其接口IModel

以下也适用：

IService<ModelA> service1 = new ServiceA();

表明ServiceA可以强制转换为其接口IService<ModelA>

但是，以下情况会失败：

IService<IModel> service2 = new ServiceA();

错误消息表明ServiceA不能隐式转换为IService<IModel>

我对此感到惊讶，因为：
ModelA可以转换为IModel，并且
ServiceA可以转换为IService<IModel>
我期望发生以下情况：
ServiceA-> IService<ModelA>->IService<IModel>

但这似乎不可能。

有人能解释为什么吗？

今天我注意到如果你在Java中声明以下内容:

public interface Foo<T extends Foo> {}

然后你可以递归地声明类型的对象:

Foo<Foo<Foo<Foo<Foo<Foo<Foo... ...>>>>>> foo;

并且你永远不会结束它,但你永远无法满足警告:"Foo是一个原始类型.Foo类型的引用应该参数化.非常好奇.