深入了解面向对象——面向对象的重要特征（C#）未写完

面向对象的三个基本特征分别为封装、继承、多态。

面向对象概述

对象是现实世界中的实体，它有三个基本要素，分别为封装、继承和多态。而类则是将具有相似属性和方法的对象集合起来。

1、面向过程

2、面向对象

3、类与对象的关系

类的继承

继承允许用户根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易，同时也有利于重用代码和节省开发时间。

当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承已有类的成员即可。这个已有的类被称为基类，这个新的类被称为派生类。

基类和派生类

在类的继承中，被继承的类叫做基类或父类，继承的类叫做派生类或子类。一个类可以派生自多个类或接口，这意味着它可以从多个基类或接口继承数据和方法。

C#中创建派生类的语法如下：

<访问修饰符> class <基类>

{

        ...

}

         clase <派生类>:<基类>

{

        ...

}

当一个类从另一个类派生出来时，派生类就自然具有基类的数据成员、属性和方法等。在基类中定义的这些成员，已经不需要在派生类定义中的重写。在派生类的定义中，只需编写基类所不具有的代码即可。

编写程序 ，通过图形的基类，派生出一个矩形的类，并计算出它的面积。

using System;
namespace Project1
{
    class Shape    //图形
    {
        public void setWidth(int w)
        {
            width = w;
        }
        public void setHeight(int h)
        {
            height = h;
        }
        protected int width;
        protected int height;
    }
    class Rectangle : Shape    //长方形继承于Shape
    {
        public int getArea()
        {
            return (width * height);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Rectangle Rect = new Rectangle();
            Rect.setWidth(6);
            Rect.setHeight(8);
            Console.WriteLine("总面积： {0}", Rect.getArea());
        }
    }
}

运行结果如下：

总面积： 48

继续的特性

继承是在类之间建立的一种相交关系，使得新定义的派生类的实例，可以继承已有的基类的特征，并且可以添加新的功能。下面是继承的一些特征。

（1）派生类只能继承一个基类，所以C#并不支持多重继承，但一个基类可以有多个直接派生类。

编写程序，通过继承 的方式，打印出一个公司里三位员工的自我介绍。

using System;
namespace Project2
{
    class Clerk     //创建一个职员的类
    {
        private string _name;   //定义职员姓名的字段
        public string Name     //定义职员姓名的属性
        {
            get
            { return _name; }
            set
            { _name = value; }
        }
        private string _department;  //定义职员部门的字段
        public string Department     //定义职员部门的属性
        {
            get
            { return _department; }
            set
            { _department = value; }
        }
        public void CSeyHello()
        {
            Console.WriteLine("大家好，我是{0}的{1}", Department, Name);
        }
    }
    class Sales : Clerk    //创建销售类Sales，继承于Clerk
    {
        private int _salesTarget;  //定义职员销售目标的字段
        public int SalesTarget     //定义职员销售目标的属性
        {
            get
            { return _salesTarget; }
            set
            { _salesTarget = value; }
        }
        public void SSayHello()
        {
            Console.WriteLine("大家好，我是{0}的{1}，我的销售目标是{2}元", Department, Name, SalesTarget);
        }
    }
    //创建技术支持类TechnicalSupport，继承于Clerk
    class TechnicalSupport : Clerk
    {
        private double _satisfactionRate;  //定义职员服务满意度的字段
        public double SatisfactionRate     //定义职员服务满意度的属性
        {
            get
            { return _satisfactionRate; }
            set
            { _satisfactionRate = value; }
        }
        public void TSSayHello()
        {
            Console.WriteLine("大家好，我是{0}的{1}，我的服务满意率为{2}分", Department, Name, SatisfactionRate);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Clerk zs = new Clerk();
            zs.Name = "张三";
            zs.Department = "人力部";
            zs.CSeyHello();
            Sales ls = new Sales();
            ls.Name = "李四";
            ls.Department = "销售部";
            ls.SalesTarget = 5000;
            ls.SSayHello();
            TechnicalSupport zh = new TechnicalSupport();
            zh.Name = "周红";
            zh.Department = "技术支持部";
            zh.SatisfactionRate = 9.8;
            zh.TSSayHello();
        }
    }
}

（2）继承是可以传递的。

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

编写程序，在派生类中隐藏和基类同名的方法。

using System;
namespace Project3
{
    class myClass1
    {
        public void Write()
        {
            Console.WriteLine("这里是基类");
        }
    }
    class myClass2 : myClass1
    {
        public new void Write()   //隐藏方法
        {
            Console.WriteLine("这里是派生类");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            myClass2 b = new myClass2();
            myClass1 a = b;
            a.Write();
            b.Write();
        }
    }
}

调用基类的构造函数

从所周知，基类的初始化工作由基类的构造函数完成，派生类的初始化工作则由派生类的构造函数完成，但是这样就产生了派生类构造函数的执行顺序问题。

1、当基类中没有定义构造函数时，派生类会默认地调用基类的默认构造函数。

2、当基类中编写一个有参构造函数后，再实例化派生类的对象，程序就会调用基类中无参的构造函数，如果该函数存在就调用它，否则编译器就会发出错误警告。因此，不论程序调用派生类中的哪个构造函数，都是在寻找基类中无参的构造函数，如果没有则报错，而非参数匹配。

3、基类中编写了构造函数，可以通过base关键字，指定创建派生类实例时应调用的基类构造函数。

编写程序，在派生类中可以指定调用基类的某个构造函数。

using System;
namespace Project4
{
    public class myClass1        //基类
    {
        int Number;
        public myClass1()        //构造函数
        {
            Console.WriteLine("派生类调用基类的第一个构造函数");
        }
        public myClass1(int a)
        {
            Number = a;
            Console.WriteLine("派生类调用基类的第二个构造函数");
        }
        public int GetNumber()
        {
            return Number;
        }
    }
    public class myClass2 : myClass1            //派生类
    {
        //这个构造函数调用第一个基类的构造函数
        public myClass2() : base()            //派生类的构造函数
        {
        }
        //这个构造函数调用第二个基类的构造函数
        public myClass2(int a) : base(a)           //派生类的第二个构造函数
        {
        }
        static void Main()
        {
            myClass2 bs1 = new myClass2();
            myClass2 bs2 = new myClass2(1);
        }
    }
}

运行结果：

base关键字还可以用于从派生类中访问基类的成员。

using System;
namespace Project5
{
    public class Person
    {
        protected string tel = "444-55-6666";
        protected string name = "张三";
        public virtual void GetInfo()
        {
            Console.WriteLine("姓名: {0}", name);
            Console.WriteLine("电话号码: {0}", tel);
        }
    }
    class Employee : Person
    {
        public string id = "ABC567EFG";
        public override void GetInfo()
        {
            base.GetInfo();          // 调用基类Getinfo方法
            Console.WriteLine("学号: {0}", id);
        }
    }
    class Program
    {
        static void Main()
        {
            Employee E = new Employee();
            E.GetInfo();
        }
    }
}
<