国内更全面
解决程序疑难杂症

UML类图在代码中的实现

    《大话》中的23种设计模式的代码都是根据UML类图在C#中实现的,可见类图对于面向对象编程的重要性。在UML类图的四种关系这一篇文章详细地介绍过类图之间的关系,关联(聚合、组合),依赖、继承和实现。这篇文章就类图的四种关系在C#的具体实现做一个介绍。

      关联

      关联是一种“拥有”关系,指一个类需要“知道”另一类的属性或方法。在代码中的表现为在类A的定义中使用类B作为成员变量。如企鹅类和气候类,企鹅根据气候的变化才确定是否需要迁徙。结构图如下:
       
     实现代码:
    class Climate                              //气候类
    {
        public  string climate;              
        public string Climate
        {
            get { return climate; }
            set { climate = value; }
        }
     
     }
    class Penguin
    {
        Climate climate;                  //Penguin类中引用Climate
        public Penguin(Climate climate)
        {
            this.climate = climate;
        }

        public void  migrate()
        {
            Console.WriteLine("由于"+climate.climate+"企鹅迁徙");
        }
        
    }

      聚合

      聚合属于关联中“弱”的拥有关系,体现的是A可以包含B,但B不是A的一部分,两者的生命周期不同。如企鹅和企鹅群,企鹅组成了企鹅群,企鹅离开企鹅群可以单独存在。其结构图如下:

     
      实现代码
    class Penguins
    {
        private Penguin penguin;                 //声明一个Penguin 对象
        public Penguins(Penguin penguin)         //通过构造方法,传入具体的对象penguin
        {
            this.penguin = penguin;
        }
    }
    class Penguin
    {
    }

     组合

       组合属于关联中“强”的拥有关系,体现的是A包含B,B是A的一部分,两者有相同的生命周期。如企鹅和眼睛、鼻子等。
    
   实现代码  
    class Penguin
    {
        private Eyes eyes;
        private Nose nose;
        public Penguin()
        {
            eyes = new Eyes();
	    
            nose = new Nose();
	    //在Penguin类中,初始化时,实例化眼睛Eyes和鼻子Nose
        }
        
    }
    class Eyes{...}
    class Nose{...}
      聚合和组合的区别在于整体与部分的生命周期不同,这在代码中也有所体现。在上述例子中,聚合关系中企鹅群类中引用企鹅类作为参数,并没有实例化Penguin,这就是说当Penguins类撤销时,penguin类存在并可能作为参数引用其他类当中。 组合关系中在Penguin类初始化的同时,创建Eyes和Nose对象,当Penguin类撤销时,Eyes和Nose类同时撤销,表现为三者的生命周期相同。

    依赖

      依赖关系体现的是一种“使用”关系,即一个类在代码要引用另一个类的属性或方法。如,企鹅类和氧气类,企鹅呼吸氧气,这一种依赖关系。其类图如下:
                                        
      从图中可以看出,在Penguin方法Breathe()中需要引用Oxygen对象。在代码中的具体实现:
      
    class Penguin         //企鹅类
    {
        
        public void Breath(Oxygen oxygen);  //氧气作为参数
    }
    class Oxygen         //氧气类
    {
    }

     泛化

       泛化也可称为继承,继承很好地体现了面向对象的特性。学习继承时,有三点是要注意的,1、子类拥有父类非private的属性和方法;2、子类具有自己的属性和方法。3、子类可以对其父类的方法进行重写。如:动物类作为父类,其子类是企鹅类,它们的结构图如下:
                                 
       实现代码
      
   class Animal                 //动物类作为父类
    {
        protected string name;
        public Animal(string name)//“名字”属性
        {
            this.name = name;
        }
        public void Breath()//定义父类的“呼吸”方法
        {

        }

    }
    class Penguin : Animal    //企鹅类作为子类,继承与动物类
    {
        public Penguin(string name) : base(name) { }//子类构造方法需要调用父类同样的参数类型的构造方法,base代表父类。
        public void Breath                          //子类继承父类的Breath方法
        {
        }
        public void Swim                           //子类的特有方法Swim
        {
        }
    }

       实现

       实现是指接口和实现类的关系,接口中定义了一系列的方法和属性,这些方法和属性在实现类中实现。比如,呼吸(动作)作为接口,企鹅去实现这个接口。其接口图为:
       
      实现代码:
      
    interface IBreath            //定义接口,关键字为interface
    {
         string Breath();       //接口中定义的方法
    }
    class Penguin : IBreath     //实现接口的语法
    {
        public void Breath()
        {
            Console.WriteLine ("企鹅呼吸");//实现接口定义的方法
        }
    }

        继承和实现两种关系,在一定程度上我认为可以等同的,代码中的实现时注意关键字的使用。

   总结

    UML类图对编程有着指导性作用,类图表达了软件编程过程时需要的类,类图的关系则表示的是各个类之间的参数传递和调用。
             

企业站定制,我们更专业!

联系我们