c#面向对象编程基础续

8.2静态方法与实例方法：
区别：静态方法不对特定实例进行操作，静态方法只能访问类中的静态成员，而不能使用实例成员。访问静态方法只能使用类名，而不需要创建对象，也不适用对象名来引用。
实例方法可以使用类的任何成员。调用实例方法时，必须使用类的实例或对象来引用。实例方法对类的某个给定的实例进行操作，在实例方法中可以使用this来访问该实例。调用实例方法时必须先创建一个对象。
eg:   int exampleVar=0;//实例成员
        static  int staticVar=0;//静态成员
        static void staticMethod()//静态方法
       {
           //exampleVar=1;无法在静态方法中调用实例成员
           staticVar=1;
        }
        void exampleMethod()//实例方法
        {
           //实例中可以调用任何成员，包括静态与实例类
            staticVar=1;         
            exampleVar=1; //等价于this. exampleVar=1;
        }
//方法的调用
       static void Main(string[] args)
      {
             Program.staticMethod();//调用静态方法时直接调用
             //将类进行实例化
             Program p=new Program();
             p.exampleMethod();
            // Program.exampleMethod();是错误的，不能通过访问静态方法的途径去访问实例方法
          }
虚方法：指一个实例方法的声明中含virtual修饰符（virtual关键字必须位于void前）。非虚方法的实现是一成不变的，无论该方法是在声明它的类的实例上调用还是在派生类的实例上调用，实现均相同。与此相反，虚方法的实现可以有派生类取代，取代所继承的虚方法的实现过程称为重写（override）该方法。在虚方法调用中，该调用所涉及的那个实例的运行时类型确定了要被调用的究竟是该方法的哪一种实现。在非虚方法调用中，相关的实例的编译时类型是决定性因素。
重写方法：用相同的签名重写所继承的虚方法。虚方法声明用于引入新方法，而重写方法声明则用于使现有的继承性方法专用化。由override声明的那个方法称为已重写了的基方法。
重写声明和已重写了的基方法具有相同的声明可访问性。即重写声明不能更改所对应的虚方法的可访问性。但是如果已经重写的基方法是protected时，并且声明它的程序集不是包含重写方法的程序集，则重写方法声明的可访问性必须是protected.
注：
（1）virtual 修饰符不能与 static、abstract, private 或 override 修饰符一起使用。
（2）不能重写非虚方法或静态方法。重写的基方法必须是 virtual、abstract 或 override 的。
 ( 3 ) override 声明不能更改 父类virtual 方法的可访问性。override 方法和 virtual 方法必须具有相同的访问级别修饰符。
（4）不能使用修饰符 new、static、virtual 或 abstract 来修改 override 方法。-----不能与abstrac，virtual,override,new,partial一同使用
（5）重写属性声明必须指定与继承属性完全相同的访问修饰符、类型和名称，并且被重写的属性必须是 virtual、abstract 或 override 的
（6）如果我不想让继承Class2的类（即Class2的子类）去重写Write()方法，采用关键字sealed
sealed 修饰符可以应用于类、实例方法和属性。密封类不能被继承。密封方法会重写基类中的方法，但其本身不能在任何派生类中进一步重写。当应用于方法或属性时，sealed 修饰符必须始终与 override 一起使用。
eg:
    //创建一个虚方法与非虚方法，然后分别通过另一类继承，并比较他们的调用结果
    //新建一个class1类
    class Class1
    {
        //默认的方法被指定为私有的（private），只能在当前类中进行访问
        //此处需要在其他类中进行访问，就需要将其指定为public:访问权限最高,只要在项目内部都可以进行访问
        //virtual关键字必须位于void前
        public virtual void virtualMethod()
        {
            Console.WriteLine("这是一个虚方法");
        }
        public void nonVirtualMethod()
        {
            Console.WriteLine("这是一个非虚方法");
        }
    }
    class Class2 : Class1//将Class2继承与Class1
    {
        //重写一下虚方法
        public override void virtualMethod()
        {
            Console.WriteLine("这是一个新写的虚方法");
        }
        public new void nonVirtualMethod()
        {
            Console.WriteLine("这是一个新方法");
        }
    }
Main
{
           //将类进行实例化
            Class1 obj1 = new Class1();
            Class2 obj2 = new Class2();
            obj1.virtualMethod();
            obj1.nonVirtualMethod();
            obj2.virtualMethod();
            obj2.nonVirtualMethod();
            obj1 = obj2;
            obj1.virtualMethod();
            obj1.nonVirtualMethod();
            Console.ReadKey();
}
eg2:重写方法
    class Class1
    {
        public virtual void Write()
        {
            Console.WriteLine("这是一个虚方法，可以被重写");
        }
    }
    //再建一个继承类用于重写方法
    class Class2 : Class1
    {
        //重写方法
        public override sealed void Write()
        {
            Console.WriteLine("这是一个重写方法，被称为已经重写了的基方法");
        }
    }
    //如果我不想让继承Class2的类去重写Write()方法，应该怎么做？
    //在Class2写Write()方法时加入关键字sealed;
    //我再写Class3继承于Class2时，则会出现错误提示重写方法：Class2.Write()是密封的，无法进行重写
   /* class Class3 : Class2
    {
        public override void Write()
        {
            Console.WriteLine("这是我再次重写的方法");
        }
    }
    */
Main
{
            Class1 c1 = new Class1();
            c1.Write();
            Class2 c2 = new Class2();
            c2.Write();
            Console.ReadKey();
}
posted @ 2016-11-15 15:23  fantasy2121  阅读(75)  评论(0)    收藏  举报