刚刚学习.Net，到了什么继承，重载，委托这里就搞不明白了？

Question

刚刚学习.Net，到了什么继承，重载，委托这里就搞不明白了，大家能不能帮忙写个例子，帮小弟我度过这个门槛...
谢谢啦。

Answer 1

呵呵，你遇到的问题，我以前也遇到过，而且在我的博客里面也把这个作为重点贴出了，下面我把我以前做的例子给你贴出来，你自己回去做下试验：
public partial class ClassJiCheng : System.Web.UI.Page
...{
    //sealed class Computer：使用sealed将事先对类的密封，结果就是这个类无法被继承，密封类不能同时又是抽象类，因为抽象类总是希望被继承。
    public class Computer
    ...{
        //protected:访问仅限包含类或从包含类派生的类型。
        //private:访问仅限于包含类型。
        protected int _mainBoard;//定义的主板的数量(这里我们为什么没定义类型为private类型，因为我们下面将创建一个派生的类，该派生类需要访问基类的属性)。
        protected int _hardDisk;//定义硬盘的数量。
        //定义一个事件。
        public delegate void ComputerChangHender(string s,int e);//定义一个委托。
        public event ComputerChangHender ComputerChanged;//定义一个事件。
        //构造函数。
        public Computer()
        ...{
            _mainBoard = 1;
            _hardDisk = 2;
        }
        public Computer(int x, int y)
        ...{
            _mainBoard = x;
            _hardDisk = y;
        }
        public int MainBoard
        ...{
            get ...{
                return _mainBoard;
            }
            set ...{
                _mainBoard = value;
                string s = "_mainBoard";
                ComputerChanged(s,value);//如果修改了这个值，将加法这个事件。
            }
        }
        public int HardDisk
        ...{
            get ...{
                return _hardDisk;
            }
            set ...{
                _hardDisk = value;
                string s = "_hardDisk";
                ComputerChanged(s,value);
            }
        }
        public string MainBoardInfo(int m)
        ...{ 
            switch (m)
            ...{
                case 0:
                    return "一块主板都没有怎么运行。";
                    //break;用到switch时，如果return了，后面就不要习惯性的跟break了，要不然vs警告break是无法访问的代码。
                case 1:
                    return "呵呵，电脑可以正常运行了。";
                case 2:
                    return "你见过两块主板的电脑吗？";
                case 3:
                    return "三个主板，好奇怪哦！";
                default:
                    return "大哥，你电脑到底有几块主板？";
            }
        }
        
    }
    public class OldComputer : Computer //创建一个IBM电脑对象，继承与电脑。
    ...{
        private int year;
        private string oem;
        public OldComputer(int ye, string oe, int m): base(888, 999)
        ...{
            year = ye;
            oem = oe;
            _mainBoard = m;
        }
        public string OemComputer
        ...{
            get
            ...{
                return "这台" + oem + "电脑，它有" + _mainBoard + "个主板和" + _hardDisk + "个硬盘，它已经使用了" + year + "年了。";
            }
        }
        public string Test()
        ...{
            return base.MainBoard.ToString() + "," + base.HardDisk.ToString();//通过base和this访问基类成员。
        }
        public string MainBoardInfo(string s, int m)//这里我们为子类编写了一个与基类同名的方法，但签名不同。
        ...{
            return s + "，" + m;
        }
        public new string MainBoardInfo(int m)
        ...{
            string c = base.MainBoardInfo(m);//这里我们使base调用基类同名的方法。
            return "父方法被覆盖，现在我们返回的是" + m + "我们调用基类同名方法的结果是：" + c;
        }
    }
    protected void Page_Load(object sender, EventArgs e)
    ...{
        Computer c1 = new Computer(2,2);
        c1.ComputerChanged += new Computer.ComputerChangHender(c1_ComputerChanged);//注册这个事件。
        c1.MainBoard = 1;
        c1.HardDisk = 2;//触发了事件。        Response.Write("主板有" + c1.MainBoard + "，硬盘有" + c1.HardDisk);
        Response.Write("<br/>调用<font color='red'>基类</font>的方法的返回是：" + c1.MainBoardInfo(3));
        Response.Write("<br/>--------------------上面是通过实例化了一个基类的对象，下面的代码是实例化一个子类的对象---------------------");
        OldComputer c2 = new OldComputer(8,"Levono",20);
        Response.Write("<br/>" + c2.OemComputer);//Output:这台Levono电脑，它有20个主板和999个硬盘，它已经使用了8年了(这里一定要弄明白了)。
        Response.Write("<br/>子类调用父类的方法返回的是：" + c2.MainBoardInfo(2));//Output:子类调用父类的方法返回的是：父方法被覆盖，现在我们返回的是2我们调用基类同名方法的结果是：你见过两块主板的电脑吗？
        Response.Write("<br/>子类调用父类的方法返回的是" + c2.MainBoardInfo("IBM", 111));//Output:子类调用父类的方法返回的是IBM，111
        Response.Write("<br/>子类调用父类的方法返回的是" + c2.Test());//Output:子类调用父类的方法返回的是20,999 。【20来自OldComputer c2 = new OldComputer(8,"Levono",20),999来自base(888,999)】。
    }
    void c1_ComputerChanged(string s, int m)
    ...{ 
        if(s == "_mainBoard")
        ...{
            switch (m)
            ...{
                case 0:
                    Response.Write("没有主板，不会吧。<br/>");
                    break;
                case 1:
                    Response.Write("一个主板很正常。<br/>");
                    break;
                case 2:
                    Response.Write("两个主板，没见过。<br/>");
                    break;
                case 3:
                    Response.Write("三个主板，晕死。<br/>");
                    break;
            }
        }
        if (s == "_hardDisk")
        ...{
            switch (m)
            ...{
                case 0:
                    Response.Write("没有主板，你电脑运行的了吗。<br/>");
                    break;
                case 1:
                    Response.Write("就一个一个硬盘啊，少了点吧。<br/>");
                    break;
                case 2:
                    Response.Write("两个硬盘，呵呵，还可以。<br/>");
                    break;
                case 3:
                    Response.Write("三个硬盘，你真富有。<br/>");
                    break;
            }
        }
    }
}这篇文章的地址在我的博客：http://blog.csdn.net/WanTianwen/archive/2008/04/27/2334041.aspx希望大家可以一起进步。

