C#总结（三）—三大特性（封装、继承、多态）

最新推荐文章于 2024-04-07 01:38:27 发布

gxq741718618

最新推荐文章于 2024-04-07 01:38:27 发布

阅读量1.4k

点赞数 1

分类专栏：【.NET学习】

本文链接：https://blog.csdn.net/gxq741718618/article/details/8675933

版权

【.NET学习】专栏收录该内容

36 篇文章 1 订阅

订阅专栏

一、封装

1、定义

每个对象都包含它进行操作所需要的所有信息，这个特性称为封装。因此对象不必以来其他对象来完成自己的操作。这样方法和类包装在类中，通过类的实例来实现。

2、好处

良好的封装能够减少耦合；

类内部实现就可以自由地修改；

类具有清晰的接口；

3、实例

<span style="font-size:18px;">class  Cat

｛

        private string name="";

        public Cat(string name)

        {

             this name=name;

        }

  

       public string Shout()

       {

               return "我的名字叫"+name+"小猫";

      }

｝</span>

二、继承

1、定义

继承就是从父类中获取一些公开的成员，如方法和属性。C#中只允许继承一个父类，但允许继承多个接口。如果子类继承接口，则必须实现接口中定义的所有公开成员。

公开成员是指在父类中定义为public的成员（public的作用域可在子类中生效，而private作用域则不可）

子类继承父类：

子类拥有父类非Private的属性和功能；
子类具有自己的属性和功能，即子类可以扩展父类没有的属性和功能；

子类还可以以自己的方式实现父类的功能（方法重写）

2、优点

继承使得所有子类公共部分都放在父类中，使得代码得到共享，这就避免了重复。此外，继承可使得修改或扩展继承而来的实现都较为容易。

3、实例

<span style="font-size:18px;">例1：

//父类 ParentClass

classParentClass

 {

       privatestring_name;                //属性

       public stringParentName        //父类名

       ｛

              get｛return _name;｝

              set{_name=value;}

        ｝

}</span>

<span style="font-size:18px;">//子类

//父类SonClass

class SonClass：ParentClass

 {

       privatestring_name;                //属性

       public stringSonName        //子类名

       ｛

              get｛return _name;｝

              set{_name=value;}

        ｝

}

//客户端

SonClass myson=new SonClass(); //创建子类对象

myson.ParentName="父名";          //自动继承父类的属性

myson.SonName="子名";          //子类自己的属性

例2：

  private void button1_Click(object sender,EventArgs e)

        {

            Cat cat = new Cat("咪咪");//将类实例化 Cat  cat声明一个Cat对象，对象名为cat；newCat()将此cat对象实例化

            cat.ShoutNum = 5;            //给属性赋值

            MessageBox.Show(cat.Shout());

        }

        class Animal                               //定义父类

        {

            protected string name ="";          //注意变为Protected  子类可以继承

            public Animal(string name)

            {

                this.name = name;

 

            }

            public Animal()

            {

                this.name = "无名";

            }

            protected int shoutNum = 3;               //变为protected

            public int ShoutNum

            {

                get

                {

                    return shoutNum;

                }

                set

                {

                    shoutNum = value;

                }

            }

        }

        class Cat : Animal                       //注意变化

        {

            public Cat() : base()                //子类构造方法需要调用父类同样参数类型的构造方法，用base关键字代表父类

            { }

            public Cat(string name):base(name)           //注意变化

            { }

            public string Shout()

            {

                string result = "";

                for (int i = 0; i <shoutNum; i++)

                    result += "喵！";

                return "我的名字叫：" +name + "" + result;

            }

        }

        class Dog : Animal                               //注意变化

        {

            public Dog() : base()

            { }

            public Dog(string name): base(name)

            { }

            public string shout()

            {

                string result = "";

                for (int i = 0; i <shoutNum; i++)

                    result += "汪！";

                return "我的名字叫：" +name + "" + result;

            }

        }

        private void button2_Click(objectsender, EventArgs e)

        {

            Dog dog = new Dog("狗");//将类实例化 Cat  cat声明一个Cat对象，对象名为cat；newCat()将此cat对象实例化

            dog.ShoutNum = 5;            //给属性赋值

            MessageBox.Show(dog.shout());

        }
</span>

4、注意

Protected表示继承时子类可以对基类有完全访问权。也就是说protected修饰的类成员，对子类公开，段不对其他类公开。

三、多态

1、定义

多态是指类可以有多种形态，通过修改可以形成多个实现方法。子类从父类继承时它会获得父类的所有方法、字段、属性、事件。多态表示不同的对象可以执行相同的操作，但要通过它们自己的实现代码来执行。

若要改变父类的数据和行为，两种方式：可创建新的成员替换父级成员，或者可以重写虚拟的父级成员。

（1）若要替换父级成员，需要使用new关键字。下面是GetName方法的两种形态，一种是返回父级名称，一种是返回子级名称。

<span style="font-size:18px;">第一种：返回父级名称

class PerentClass    //父类

｛

       public string GetName()

       {

          return"父级名称";

        }

｝

第二种：返回子级名称

class SonClass：PerentClass     //子类继承父类

｛

       public new string GetName()

       {

          return"子级名称";

        }

｝

（2）重写虚拟的父级成员的两个条件：父级成员使用关键字“virtual”;子级成员使用“override”。代码

class PerentClass    //父类

｛

       public virtual string  GetName()

       {

          return"父级名称";

        }

｝

 

class SonClass：PerentClass     //子类继承父类

｛

       public override string GetName()

       {

          return"子级名称";

        }

｝</span>

2、注意

子类以父类省份出现
子类在工作中以自己的方式来实现

子类乙父类的身份出现时，子类特有的属性和方法不可同时使用

使用多态时，需了解：虚方法和方法重写

为了使子类的实例完全接替来自父类的成员，父类必须将该成员声明为虚拟的。这是通过在该成员的返回类型之前添加virtual来实现。

子类选择使用override关键字，将父类实现替换为自己的实现，这就是方法重写。

3、实例

（1）创建类"Employee"表示公司里的员工。它包含虚方法GetDepart。代码：

class Employee    //父类

｛

       public virtual string  GetDepart()

       {

          return"总公司";

        }

｝

（2）创建类"MarketEmployee"，它重写了父类中的GetDepart方法。代码

class MarketEmployee：Employee    //子类继承父类

｛

       public override string GetDepart()

       {

          return"市场部";

        }

｝

（3）客户端调用两种形态的方法。

Employee myee=new Employee();                            //创建父类

string str1=myee.GetDepart();                                 //结果为父公司

MarketEmployee yee=newMarketEmployee();    //创建子类

string str2=yee.GetDepart();                                   //结果为子公司