在C＃中，如果我有一个带有默认构造函数的继承类，是否必须显式调用基类的构造函数，还是将其隐式调用？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| class BaseClass
{
public BaseClass()
{
// ... some code
}
}
class MyClass : BaseClass
{
public MyClass() // Do I need to put": base()" here or is it implied?
{
// ... some code
}
} |
您不需要显式调用基本构造函数，它将被隐式调用。
稍微扩展一下示例并创建一个控制台应用程序，您可以自己验证以下行为：
暗含，只要它没有参数。这是因为您需要实现采用值的构造函数，请参见下面的示例代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| public class SuperClassEmptyCtor
{
public SuperClassEmptyCtor()
{
// Default Ctor
}
}
public class SubClassA : SuperClassEmptyCtor
{
// No Ctor's this is fine since we have
// a default (empty ctor in the base)
}
public class SuperClassCtor
{
public SuperClassCtor(string value)
{
// Default Ctor
}
}
public class SubClassB : SuperClassCtor
{
// This fails because we need to satisfy
// the ctor for the base class.
}
public class SubClassC : SuperClassCtor
{
public SubClassC(string value) : base(value)
{
// make it easy and pipe the params
// straight to the base!
}
} |
对于基本的无参数构造函数而言是隐含的，但对于当前类中的默认值，它是必需的：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| public class BaseClass {
protected string X;
public BaseClass() {
this.X ="Foo";
}
}
public class MyClass : BaseClass
{
public MyClass()
// no ref to base needed
{
// initialise stuff
this.X ="bar";
}
public MyClass(int param1, string param2)
:this() // This is needed to hit the parameterless ..ctor
{
// this.X will be"bar"
}
public MyClass(string param1, int param2)
// :base() // can be implied
{
// this.X will be"foo"
}
} |
暗含。
派生类基于基类构建。如果考虑一下，则必须先在内存中实例化基础对象，然后才能将派生类附加到该对象。因此，将在创建派生对象的过程中创建基础对象。所以不，您不要调用构造函数。
AFAIK，仅当需要将任何值传递给它时，才需要调用基本构造函数。
您不需要显式调用基本构造函数，它将被隐式调用，但是有时您需要将参数传递给构造函数，这样您可以执行以下操作：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
| using System;
namespace StackOverflow.Examples
{
class Program
{
static void Main(string[] args)
{
NewClass foo = new NewClass("parameter1","parameter2");
Console.WriteLine(foo.GetUpperParameter());
Console.ReadKey();
}
}
interface IClass
{
string GetUpperParameter();
}
class BaseClass : IClass
{
private string parameter;
public BaseClass (string someParameter)
{
this.parameter = someParameter;
}
public string GetUpperParameter()
{
return this.parameter.ToUpper();
}
}
class NewClass : IClass
{
private BaseClass internalClass;
private string newParameter;
public NewClass (string someParameter, string newParameter)
{
this.internalClass = new BaseClass(someParameter);
this.newParameter = newParameter;
}
public string GetUpperParameter()
{
return this.internalClass.GetUpperParameter() + this.newParameter.ToUpper();
}
}
} |
注意：如果有人知道更好的解决方案，请告诉我。