Answer 2

重贴一次吧，上面的格式好像有点错误.public partial class ClassJiCheng : System.Web.UI.Page
{
    //sealed class Computer：使用sealed将事先对类的密封，结果就是这个类无法被继承，密封类不能同时又是抽象类，因为抽象类总是希望被继承。
    public class Computer
    {
        //protected:访问仅限包含类或从包含类派生的类型。
        //private:访问仅限于包含类型。
        protected int _mainBoard;//定义的主板的数量(这里我们为什么没定义类型为private类型，因为我们下面将创建一个派生的类，该派生类需要访问基类的属性)。
        protected int _hardDisk;//定义硬盘的数量。
        //定义一个事件。
        public delegate void ComputerChangHender(string s,int e);//定义一个委托。
        public event ComputerChangHender ComputerChanged;//定义一个事件。
        //构造函数。
        public Computer()
        {
            _mainBoard = 1;
            _hardDisk = 2;
        }
        public Computer(int x, int y)
        {
            _mainBoard = x;
            _hardDisk = y;
        }
        public int MainBoard
        {
            get {
                return _mainBoard;
            }
            set {
                _mainBoard = value;
                string s = "_mainBoard";
                ComputerChanged(s,value);//如果修改了这个值，将加法这个事件。
            }
        }
        public int HardDisk
        {
            get {
                return _hardDisk;
            }
            set {
                _hardDisk = value;
                string s = "_hardDisk";
                ComputerChanged(s,value);
            }
        }
        public string MainBoardInfo(int m)
        { 
            switch (m)
            {
                case 0:
                    return "一块主板都没有怎么运行。";
                    //break;用到switch时，如果return了，后面就不要习惯性的跟break了，要不然vs警告break是无法访问的代码。
                case 1:
                    return "呵呵，电脑可以正常运行了。";
                case 2:
                    return "你见过两块主板的电脑吗？";
                case 3:
                    return "三个主板，好奇怪哦！";
                default:
                    return "大哥，你电脑到底有几块主板？";
            }
        }
        
    }
    public class OldComputer : Computer //创建一个IBM电脑对象，继承与电脑。
    {
        private int year;
        private string oem;
        public OldComputer(int ye, string oe, int m): base(888, 999)
        {
            year = ye;
            oem = oe;
            _mainBoard = m;
        }
        public string OemComputer
        {
            get
            {
                return "这台" + oem + "电脑，它有" + _mainBoard + "个主板和" + _hardDisk + "个硬盘，它已经使用了" + year + "年了。";
            }
        }
        public string Test()
        {
            return base.MainBoard.ToString() + "," + base.HardDisk.ToString();//通过base和this访问基类成员。
        }
        public string MainBoardInfo(string s, int m)//这里我们为子类编写了一个与基类同名的方法，但签名不同。
        {
            return s + "，" + m;
        }
        public new string MainBoardInfo(int m)
        {
            string c = base.MainBoardInfo(m);//这里我们使base调用基类同名的方法。
            return "父方法被覆盖，现在我们返回的是" + m + "我们调用基类同名方法的结果是：" + c;
        }
    }
    protected void Page_Load(object sender, EventArgs e)
    {
        Computer c1 = new Computer(2,2);
        c1.ComputerChanged += new Computer.ComputerChangHender(c1_ComputerChanged);//注册这个事件。
        c1.MainBoard = 1;
        c1.HardDisk = 2;//触发了事件。        Response.Write("主板有" + c1.MainBoard + "，硬盘有" + c1.HardDisk);
        Response.Write("<br/>调用<font color='red'>基类</font>的方法的返回是：" + c1.MainBoardInfo(3));
        Response.Write("<br/>--------------------上面是通过实例化了一个基类的对象，下面的代码是实例化一个子类的对象---------------------");
        OldComputer c2 = new OldComputer(8,"Levono",20);
        Response.Write("<br/>" + c2.OemComputer);//Output:这台Levono电脑，它有20个主板和999个硬盘，它已经使用了8年了(这里一定要弄明白了)。
        Response.Write("<br/>子类调用父类的方法返回的是：" + c2.MainBoardInfo(2));//Output:子类调用父类的方法返回的是：父方法被覆盖，现在我们返回的是2我们调用基类同名方法的结果是：你见过两块主板的电脑吗？
        Response.Write("<br/>子类调用父类的方法返回的是" + c2.MainBoardInfo("IBM", 111));//Output:子类调用父类的方法返回的是IBM，111
        Response.Write("<br/>子类调用父类的方法返回的是" + c2.Test());//Output:子类调用父类的方法返回的是20,999 。【20来自OldComputer c2 = new OldComputer(8,"Levono",20),999来自base(888,999)】。
    }
    void c1_ComputerChanged(string s, int m)
    { 
        if(s == "_mainBoard")
        {
            switch (m)
            {
                case 0:
                    Response.Write("没有主板，不会吧。<br/>");
                    break;
                case 1:
                    Response.Write("一个主板很正常。<br/>");
                    break;
                case 2:
                    Response.Write("两个主板，没见过。<br/>");
                    break;
                case 3:
                    Response.Write("三个主板，晕死。<br/>");
                    break;
            }
        }
        if (s == "_hardDisk")
        {
            switch (m)
            {
                case 0:
                    Response.Write("没有主板，你电脑运行的了吗。<br/>");
                    break;
                case 1:
                    Response.Write("就一个一个硬盘啊，少了点吧。<br/>");
                    break;
                case 2:
                    Response.Write("两个硬盘，呵呵，还可以。<br/>");
                    break;
                case 3:
                    Response.Write("三个硬盘，你真富有。<br/>");
                    break;
            }
        }
    }
}
有什么不明白的请访问我的blog:http://blog.csdn.net/WanTianwen

