面向对象程序设计中，要实现复杂的模块化系统，需要将系统划分为多个对象并组织它们之间的关系，这就涉及到常说的面向对象五大依赖关系。这五种依赖关系分别是：继承、聚合、组合、关联和依赖。本文将逐一介绍这五种依赖关系。

继承是一种基于类的依赖关系，允许一个类从一个或多个基类继承属性和方法。继承关系建立在共性和特性之间，通常使用 is-a 关系来描述，即子类 is a 父类的一种特殊形式。

通过继承，一个子类可以拥有父类的所有属性和方法，并能够扩展和修改这些属性和方法。通过继承，我们可以避免代码冗余，减少代码复制和粘贴，并提高代码重用性。

在继承关系中，应该遵循以下原则：

子类扩展或重写基类的属性和方法；
子类不能直接修改基类的实现方式；
子类应该尽量简化和区分基类的属性和方法。

    internal abstract class Animal
    {
        public Animal()
        {
            
        }
        protected string Name { get; set; }

        public abstract void Call();
    }
    /// <summary>
    /// 继承Animal
    /// </summary>
    internal class Cat : Animal
    {
        public Cat()
        {
            //使用继承Animal的Name属性
            Name = "金毛";
        }
        //重写Animal的Call方法
        public override void Call()
        {
            Console.WriteLine($"{Name}在喵喵叫");
        }
    }
    /// <summary>
    /// 继承Animal
    /// </summary>
    internal class Dog : Animal
    {
        public Dog()
        {
            //使用继承Animal的Name属性
            Name = "金毛";
        }
        //重写Animal的Call方法
        public override void Call()
        {
            Console.WriteLine($"{Name}在汪汪叫");
        }
    }

聚合关系是一种整体与部分的关系，即整体可以由部分构成，部分可以独立存在，且整体与部分是 “has-a” 关系。主要体现的是生命周期的不同，部分的生命周期可以与整体不同,整体对于部分有着控制和管理。

下面的例子体现聚合关系，教师拥有多个学生，控制并管理多个学生，而学生可以独立存在，生命周期教师与学生可以不同。

    // 教师类
    public class Teacher
    {
        public string Name { get; set; }

        public Teacher(string name)
        {
            Name = name;
        }

        public void Teach(List<Student> students)
        {
            Console.WriteLine($"{Name}老师在教{students.Count}个学生");

            foreach (var student in students)
            {
                student.Learn();
            }
        }
    }
    //学生类
    public class Student
    {
        public string Name { get; set; }

        public Student(string name)
        {
            Name = name;
        }

        public void Learn()
        {
            Console.WriteLine($"{Name}在学习");
        }
    }

组合关系也是一种整体与部分的关系，与聚合关系不同的是，部分不能独立存在，只能作为整体的一部分存在。例如，一本书由封面、目录、正文和封底等部分构成，如果没有这些部分之一，就不能称之为完整的书。

组合关系强调整体与部分的生命周期统一，整体包含部分，同时部分只能属于一个整体。组合关系是一种强依赖关系，整体控制和管理了部分，整体的生命周期结束时，部分也随之销毁。

