设计模式之三重定义——重载，重写，重构

我对于重载，重构，重写中“重”字的理解是多次，多次对于同一方法的多次调用，同一函数的多次的构造，同一方法的多次写入。但是对于他们如果运作的机制却不是很了解，在后来不断的学习中加深了对他们理解！其实无论是重写还是重载都是属于重构，他们的相互关系正如下图的表示方法：



虽然重构包括了重载和重写，但是重载和重写却是不一样：

一：重载

举个简单的例子：我们可以给一个猫起名字叫“美丽”；也可以给她起名字，直接叫猫猫。但是同样都是属于同一类猫方法，但是却是可以多次调用，返回不同的值。

class Cat
    {
        private string name = "";
        public Cat(string name)    //注意这里构造函数是有参数的“name”的。
        {
            this.name = name;
        }
        public Cat()             //注意这里的构造函数是无参数的，在这个函数体里面直接给出了实际的名字。
        {
            this.name = "猫猫";  
        }
        public string shout()
        {
            return name;
        }
    }

 客户端的代码：

</pre><pre name="code" class="plain"> class Program
    {
        static void Main(string[] args)
        {
            Cat cat = new Cat();  
            Console.WriteLine( cat.shout());
          
            Cat cat1 = new Cat("美丽");
            Console.WriteLine(cat1.shout());

            Console.Read();
           
        }
    }

在这里注意一下：是提供了创建多个方法的能力，但是这些方法使用不同的参数类型。我们在cat（）这个构造函数里面还可以写出更多的参数name，sex，age等等，可以被重复的加载。

当然要在这里普及一下构造函数的好处了，以一下的代码为例：

没有用构造函数的客户端代码：

class Program
    {
        static void Main(string[] args)
        {
            Cat cat = new Cat();
            cat.name = "美丽";
            cat.sex = '女';
            cat.age = 1;
            cat.shout();
         }
    
    }

使用了构造函数的代码：

Cat cat=new Cat("美丽"，"女"，"1");
       cat.shout();

通过代码我们就可以看到，通过使用构造函数可以再类中就对构造函数进行初始化，大大简化了客户端代码的数量，增加了维护性；而且客户端只能通过构造函数访问类，保证了类的封装性和安全性。

二：重写

同样也举一个简单的例子：对于动物来说，每一种动物都有叫声，但是每一种动物的叫声又是不一样。看似不一样，但是我们可以再抽象动物类中虚拟出”叫“的方法，然后在不同的动物个体中存放不同声音！

//抽象类animal
        class Animal
     {
        protected string name = "";
        public Animal(string name)
        {
            this.name = name;
        }
        protected int shouNum = 3;
        public int ShoutNum
        {
            get { return shouNum;}
            set { shouNum = value; }
        
        }
        public string shout()
        {
               string result="";
                for (int i = 0; i <shouNum; i++)
                result += "";
                return "我的名字叫" + name + "" + result;  
        }
        protected virtual string getshoutsound()    //虚拟方法
        {
            return "";
        }
    }
    //类cat
        class Cat : Animal
        {
            public Cat(string name)
                : base(name)
            { }
            public override string getshoutsound()    //类cat对方法getshoutsound（）进行了重写覆盖
            {
                return "喵";
            }
        }
    //类dog
        class Dog:Animal
        {
            public Dog(string name)
                : base(name)
            { }
            public override string getshoutsound()  //类dog对方法getshoutsound（）进行了重写覆盖
            {
               return "汪";  
            }
        }

三：重构，重写和重载的区别：

三重	条件	范围	方法体	参数
重构	一切对于代码设计修改的过程	一切对代码设计的过程，多种情况	——	——
重写	对于子类对父类方法的覆盖上	子类与父类方法上，一种情况	相同	相同
重载	同一类中的两个及两个以上方法名相同的方法上	方法名相同的同一个类中，一种情况	不同	不同

对于在对三重定义的了解之后，发现其实他们还是具有很大的区别： 重写是子类的方法覆盖父类的方法，要求方法名和参数都相同 ；重载是在同一个类中的两个或两个以上的方法，拥有相同的方法名，但是参数却不相同，方法体也不相同重构是可以通过重写或者重载等, 但不限于此, 更改注释,
更改函数名类名。