1，静态成员和非静态成员的区别？

（1）静态成员使用static修饰符进行声明；在类被实例化时被创建；属于类本身；只能通过类名进行访问（网上有的地方说可以通过实例访问，经我验证，C#中不可以）。

（2）不带static修饰符声明的为非静态成员；在对象被实例化时被创建；属于实例本身；只能通过实例进行访问。

//实例1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Example01
{
    class Program
    {
        class Class1
        {
            public static String staticStr = "Class";
            public String notStaticStr = "Obj";
        }

        static void Main(string[] args)
        {
            Console.WriteLine("Class1's staticStr:{0}", Class1.staticStr);
            
            Class1 tmpObj1 = new Class1();
            tmpObj1.notStaticStr = "tmpObj1";
            Class1 tmpObj2 = new Class1();
            tmpObj2.notStaticStr = "tmpObj2";
  
            //Console.WriteLine("tmpObj1's staticStr:{0}", tmpObj3.staticStr);   不能通过对象引用静态成员
            Console.WriteLine("tmpObj1's notstaticStr:{0}", tmpObj1.notStaticStr);
            Console.WriteLine("tmpObj2's notstaticStr:{0}", tmpObj2.notStaticStr);

            Console.ReadKey();
        }
    }
}

2，const 和static readonly的区别？

（1）用const修饰符声明的成员叫常量，是在编译期初始化并嵌入到客户端程序。

（2）用static readonly修饰符声明的成员依然是变量，只不过具有和常量类似的使用方法：通过类进行访问；初始化以后不可修改。但与变量不同的是这种变量是在运行期初始化。

3，sealed修饰符的作用？

（1）sealed修饰符表示密封。

（2）用于类时，表示该类不能再被继承，不能和abstract同时使用。因为这两个修饰符在含义上互相排斥。

（3）用于方法和属性时，表示该方法或属性不能再被重写，必须和override关键字一起使用，因为使用sealed修饰符的方法或属性肯定是基类中相应的虚成员。

（3）通常用于实现第三方类库时不想被客户端继承，或用于没有必要再继承的类，以防止滥用继承造成层次结构体系混乱。

//实例3
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace Example03
{
    class Program
    {
        class A
        {
            public virtual void F()
            {
                Console.WriteLine("A.F");
            }
            public virtual void G()
            {
                Console.WriteLine("A.G");
            }
        }

        class B : A
        {
            public sealed override void F()
            {
                Console.WriteLine("B.F");
            }
            public override void G()
            {
                Console.WriteLine("B.G");
            }
        }

        class C : B
        {
            public override void G()
            {
                Console.WriteLine("C.G");
            }
        }

        static void Main(string[] args)
        {
            new A().F();
            new A().G();

            new B().F();
            new B().G();

            new C().F();
            new C().G();

            Console.ReadKey();
        }
    }
}

类B在继承类A时可以重写两个虚函数。但类B对F方法进行了密封，类C