如何访问抽象父类的实例成员？

Question

如果无法创建父类（抽象）的实例，我们如何访问子类中抽象父类的实例成员？

Answer 1

TL:RD; the answer would be, yes. But they are not copied.

Let's say:

public abstract class A
{
    public string Code { get;set; }
}

Is your super (parent/base) class and

public class B : A
{
    public string Title { get;set; }
}

Is your derived (sub) class. The instantiation of class B would contain both the property Code as well as Title.

Class B extends class A. This makes things possible like casting an instantiation of class B to class A by simply doing:

B foo = new B();
A bar = foo as A;

Though I would advise you to use an interface rather than a superclass in order to check if an instance has a certain property you are looking for.

So again, class A properties and methods are not copied to class B. Class B extends its methods and properties to class A.

-- Edit --

To answer the question: both constructors are invoked, so aren't there really 2 different objects?

On compiler level, yes, the abstract class and the derived class are 2 different objects. But you as a user of the instance B don't need to worry that B is actually an object consisting of B and A.

In the above example, if you cast B down to A. And modify the property 'Code'. Then cast object back to B. The property 'Code' is still set to the new value.

Example:

B foo = new B();
foo.Code = "testfoo";
Console.WriteLine(foo.Code); //output will be testfoo;

A bar = foo as A;
bar.Code = "testbar";
Console.WriteLine(bar.Code); //output will be testbar;

But also:

Console.WriteLine(foo.Code); //output will be testbar;

This is because the derived class B, does not actually contain a property Code. It only says that it extends A, and A has the property Code.

BUT! Your doubt would be justified if you use new(shadows in vb.net).

Example:

public abstract class A
{
    public string Code { get;set; }
}

public class B : A
{
    public new string Code { get;set; }
    public string Title { get;set; }
}

What then happens is what I think you are worried about happening.

Now both the derived and superclass have a property 'Code'.

In this example, the output would actually differ based upon how you would look at the object.

Something really weird would happen in this case and is prone to faults if used incorrectly.

Example:

B foo = new B();
foo.Code = "testfoo";
Console.WriteLine(foo.Code); //output will be testfoo;

A bar = foo as A;
bar.Code = "testbar";
Console.WriteLine(bar.Code); //output will be testbar;

But now :

Console.WriteLine(foo.Code); //output will be testfoo;

Also, the term Abstract does not do more for your class apart from stating that it cannot be constructed on its own, it has to be inherited in order to be constructed.