Answer 3

public partial class ClassJiCheng : System.Web.UI.Page
{
    //sealed class Computer：使用sealed将事先对类的密封，结果就是这个类无法被继承，密封类不能同时又是抽象类，因为抽象类总是希望被继承。
    public class Computer
    {
        //protected:访问仅限包含类或从包含类派生的类型。
        //private:访问仅限于包含类型。
        protected int _mainBoard;//定义的主板的数量(这里我们为什么没定义类型为private类型，因为我们下面将创建一个派生的类，该派生类需要访问基类的属性)。
        protected int _hardDisk;//定义硬盘的数量。
        //定义一个事件。
        public delegate void ComputerChangHender(string s,int e);//定义一个委托。
        public event ComputerChangHender ComputerChanged;//定义一个事件。
        //构造函数。
        public Computer()
        {
            _mainBoard = 1;
            _hardDisk = 2;
        }
        public Computer(int x, int y)
        {
            _mainBoard = x;
            _hardDisk = y;
        }
        public int MainBoard
        {
            get {
                return _mainBoard;
            }
            set {
                _mainBoard = value;
                string s = "_mainBoard";
                ComputerChanged(s,value);//如果修改了这个值，将加法这个事件。
            }
        }
        public int HardDisk
        {
            get {
                return _hardDisk;
            }
            set {
                _hardDisk = value;
                string s = "_hardDisk";
                ComputerChanged(s,value);
            }
        }
        public string MainBoardInfo(int m)
        { 
            switch (m)
            {
                case 0:
                    return "一块主板都没有怎么运行。";
                    //break;用到switch时，如果return了，后面就不要习惯性的跟break了，要不然vs警告break是无法访问的代码。
                case 1:
                    return "呵呵，电脑可以正常运行了。";
                case 2:
                    return "你见过两块主板的电脑吗？";
                case 3:
                    return "三个主板，好奇怪哦！";
                default:
                    return "大哥，你电脑到底有几块主板？";
            }
        }
        
    }
    public class OldComputer : Computer //创建一个IBM电脑对象，继承与电脑。
    {
        private int year;
        private string oem;
        public OldComputer(int ye, string oe, int m): base(888, 999)
        {
            year = ye;
            oem = oe;
            _mainBoard = m;
        }
        public string OemComputer
        {
            get
            {
                return "这台" + oem + "电脑，它有" + _mainBoard + "个主板和" + _hardDisk + "个硬盘，它已经使用了" + year + "年了。";
            }
        }
        public string Test()
        {
            return base.MainBoard.ToString() + "," + base.HardDisk.ToString();//通过base和this访问基类成员。
        }
        public string MainBoardInfo(string s, int m)//这里我们为子类编写了一个与基类同名的方法，但签名不同。
        {
            return s + "，" + m;
        }
        public new string MainBoardInfo(int m)
        {
            string c = base.MainBoardInfo(m);//这里我们使base调用基类同名的方法。
            return "父方法被覆盖，现在我们返回的是" + m + "我们调用基类同名方法的结果是：" + c;
        }
    }
    protected void Page_Load(object sender, EventArgs e)
    {
        Computer c1 = new Computer(2,2);
        c1.ComputerChanged += new Computer.ComputerChangHender(c1_ComputerChanged);//注册这个事件。
        c1.MainBoard = 1;
        c1.HardDisk = 2;//触发了事件。        Response.Write("主板有" + c1.MainBoard + "，硬盘有" + c1.HardDisk);
        Response.Write("<br/>调用<font color='red'>基类</font>的方法的返回是：" + c1.MainBoardInfo(3));
        Response.Write("<br/>--------------------上面是通过实例化了一个基类的对象，下面的代码是实例化一个子类的对象---------------------");
        OldComputer c2 = new OldComputer(8,"Levono",20);
        Response.Write("<br/>" + c2.OemComputer);//Output:这台Levono电脑，它有20个主板和999个硬盘，它已经使用了8年了(这里一定要弄明白了)。
        Response.Write("<br/>子类调用父类的方法返回的是：" + c2.MainBoardInfo(2));//Output:子类调用父类的方法返回的是：父方法被覆盖，现在我们返回的是2我们调用基类同名方法的结果是：你见过两块主板的电脑吗？
        Response.Write("<br/>子类调用父类的方法返回的是" + c2.MainBoardInfo("IBM", 111));//Output:子类调用父类的方法返回的是IBM，111
        Response.Write("<br/>子类调用父类的方法返回的是" + c2.Test());//Output:子类调用父类的方法返回的是20,999 。【20来自OldComputer c2 = new OldComputer(8,"Levono",20),999来自base(888,999)】。
    }
    void c1_ComputerChanged(string s, int m)
    { 
        if(s == "_mainBoard")
        {
            switch (m)
            {
                case 0:
                    Response.Write("没有主板，不会吧。<br/>");
                    break;
                case 1:
                    Response.Write("一个主板很正常。<br/>");
                    break;
                case 2:
                    Response.Write("两个主板，没见过。<br/>");
                    break;
                case 3:
                    Response.Write("三个主板，晕死。<br/>");
                    break;
            }
        }
        if (s == "_hardDisk")
        {
            switch (m)
            {
                case 0:
                    Response.Write("没有主板，你电脑运行的了吗。<br/>");
                    break;
                case 1:
                    Response.Write("就一个一个硬盘啊，少了点吧。<br/>");
                    break;
                case 2:
                    Response.Write("两个硬盘，呵呵，还可以。<br/>");
                    break;
                case 3:
                    Response.Write("三个硬盘，你真富有。<br/>");
                    break;
            }
        }
    }
}
自己从基础慢慢开始，万丈高楼平地起嘛！