一步一步学习C#(四 继承)

1.类的继承

 

     1)继承父类，即拥有该类的所有成员字段和方法     比如：继承一个控件，就等于继承了此控件的所有方法与属性，节省编码量。

 

        1.启动vs,建立一个简单的winform窗口，输入一个按钮，在按钮事件中写入代码：MessageBox.Show("you clicked me!");

 

        2、我们再建立一个Form窗口，我们选择“继承的窗体”，再次选择刚刚建立的Form1。

 

        3、这样在新建立的Form2窗口中也有一个按钮了（这个按钮就是继承了Form1窗口而来，而且删除不掉）。

 

        4、我们修改入口方法main(),修改代码如下：      将原来的Application.Run(new Form1());修改为为Application.Run(new Form2());

 

        5、运行效果一样，但是实际上运行的是一个继承的窗体。

 

 （1）接口类似于一个模板，它定义了一种签名方式，什么是签名？  int onemethod(int a){}  就是定义了一种签名方式，它的内容是空的。 如果一个具有int参数并且有int返回值的方法，我们就说满足此种签名方式。 （2）一个类继承了接口，则必须要有接口中定义的签名的方式的方法。 （3）接口中定义的方法不能有实际内容。 （4）接口就是通过继承来使用的。 （5）接口不能包括字段。

 

 （1）       结构派生于System.ValueType，它们不能实现继承，但是可以继承接口。 （2）       类可以继承类和接口。

 

 如果签名相同的方法在基类和派生类中都进行了声明，但该方法没有声明为virtual 和 override，派生类方法就会隐藏基类方法。

 

 用base关键字表示基类 用this关键字表示本类     base.<MethodName>()  this. <MethodName>()

 

 （1）抽象类用abstract来定义  （2）抽象类与接口非常类似，抽象方法没有执行代码，  （3）抽象类不能实例化，只能继承  （4）抽象方法没有执行代码，必须在非抽象的派生类中重写  （5）类中成员只要有一个是抽象的，则类必须是抽象的。  （6）抽象方法用override重写，而接口则不用。

 

 （1）对于一些永远也不想让别人继承我们用sealed来修饰它。 （2）当然它的方法是不可重写的,也就是不可以定义为虚方法。 （3）不能将sealed作用于方法。

 

 （1）在子类中声明同样的方法 （2）在子类中声明同样的方法，并用new修饰 （3）在子类中声明同样的方法，用override来修饰，当然必须祖先要有virtual修饰。

 

 （1）声明接口在语法上与声明抽象类完全相同 （2）接口中只能包含方法、属性、索引器和事件的声明。 （3）不能实例化接口，接口不能有构造函数。 （4）接口成员总是公共的，不能声明为虚拟或静态。因为它是依附于类的。 （5）接口是可以继承的。例如：

 

  列子：

 

Public class a
{}
Public class b:a
{}

 

 

 

 

 

2.接口的继承

 

 （1）接口类似于一个模板，它定义了一种签名方式，什么是签名？

 

      int onemethod(int a){}  就是定义了一种签名方式，它的内容是空的。

     如果一个具有int参数并且有int返回值的方法，我们就说满足此种签名方式。

（2）一个类继承了接口，则必须要有接口中定义的签名的方式的方法。

（3）接口中定义的方法不能有实际内容。

（4）接口就是通过继承来使用的。

（5）接口不能包括字段。

接口继承代码：

public interface tank_action
    {
        void fire();
        void go();
    }
 class tank1:tank_action
    {
        public void fire()
        {
            Console.WriteLine("tank1 is now firing!");
        }
        public void go()
        {
            Console.WriteLine("tank1 is now going!");
        }
    }

调用：
tank1 aa = new tank1();
            aa.fire();
            aa.go();
 Console.ReadLine();

注意：

 

 

 

