zoukankan      html  css  js  c++  java
  • 类与类之间关系,用C#和JavaScript体现


    前言

    在面向对象中,类之间的关系有六种,分别是:

    1. 关联关系(Association)
    2. 泛化关系(Generalization)
    3. 依赖(Dependency)
    4. 聚合(Aggregation)
    5. 组合(Composite)

    类与类之间关系

    关联(Association)

    两个相对独立的对象,当一个对象的实例与另一个对象的实例存在固定关系时,这两个对象之间就存在关联关系,关联体现的是一种强关联关系,关联关系形式有四种:单向关联、双向关联、自身关联和多维关联。

    单向关联
    场景:订单和商品,订单中包含商品,但是商品并不知道订单的存在。
    UML类图:

    image

    代码体现:

    C#

     public class Order
        {
            public List<Product> products;
    
            public Order()
            {
                products = new List<Product>();
            }
    
            public void AddProduct(Product product)
            {
                products.Add(product);
            }
    
            public void Print()
            {
                foreach (var product in products)
                {
                    Console.WriteLine(product.Name);
                }
            }
        }
    
        public class Product
        {
            public string Name { get; set; }
        }

    JavaScript

       var Order = function () {
                var products = [];
                this.addProduct = function (product) {
                    products.push(product);
                };
    
                this.Print = function () {
                    for (var i = 0; i < products.length; i++) {
                        console.log(products[i].Name);
                    }
                }
            };
    
            var Product = function (name) {
                this.Name = name;
            }

    双向关联
    场景:订单和客户,订单属于客户,客户拥有一些订单
    UML类图:
    image

    代码体现:

    C#

    public class Order
        {
            public User GetUserByOrderId(string orderId)
            {
                return new User();
            }
        }
     public class User
        {
            public List<Order> GetOrders()
            {
                return new List<Order>();
            }
        }

    JavaScript

            var User = function (name) {
                this.Name = name;
    
                this.getOrder = function () {
                    console.log("getOrder");
                };
            };
            var Order = function () {
    
                this.getUserByOrderId = function (id) {
                    console.log("getUserByOrderId:" + id);
                };
            }

    自身关联
    同一个对象之间的关联
    UML类图:
    image

    多维关联
    多个对象之间存在联系
    场景:公司雇佣员工,同时公司需要字符工资给员工

    依赖(Dependency)
    类A要完成某个功能必须引用类B,则A和B存在依赖关系,依赖关系是弱关联关系。
    场景:司机和汽车
    UML类图:
    image

    代码体现:

      public class Driver
        {
            public void Drive(Car car)
            {
                car.Run();
            }
        }
    
        public class Car
        {
            public void Run()
            {
                Console.WriteLine("跑起来了");
            }
        }

    JavaScript

            var Driver = function () {
                this.dirve = function (car) {
                    if (car instanceof Car) {
                        car.run();
                    } else {
                        throw new Error("参数异常,必须是Car类型");
                    }
                }
            };
    
    
            var Car = function () {
                this.run = function () {
                    console.log("跑起来了");
                }
            }

    泛化(Generalization)
    泛化就是类与类的的继承关系,类与接口的实现关系。
    场景:狗是一个动物;鸟会飞
    UML类图:
    image

    代码体现:

    C#

       public abstract class Animal
        {
    
        }
    
        public class Dog
        {
        }

    JavaScript

            function Animal() { }
    
            function Dog() { }
    
            Dog.prototype = new Animal();
            Dog.prototype.constructor = Dog;
    
            var dog = new Dog();
            console.log(dog.constructor);
            console.log(dog instanceof Dog);

    聚合(Aggregation)
    当对象A被加入到对象B中,称为对象B的一部分时,对象A和B就存在聚合关系。聚合关系是关联关系的一种,是较强的关联关系,强调的是整体与部分之间的关系。
    场景:大雁与雁群
    UML类图:
    image

    代码体现

    C#

    public class GooseGroup
        {
            public Goose goose;
    
            public GooseGroup(Goose g)
            {
                goose = g;
            }
    
        }
    
        public class Goose
        {
        }

    JavaScript

     var Goose = function() {
    
            };
    
            var GooseGroup = function(goose) {
                var _goose = goose;
                console.log(_goose);
            };

    组合(Composition)
    对象A包含对象B,对象B离开对象A就没有存在的意义,是一种更强的关联关系。
    场景:大雁和翅膀
    UML类图:
    image

    代码体现

    C#

      public class Goose
        {
            public Wing wing;
    
            public Goose()
            {
                wing = new Wing();
            }
    
        }
    
        public class Wing
        {
        }

    JavaScript

        var Goose = function() {
    
                var wing = new Wing();
            };
    
            var Wing = function() {};

    区别

    关联和依赖区别:

    • 从代码的角度看,依赖关系中依赖是作为方法的参数或返回值,或者方法的变量形式体现的;关联关系则是作为一个类的属性体现的,相比依赖,关联是更加固定,更为持久的持有的关系。
    • 从生命周期来看,依赖关系则是随着类的方法被调用时而产生,伴随着方法的结束而结束;关联关系则是当类实例化的时候即产生,当类的销毁时而结束,相比依赖,关联的生命周期更长。

    聚合和组合区别:

    • 构造函数不同,聚合类的构造函数参数是另一个类的实例;组合类的构造函数包含另一个类的实例化。
    • 信息的封装性不同,聚合关系中,GooseGroup类和Goose类是独立的,客户端都可以访问到;组合关系中,客户端只能访问到Goose类,Wing类则访问不到,因为它被封装在Goose类中。
  • 相关阅读:
    常用模块汇总
    day 16 常用模块 time 和 datetime(1)
    二分法 函数式 模块
    day 15 模块 (3)
    vue require.context 检索文件夹内文件路径
    Node.js搭建本地服务,读取css/js/img/html等各种格式文件
    Nodejs搭建web服务器
    el-table横向滚动条固定在屏幕最下方显示
    IE浏览器 backspace键使浏览器回退
    vue ElementUI el-input 键盘enter事件 导致刷新表单问题
  • 原文地址:https://www.cnblogs.com/Khadron/p/OOP_Class_Relationship.html
Copyright © 2011-2022 走看看