1 /// <summary>
  2     /// 果树类
  3     /// </summary>
  4     class FruitTree
  5     {
  6         /// <summary>
  7         /// 名称
  8         /// 说明：修饰符 protected 保护访问。只限于本类和子类访问，实例不能访问。
  9         /// </summary>
 10         protected string name;
 11         /// <summary>
 12         /// 构造函数
 13         /// </summary>
 14         public FruitTree()
 15         {
 16             this.name = "无名";
 17         }
 18         /// <summary>
 19         /// 构造函数二
 20         /// </summary>
 21         /// <param name="name"></param>
 22         public FruitTree(string name)
 23         {
 24             this.name = name;
 25         }
 26         object _leaf;
 27         object _root;
 28         object _flower;
 29         string _type;
 30         /// <summary>
 31         /// 叶子（公有属性）
 32         /// </summary>
 33         public object leaf
 34         {
 35             get { return _leaf; }
 36             set { _leaf = value; }
 37         }
 38         /// <summary>
 39         /// 根（公有属性）
 40         /// </summary>
 41         public object root
 42         {
 43             get { return _root; }
 44             set { _root = value; }
 45         }
 46         /// <summary>
 47         /// 花（公有属性）
 48         /// </summary>
 49         public object flower
 50         {
 51             get { return _flower; }
 52             set { _flower = value; }
 53         }
 54         /// <summary>
 55         /// 类别（不定义修饰符，默认为私有）
 56         /// </summary>
 57         string type
 58         {
 59             get { return _type; }
 60             set { _type = value; }
 61         }
 62   
 63     }
 64 
 65     /// <summary>
 66     /// 苹果树类
 67     /// 继承自：果树类
 68     /// </summary>
 69     class AppleTree:FruitTree
 70     {
 71         string _myName;
 72         /// <summary>
 73         /// 构造函数
 74         /// 说明：子类调用父类同样的构造函数，需要使用 :base()
 75         /// </summary>
 76         public AppleTree():base()
 77         {          
 78         }
 79         /// <summary>
 80         /// 构造函数二
 81         /// 说明：子类调用父类同样的构造函数，需要使用 :base(name)
 82         /// </summary>
 83         /// <param name="name"></param>
 84         public AppleTree(string name):base(name)
 85         {
 86             _myName = name;
 87         }             
 88 
 89         /// <summary>
 90         /// 返回果实的名字
 91         /// </summary>
 92         /// <returns></returns>
 93         public string MyFruitName()
 94         {
 95             return "我是：" + _myName + "；我的果实叫：苹果";
 96         }
 97     }
 98     /// <summary>
 99     /// 桔树类
100     /// 继承自：果树类
101     /// </summary>
102     class OrangeTree : FruitTree
103     {
104         string _myName;
105         /// <summary>
106         /// 构造函数
107         /// 说明：子类调用父类同样的构造函数，需要使用 :base()
108         /// </summary>
109         public OrangeTree(): base()
110         {
111         }
112         /// <summary>
113         /// 构造函数二
114         /// 说明：子类调用父类同样的构造函数，需要使用 :base(name)
115         /// </summary>
116         /// <param name="name"></param>
117         public OrangeTree(string name): base(name)
118         {
119             _myName = name;
120         }
121 
122         /// <summary>
123         /// 返回果实的名字
124         /// </summary>
125         /// <returns></returns>
126         public string MyFruitName()
127         {
128             return "我是："+_myName+"；我的果实叫：桔子";
129         }
130     }

//调用子类
AppleTree appleTree = new AppleTree("苹果树");
string myName = appleTree.MyFruitName();
//返回结果为：我是：苹果树；我的果实叫：苹果

//调用子类
OrangeTree orangeTree = new OrangeTree("桔子树"); 
string myName = orangeTree. MyFruitName (); 
//返回结果为：我是：桔子树；我的果实叫：桔子