下面的例子，书包含封面、目录、正文和封底，书与封面、目录、正文和封底的生命周期一同结束。封面、目录、正文和封底不能独立存在。

    // 书类
    public class Book
    {
        public string Title { get; set; }
        public Cover BookCover { get; set; }
        public TableOfContents Contents { get; set; }
        public Text Body { get; set; }
        public BackCover BookBackCover { get; set; }

        public Book(string title, string coverImage, string[] chapters, string[] pages, string backCoverImage)
        {
            Title = title;
            BookCover = new Cover(coverImage);
            Contents = new TableOfContents(chapters);
            Body = new Text(pages);
            BookBackCover = new BackCover(backCoverImage);
        }

        public void Read()
        {
            Console.WriteLine($"这本书叫{Title}");
            BookCover.Display();
            Contents.Display();
            Body.Display();
            BookBackCover.Display();
        }
    }

    // 封面类
    public class Cover
    {
        private string _coverImage;

        public Cover(string image)
        {
            _coverImage = image;
        }

        public void Display()
        {
            Console.WriteLine($"这本书的封面是:{_coverImage}");
        }
    }

    // 目录类
    public class TableOfContents
    {
        private IList<string> _tableOfContentsList;

        public TableOfContents(string[] chapters)
        {
            _tableOfContentsList = chapters;
        }

        public void Display()
        {
            Console.WriteLine($"这本书目录:");
            for (int i = 0; i < _tableOfContentsList.Count; i++)
            {
                Console.WriteLine($"{i} 1 .{_tableOfContentsList[i]}");
            }
        }
    }

    // 正文类
    public class Text
    {
        private IList<string> _pageList;

        public Text(string[] pages)
        {
            _pageList = pages;
        }

        public void Display()
        {
            Console.WriteLine($"这本书的正文:");
            for (int i = 0; i < _pageList.Count; i++)
            {
                Console.WriteLine($"Page {(i + 1)} :  {_pageList[i]}");
            }
        }
    }

    // 封底类
    public class BackCover
    {
        private string _backCoverImage;

        public BackCover(string backImage)
        {
            _backCoverImage = backImage;
        }

        public void Display()
        {
            Console.WriteLine($"这本书的封底是:{_backCoverImage}");
        }
    }

关联关系是一种对象之间的联接关系，用于描述两个对象之间有交互关系。关联关系可以是单向的或双向的，可以是强关联、中等关联或弱关联。

强关联表示两个对象之间的依赖关系比较紧密，通常使用对象成员变量来实现，如一个人与其身份证号之间就是强关联。中等关联表示两个对象之间能互相访问，但是依赖程度不是很紧密。弱关联表示两个对象之间关联程度较小。

下面例子中，教师类需要有学生才能教学，学生类需要有教师才能学习。于是二者之间有了关联，互相之间需要对方来完成信息的交互。

    // 学生类
    public class Student
    {
        public string Name { get; set; }
        public int Age { get; set; }

        public Student(string name, int age)
        {
            Name = name;
            Age = age;
        }

        public void Learn(Teacher teacher)
        {
            Console.WriteLine($"{Name}学生在学{teacher.Name}老师的课程");
        }
    }

    // 教师类
    public class Teacher
    {
        public string Name { get; set; }
        public string Subject { get; set; }

        public Teacher(string name, string subject)
        {
            Name = name;
            Subject = subject;
        }

        public void Teach(Student student)
        {
            Console.WriteLine($"{Name}老师在教{student.Name}学生{Subject}");
        }
    }

依赖关系是一种类之间的关系，表示一个类依赖于另一个类。依赖关系通常体现为一个类在方法内使用了另一个类的对象作为参数或局部变量。如果一个类的代码依赖于另一个类，就意味着当另一个类发生改变时，这个类也可能受到影响。

依赖关系可以帮助我们提高代码复用性，通过在一个类中使用另一个类，可以有效地实现代码的模块化和重用。

下面例子中，司机类有一个开车的行为，而司机开车需要依赖于车才能完成自身的行为。所以司机依赖于车。

    // 车类
    public class Car
    {
        public void Drive()
        {
            Console.WriteLine($"车正在行驶");
        }
    }

    // 司机类
    public class Driver
    {
        public void DriveCar(Car car)
        {
            car.Drive();
        }
    }

总的来说，面向对象程序设计中的五大依赖关系是程序员必须理解和掌握的一些基本概念。当我们设计、实现和维护面向对象系统时，需要合理使用这些依赖关系，以便让我们的程序结构更为清晰、易懂、易扩展和易维护。

【面向对象依赖关系概念总结】面向对象程序设计的五种依赖关系 - 欲东

【面向对象依赖关系概念总结】面向对象程序设计的五种依赖关系

Recommend

面向对象程序设计_第二阶段总结

游戏开发与程序设计知识总结06——常见软件架构模式

游戏开发与程序设计知识总结05——游戏前端开发

游戏开发与程序设计知识总结04——操作系统

浙江省第十三届程序设计竞赛总结

浙江省第十四届程序设计竞赛总结

10 道面向对象面试题总结（含答案解析和思维导图）

从前端到全栈 -- 最全面向对象总结

为使用不同类型的值而设计的 trait 对象 - Rust 程序设计语言简体中文版

C# 实例解释面向对象编程中的依赖反转原则 - 技术译民

About Joyk