方法的重载、重构、重写有什么区别？举例说明，求大神！

重构：就是代码优化

重载：发生在同一类中，方法名相同，参数列表不同

重写：发生在父子类中，子类中有一个方法名，参数列表和返回值类型与父类相同的方法完全相同时

重构：就是代码优化，或则你可以理解为代码的修改！

           例：开始你的类名是A现在要改为B也称为重构的一种

重载：发生在同一类中，方法名相同，参数列表不同

重写：发生在父子类中，子类中有一个方法名，参数列表和返回值类型与父类相同的方法完全相同时， 称之为方法重写

代码案例，，，，，，，举例看看

重构：

1.         void Change()
   
2.         {
   
3. int a = 15, b = 20;
   
4.             a = a + b;
   
5.             b = a - b;
   
6.             a = a - b;
   
7.             Console.WriteLine("交换变量的值  a={0},b={1}", a, b);
   
8.             Console.ReadKey();
   
9.         }

复制代码

1.         void Change()
   
2.         {
   
3.             int a = 15, b = 20;
   
4.             int tem;
   
5.             tem = a;
   
6.             a = b;
   
7.             b = tem;
   
8.             Console.WriteLine("交换变量的值  a={0},b={1}", a, b);
   
9.             Console.ReadKey();
   
10.         }

复制代码

重载：

1.       void Change(){}

复制代码

1.   void change(int a) { }

复制代码

重写：

1. 父类
   
2. class String
   
3. {……
   
4.     copy()
   
5. ……}
   
6. 接着写他的子类
   
7. class String1 based String
   
8. {
   
9.     copy();    //重写父类的方法以实现第一种复制功能
   
10. }
    
11. 
    
12. class String2 based String
    
13. {
    
14.     copy();    //重写以实现第二种复制功能
    
15. }

复制代码

// Define the base class
class Car
{
       public int wheels;//公有成员：轮子个数
       protected float weight; //保护成员：重量
       public Car()
       {
         // ......
       }
       public Car(int w,float g)
       {
              wheels = w;
              weight = g;
       }
        public virtual void DescribeCar()
      {
            System.Console.WriteLine("Four wheels and an engine.");
      }
}
// Define the derived classes
class ConvertibleCar : Car
{
    public new virtual void DescribeCar()
    {
        base.DescribeCar();
        System.Console.WriteLine("A roof that opens up.");
    }
}
class Minivan : Car
{
    public override void DescribeCar()
    {
        base.DescribeCar();
        System.Console.WriteLine("Carries seven people.");
    }
}
现在可以编写一些代码来声明这些类的实例，并调用它们的方法以便对象能够描述其自身：
public static void TestCars1()
{
    Car car1 = new Car();
    car1.DescribeCar();
    System.Console.WriteLine("----------");
    ConvertibleCar car2 = new ConvertibleCar();
    car2.DescribeCar();
    System.Console.WriteLine("----------");
    Minivan car3 = new Minivan();
    car3.DescribeCar();
    System.Console.WriteLine("----------");
}
正如预期的那样，输出类似如下所示：
Four wheels and an engine.
----------
Four wheels and an engine.
A roof that opens up.
----------
Four wheels and an engine.
Carries seven people.

首先把三个，每一个理解透彻了，慢慢就会理解之间的区别了。