一个类只能有唯一的一个父类，而不能同时继承多个
例如：
 public class a
    {
    }
    public class b
    {
    }
    public class c : a,b
    {
    }
 

 

 

    结构与类在继承上的区别：

（1）结构派生于System.ValueType，它们不能实现继承，但是可以继承接口。

 

（2）类可以继承类和接口。

  

接口特性： 

（1）声明接口在语法上与声明抽象类完全相同

（2）接口中只能包含方法、属性、索引器和事件的声明。

（3）不能实例化接口，接口不能有构造函数。

（4）接口成员总是公共的，不能声明为虚拟或静态。因为它是依附于类的。

（5）接口是可以继承的。

  

3.隐藏方法

    如果签名相同的方法在基类和派生类中都进行了声明，但该方法没有声明为virtual 和 override，派生类方法就会隐藏基类方法。

隐藏方法例子：
 class class1
    {
        public void class1_method1()
        {
            Console.WriteLine("aa");
        }
    }
    class class2:class1
    {
        public void class1_method1()
        {
            Console.WriteLine("bb");
        }
    }
调用：
class2 testclass = 
 new class2();
      testclass.class1_method1();
    Console.ReadLine();

 

 

4.调用函数的基类

 

  用base关键字表示基类

  用this关键字表示本类   

  base.<MethodName>()

  this. <MethodName>()

调用基类例子：
class CustomerAccount
    {
        public virtual decimal CalculatePrice()
        {
            return 1M;
        }
    }
    class GoldAccount : CustomerAccount
    {
        public override decimal CalculatePrice()
        {
            return base.CalculatePrice() * 0.9M;
        }
    } 
调用：
  GoldAccount test = new GoldAccount();            Console.WriteLine(test.CalculatePrice());            Console.ReadLine();

 

 

5.抽象类和抽象方法

 （1）抽象类用abstract来定义

 （2）抽象类与接口非常类似，抽象方法没有执行代码，

 （3）抽象类不能实例化，只能继承

 （4）抽象方法没有执行代码，必须在非抽象的派生类中重写

 （5）类中成员只要有一个是抽象的，则类必须是抽象的。

 （6）抽象方法用override重写，而接口则不用。

抽象类和抽象方法例子：
  abstract class Building
    {
     public abstract decimal Calculate(); // abstract method
     }
    class newBuilding : Building
    {
        public override decimal Calculate ()
        {
            Console.WriteLine("aa");
            return 2.2M;
        }
    }

调用：
      newBuilding test = new newBuilding();
   Console.WriteLine(test.Calculate ());
      Console.ReadLine();


 

 

6.密封类和密封方法 

（1）对于一些永远也不想让别人继承我们用sealed来修饰它。

 

（2）当然它的方法是不可重写的,也就是不可以定义为虚方法。

 

（3）不能将sealed作用于方法。

密封类和密封方法例子：
 sealed class FinalClass
    {
       //不能定义为虚方法,,因为本身这个类都是不需要继承的,那么定义为虚方法的意义就不大了
    //public virtual void cal()
       // {
       //     Console.WriteLine("cc");
       // }
 
        public void cal()
        {
            Console.WriteLine("cc");
        }
        public static void StaCal()
        {
            Console.WriteLine("bb");
        }
    }
 //密封类是不能继承的
    //class DerivedClass : FinalClass
    //{  
        //public override void cal()
        //{
        //    Console.WriteLine("bb");
        //}
    //}
 
 

在子类中覆盖父类方法:

 

（1）在子类中声明同样的方法

 

（2）在子类中声明同样的方法，并用new修饰

 

（3）在子类中声明同样的方法，用override来修饰，当然必须祖先要有virtual修饰。

base 引用父类方法：

public class aa
    {
        public void one()
        {
            Console.WriteLine("aa");
        }
    }
    public class bb : aa
    {
        new public void one()
        {
            base.one();
            Console.WriteLine("bb");
        }
    }
 

 

 

7.类的修饰符