我有一堂课:
class User: NSObject {
var name = "User_Name"
// Other variables and methods
}
以及从‘user’继承的第二个类:
class Employee: User {
var job = "Manager"
// other variables and methods
}
我希望能够检查两者之间的一个函数,并对它们采取稍微不同的行动。
我相信在使用“AnyObject”参数之前,我可以使用一个守护语句将其转换为可疑类型,但不知道如何在两个不同的类
这是从编译器内部角度提出的问题。
我对泛型感兴趣,而不是模板(C++),所以我用C#标记了这个问题。而不是Java,因为AFAIK两种语言中的泛型在实现上有所不同。
当我查看语言w/o泛型时,它非常简单,您可以验证类定义,将其添加到层次结构中,仅此而已。
但是如何处理泛型类,更重要的是如何处理对它的引用呢?如何确保每个实例化的静态字段都是单数(即每次解决泛型参数时)。
假设我看到一个电话:
var x = new Foo<Bar>();
我是否向层次结构中添加了新的Foo_Bar类?
更新:到目前为止,我只发现了两篇相关的文章,然而,即使它们在“如何自己做”的意义上也没有太多的细节
给定一个类型化泛型函数,我想为该函数创建一个泛型别名,但似乎不能。换句话说,这是行不通的:
// foo.tsx
function foo<T>(arg: T): T {
return arg
}
type FooT = typeof foo // works, but alias isn't generic: <T>(arg: T) => T
type FooParametersT = Parameters<typeof foo> // sure: [unknown]
type FooReturnT = ReturnType<
我遇到的情况是,我在父/子层次结构中有两个层次的多态性,一个在另一个层次中。
我认为最好用一个简单的例子来解释:
class Group
{
public IList<Person> People { get; set; }
}
class SpecialGroup : Group
{
public IList<SpecialPerson> People { get; set; }
}
class Person {}
class SpecialPerson : Pers
我有一个类,它是可分的。
public class A
{
private static A Divide(double a, A b)
{
// some code to divide
return b;
}
public static A operator / (double a, A b)
{
return Divide(a, b);
}
}
public class B : A
{
我有我的s3班学生
# a constructor function for the "student" class
student <- function(n,a,g) {
# we can add our own integrity checks
if(g>4 || g<0) stop("GPA must be between 0 and 4")
value <- list(name = n, age = a, GPA = g)
# class can be set using class() or attr() f
我已经创建了一个新类,并且我想启用R的自动补全。
一个例子可以是:
# Define class
setClass("customList",
representation("list")
)
# Make example
tmp <- new("customList",
list(
test='a',
b=1:3
)
)
这会导致:
tmp
# An object of class "
我有A类,它是B的基类,也是这两种类型的扩展。然后,如果我从泛型函数(即使是B类型的对象)调用扩展,它仍然会调用基类的扩展名。
void Main()
{
var b = new B();
GenericClass.SomeGenericFunction<B>(b);
}
public class A
{
public void fooA()
{
Console.WriteLine("A");
}
};
public class B : A
{
public void fooB()
我正在使用google模拟,并希望像这样模拟继承链:
class A
{
// virtual method A1();
}
class B : public A
{
// virtual method B1();
}
class C : public B
{
// virtual method C1();
}
当模拟A时,我需要模拟A1();当模拟B时,我必须同时模拟A1()和B1();当模拟C时,我必须模拟C1()、B1()和A1()。
//Mock Definition
class MockA : public A
{
// mockA1()
}
clas
我有以下类层次结构
abstract class Base<T>
{
abstract T getRelevantType();
}
class A : Base<AType>
{
AType getRelevantType()
}
class B : Base<BType>
{
BType getRelevantType()
}
class A1 : A {
getRelevantType()
// logic
}
class A2 : A {
getReleva
为了最大化代码重用,我为我的Python代码创建了一个相当复杂的类层次结构。它是这样的:
class ElectionMethod
class IterativeMethod
class SNTV
...
class NonIterativeMethod
class OrderDependent
class CambridgeSTV
...
class OrderIndependent
class WIGM
cl