为什么子类可以继承父类的private的成员，但是不可以直接访问？

Question

为什么子类可以继承父类的private的成员，但是不可以直接访问？是基于什么考虑这样设计的？

Answer 1

子类不可以继承父类的private的成员

Answer 2

你的意思是?class parent
{   private string name;}class child : parent
{
   public string getname()
   {
      return super.name;
      //return name;  //这样子就不行
   }
}

Answer 3

对啊，不可以继承private成员喔~~~~~~~~~·

Answer 4

不可以继承....你可以使用 protected 保护类成员

Answer 5

子类不可以继承父类的private成员。
但可以以private的方式继承父类，如：class parent
{   private string name;}class child : private parent
{
   ...
}

Answer 6

super?????   java~~~~~~~~~

Answer 7

不可以继承
使用protected类和类的派生类可以访问

Answer 8

这主要是为了防止在子类中修改父类中用private指定的成员值

Answer 9

是的，你也可以用protected方法让派生类访问

Answer 10

私有的是不可以被继承的
楼主说的是当一个父类的公共方法被继承时为什么能访问父类中的私有属性吗?其实是这样的 继承后其实这个方法并不是子类的 而是父类的,所以它理所当然能访问本类下的成员楼主可能是把继承弄错了class Parent
{ 
  private string _name; 
  public string GetName()
  {
    return _name;
  }
} class Child : Parent 
{ 
  public string ParentName()
  {
    return GetName();//楼主不要以为这里是自己的GetName方法 其实是隐式调用了 base.GetName();
  }
} 

Answer 11

super.name 
这个是什么？ java的，类似c#中的base.name

Answer 12

大大门,那个super是我乱写的....
而且整个就是错的.....俺还是太菜了

Answer 13

private不可以继承的！
protected可以被子类继承！

Answer 14

嗯，我看MSDN上，似乎也是这么说，

Answer 15

对于子类不能直接访问父类
我的理解是
可以用这样的方法将我们的成员保护得更好,让子类的设计者只能通过父类指定的方法修改父类的私有成员,这样将能把类保护得更好你可以看下面的例子BaseClasspublic class BaseClass
{
    private List<string> list = new List<string>();    public void Add(string s)
    {
        list.Add(s);
    }    public void ConsoleOut()
    {
        foreach(string s in list)
        {
            Console.WriteLine(s);
        }
    }
}ChildClasspublic class ChildClass : BaseClass
{
    
}TestChildClass cc = new ChildClass();
cc.Add("1");
cc.Add("2");
cc.Add("3");
cc.ConsoleOut();也就是说你如果想改变List的值
那么只能通过BaseClass的公开的方法Add来访问
当然了，你也可以使用反射~~~~

Answer 16

public class BaseClass
{
    private string s = "sss";
}public class ChildClass : BaseClass
{}
FieldInfo fi = typeof(ChildClass).BaseType.GetField("s", BindingFlags.NonPublic | BindingFlags.IgnoreCase | BindingFlags.Instance);
string s = fi.GetValue(new ChildClass()) as string;请测试~~~

Answer 17

呵呵，我没说清楚，我指的是直接对ChildClass反射， typeof(ChildClass).GetField。当然， typeof(ChildClass).BaseType.GetField也是通过反射得到了

Answer 18

用面向对象的思想去理解这个问题:        static void Main(string[] args)
        {
            徒弟 t1 = new 徒弟(赏识度.十分欣赏);
            Console.WriteLine(t1.徒弟的功力);
            徒弟 t2 = new 徒弟(赏识度.垃圾);
            Console.WriteLine(t2.徒弟的功力);            师傅 s = new 师傅();
            Type 偷秘笈的 = s.GetType();
            FieldInfo fi = 偷秘笈的.GetField("师傅的功力", BindingFlags.Instance | BindingFlags.NonPublic);
            Console.WriteLine(fi.GetValue(s));
        }        enum 赏识度
        {
            十分欣赏, 比较欣赏, 一般, 失望, 垃圾
        }
        class 师傅
        {
            private double 师傅的功力;
            public 师傅()
            {
                this.师傅的功力 = 100;
            }
            protected double 传授武功(赏识度 s)
            {
                switch (s)
                {
                    case 赏识度.十分欣赏:
                        return 0.9 * this.师傅的功力;
                    case 赏识度.比较欣赏:
                        return 0.7 * this.师傅的功力;
                    case 赏识度.一般:
                        return 0.5 * this.师傅的功力;
                    case 赏识度.失望:
                        return 0.3 * this.师傅的功力;
                    case 赏识度.垃圾:
                        return 0.1 * this.师傅的功力;
                    default:
                        return 0;
                }
            }
        }        class 徒弟 : 师傅
        {
            public double 徒弟的功力;
            public 徒弟(赏识度 s)
            {
                this.徒弟的功力 = this.传授武功(s);
            }
        }不管徒弟再怎么努力，师傅都不会把武功全教授给他，除非被人偷了……

Answer 19

我同意30楼lovefootball同志的说法，这样才能很好的保护数据，并且可以节省好多无用的代码，在MS的示例程序中很多地方都是这么用的。
比如，现在有很多产品，主要分为两大类，一类是电脑，一类是汽车
我们可以做如下设计：
1，首先设计一个产品的基类:ProBasepublic class ProBase
{
private enum PropertyTypes
{
//公共的东西写在这里面
 caption=0,
 name=1,
}
private Dictionary<int,string> propCol;//在这里写基类的公共属性
public virtual string Caption
{
get{return GetPropertyValue(PropertyTypes.caption);}
set{SetPropertyValue(PropertyTypes.caption,value);}
}
public virtual string Name
{
get{return GetPropertyValue(PropertyTypes.name);}
set{SetPropertyValue(PropertyTypes.name,value);}
}public string GetPropertyValue(int propType)
{
return propCol.trygetvalue(propType)
}public void SetPropertyValue(int propType,string value)
{
propCol.add(propType,value);
}}然后我们加了一类产品叫电脑，它比基类多一些属性，比如说，显示器名，我们来写出这个类，public class ComputerPro:ProBase
{
private enum PropertyTypes
{
//公共的东西
 caption=0,
 name=1,
 //新加属性
 monitor＝2，
}
public string Monitor
{
get{return GetPropertyValue(PropertyTypes.monitor);}
set{SetPropertyValue(PropertyTypes.monitor,value);}
}}再加一个类型：汽车，有发动机属性public class CarPro:ProBase
{
private enum PropertyTypes
{
//公共的东西
 caption=0,
 name=1,
 //新加属性
 engine＝2，
}
public string Monitor
{
get{return GetPropertyValue(PropertyTypes.engine);}
set{SetPropertyValue(PropertyTypes.engine,value);}
}}以上代码可能不是很合适，但其中的意思应该是比较明白了。

Answer 20

子类不可以继承父类的private的成员
在子类中  super.name 可以使用，是因为是super关键字。super关键字：代表的是父类的一个实类。
this关键字：代表的是类本身的实类。如下：
super.name 语法等效如下：
parent p = new p();
p.name;