1，静态方法和非静态方法的区别：

例子1：

（1）静态方法

namespace 静态方法
{
    
    class Program
    {
        public static int Add(int x, int y)             //声明一个静态方法
        {
            return x + y;
        }
        static void Main(string[] args)
        {
            Console.WriteLine("学敏，咱们的计算结果是：  " + Program.Add(2, 4));            //使用类名调用静态方法
        }
    }
}

运行结果：

（2）非静态方法

namespace 非静态方法
{
    class Program
    {
        public int Add(int x, int y)              //声明一个非静态方法
        {
            return x + y;

        }
        static void Main(string[] args)
        {
            Program xuemin = new Program();                                //实例化类Program
            Console.WriteLine("学敏，计算结果为 " + xuemin.Add(2, 4));        //使用实例化对象xuemin调用定义的非静态方法

        }
    }
}

运行结果：

2，方法重载和方法重写的不同：

例子2：

（1）方法重载

namespace 方法重载
{
    class Program
    {
        public static int Add(int x, int y)      //定义静态方法Add，返回值为int类型，两个int类型参数
        {
            return x + y;

        }
        public double Add(int x, double  y)       //方法Add，两个参数，一个double类型，一个int类型
        {
            return x + y;

        }
        public int Add(int x, int y, int z)      //方法Add，三个参数，均为int类型
        {
            return x + y + z;

        }
        static void Main(string[] args)
        {
            Program xuemin = new Program();
            int x=3;
            int y1=4;
            double y2 = 3.2;
            int z=5;

            Console.WriteLine("学敏，以下是计算结果，请注意查收！！"+"\n");

            //根据传入的参数类型和个数的不同调用不同的Add重载方法
            Console .WriteLine ("x"+"+"+"y1"+"="+Program .Add (x ,y1 ));
            Console .WriteLine ("x"+"+"+"y2"+"="+xuemin .Add (x ,y2 ));
            Console .WriteLine ("x"+"+"+"y1"+"+"+"z"+"="+xuemin .Add (x ,y1,z  ));

        }
    }
}

运行结果：

（2）方法重写

见例子3就有方法重写

3，通过例子3能掌握：

1，抽象类不能直接实例化，抽象类如何实例化？—先实例化派生类，然后使用派生类对象实例化抽象类

2，抽象类和抽象类的使用：

例子3：声明一个抽象类myClass，该抽象类中声明了两个属性和一个方法，其中为两个属性提供了具体实现，方法为抽象方法。然后声明一个派生类DriveClass，继承自myClass，在DriveClass派生类中重写myClass中的抽象方法，并提供具体实现。最后在主程序类Program的Main方法中实例化DriveClass派生类的一个对象，使用该对象实例化抽象类，并使用抽象类对象访问抽象类中的属性和派生类中重写的方法。

namespace 抽象类和抽象方法的使用
{
    abstract class myClass                  //声明一个抽象类myClass
    {
        string id;
        string name;

        public string ID                         //编号属性ID
        {
            get
            { return id; }

            set
            { id = value; }

        }

        public string Name                      //姓名属性Name
        {
            get
            { return name; }

            set
            { name = value; }
        }

        public abstract void ShowInfo();         //声明一个抽象方法ShowInfo

    }

    class DriveClass : myClass                                     //声明一个派生类DriveClass，派生自类myClass
    {
        public override void ShowInfo()                //派生类DriveClass重写基类myClass中的抽象方法ShowInfo
        {
            Console.WriteLine(ID + " " + Name);

        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            DriveClass driveclass = new DriveClass();         //实例化派生类DriveClass
            myClass xuemin = driveclass;                                  //使用派生类对象driveclass来实例化抽象类

            xuemin.ID = "廊坊师范学院001号";