精华内容
下载资源
问答
  • 有这么一个问题就是,给定了很多列表,但是... 我们认为这是存在隐含关联的一种体现,现在需要用程序来计算出来这种关系,我自己思路比较简单,可能会存在很多问题,现在也没有太多想法,只是简单实现了一下,如

        有这么一个问题就是,给定了很多列表,但是列表之间可能是存在某种关联的,比如下面的:

        num_list1=[1,1,1,1,1,1,2,2,2,2]

        num_list2=[1,2,3,4,5,6,1,2,3,4]

        我们认为这是存在隐含关联的一种体现,现在需要用程序来计算出来这种关系,我自己的思路比较简单,可能会存在很多问题,现在也没有太多的想法,只是简单的实现了一下,如果之后有更好的方法或者大家谁有更好的方法可以来补充,下面是具体实现:


    #!usr/bin/env python
    #encoding:utf-8
    
    '''
    __Author__:沂水寒城
    功能:找出列表间隐含的关联关系以及重复模式
    '''
    
    import numpy as np 
    from collections import Counter
    
    def find_list_cycle_pattern(num_list1, num_list2):
        '''
        给定两个列表,找出列表间隐含的关联关系以及重复模式
        一般的w_shingle是定长的窗口来切片这里是变长的
        '''
        w_list=[]
        sub_list=[]
        set_num_list1=list(set(num_list1))
        set_num_list1.sort()
        set_num_list2=list(set(num_list2))
        set_num_list2.sort()
        for one in set_num_list1:
            w_list.append(num_list1.count(one))
        i=0
        for one_w in w_list:
            sub_list.append(num_list2[i:i+one_w])
            i+=one_w
        mean_list=[]
        for one_list in sub_list:
            fre_list=count_ele(one_list)
            mean_list.append(np.array(fre_list).var())
        #找出mean_list中出现频数最多的元素
        threshold=Counter(mean_list).most_common(1)[0][0]
        if threshold:
            print 'Find pattern, but not stable'
        else:
            print 'Find pattern, and stable'
    
    
    def count_ele(one_list):
        '''
        计算一个列表中的每个元素的频数
        '''
        fre_list=[]
        for one in one_list:
            fre_list.append(one_list.count(one))
        return fre_list
    
    
    if __name__ == '__main__':
        num_list1=[1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6]
        num_list2=[1,2,2,2,1,2,2,2,1,2,2,2,1,2,2,2,1,2,2,2,1,2,2,2]
        num_list3=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,3]
        num_list4=[1,1,2,2,3,3,4,4,5,5,6,6,7,7,1,1,2,2,3,3,4,4,1,1,2,2,3,3]
        find_list_cycle_pattern(num_list1, num_list2)
        find_list_cycle_pattern(num_list3, num_list4)


    结果如下:


    Find pattern, but not stable
    Find pattern, and stable
    [Finished in 0.4s]


    展开全文
  • 类与类的几种关联模式的讲解

    万次阅读 2019-02-19 23:17:03
    一般来说类与类有六种关联方式:单向关联,双向关联,自关联,多重性关联,聚合关系,组合关系。 1.单向关联一般是把B类作为A类一个属性来实用,例如Company是一个类,Employee是一个类。然而Company类将Employee...

    一般来说类与类有六种关联方式:单向关联,双向关联,自关联,多重性关联,聚合关系,组合关系。

    1.单向关联一般是把B类作为A类的一个属性来实用,例如Company是一个类,Employee是一个类。然而Company类将Employee作为其的一个属性。

    2.双向关联,就是说将对方(类)当做自己的一个属性。例如顾客与商品的关系,顾客购买商品,卖出的商品与某个顾客关联。

    3.自关联的比如链表中的节点,可以指向自己,把自己当做自己类的一个属性。

    4.多重性关联,即A类把多个B类当做属性。

    5.聚合关系,这是表示整体与部分之间的关系,成员对象是整体对象的一部分,但成员对象时可以脱离整体对象存在的

    一个不恰当的例子是,一个三口家庭是由父亲,母亲,儿子存在组成整体部分的,但是父亲是可以可以脱离整体部分存在的。(不是很恰当的举例),两者关系较弱,通过对象注入实现。

     

    6.组合关系,也是表示整体与部分之间的关系,但是部分不能脱离整体存在,整体没了它就没了。例如腾讯与QQ的关系,没了腾讯这家公司,QQ软件也没了。两者关系较强,通过构造函数实例化来实现。

     

    展开全文
  • 在java以及其他面向对象设计模式中,类与类之间主要有6种关系,他们分别是:依赖、关联、聚合、组合、继承、实现。他们耦合度依次增强。 1. 依赖(Dependence)  依赖关系的定义为:对于两个相对独立...

    原文转载地址

    在java以及其他的面向对象设计模式中,类与类之间主要有6种关系,他们分别是:依赖、关联、聚合、组合、继承、实现。他们的耦合度依次增强。

    1. 依赖(Dependence)

            依赖关系的定义为:对于两个相对独立的对象,当一个对象负责构造另一个对象的实例,或者依赖另一个对象的服务时,这两个对象之间主要体现为依赖关系。定义比较晦涩难懂,但在java中的表现还是比较直观的:类A当中使用了类B,其中类B是作为类A的方法参数、方法中的局部变量、或者静态方法调用。类上面的图例中:People类依赖于Book类和Food类,Book类和Food类是作为类中方法的参数形式出现在People类中的。

    代码样例:

    1. public class People{  
    2.     //Book作为read方法的形参  
    3.      public void read(Book book){  
    4.         System.out.println(“读的书是”+book.getName());  
    5.     }  
    6. }  

    2.关联(Association)

    单向关联:

     

    双向关联:

            对于两个相对独立的对象,当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时,这两个对象之间为关联关系。关联关系分为单向关联和双向关联。在java中,单向关联表现为:类A当中使用了类B,其中类B是作为类A的成员变量。双向关联表现为:类A当中使用了类B作为成员变量;同时类B中也使用了类A作为成员变量。

    代码样例:

    1. public class Son{  
    2.    //关联关系中作为成员变量的类一般会在类中赋值  
    3.     Father father = new Father();  
    4.     public void getGift(){  
    5.         System.out.println(“从”+father.getName()+”获得礼物”);  
    6.     }  
    7. }  
    8.   
    9. public class Father{  
    10.     Son son = new Son();  
    11.     public void giveGift(){  
    12.         System.out.println(“送给”+son.getName()+“礼物”);  
    13.     }  
    14. }  

    3.聚合(Aggregation)

            聚合关系是关联关系的一种,耦合度强于关联,他们的代码表现是相同的,仅仅是在语义上有所区别:关联关系的对象间是相互独立的,而聚合关系的对象之间存在着包容关系,他们之间是“整体-个体”的相互关系。

    代码样例:

    1. public class People{  
    2.     Car car;  
    3.     House house;   
    4.     //聚合关系中作为成员变量的类一般使用set方法赋值  
    5.      public void setCar(Car car){  
    6.         This.car = car;  
    7.     }  
    8.     public void setHouse(House house){  
    9.         This.house = house;  
    10.     }  
    11.   
    12.     public void driver(){  
    13.         System.out.println(“车的型号:”+car.getType());  
    14.     }  
    15.     public void sleep(){  
    16.         System.out.println(“我在房子里睡觉:”+house.getAddress());  
    17.     }  
    18. }  

    4.组合(Composition)

            相比于聚合,组合是一种耦合度更强的关联关系。存在组合关系的类表示“整体-部分”的关联关系,“整体”负责“部分”的生命周期,他们之间是共生共死的;并且“部分”单独存在时没有任何意义。在下图的例子中,People与Soul、Body之间是组合关系,当人的生命周期开始时,必须同时有灵魂和肉体;当人的生命周期结束时,灵魂肉体随之消亡;无论是灵魂还是肉体,都不能单独存在,他们必须作为人的组成部分存在。

    1. Public class People{  
    2.     Soul soul;  
    3.     Body body;   
    4.     //组合关系中的成员变量一般会在构造方法中赋值  
    5.      Public People(Soul soul, Body body){   
    6.         This.soul = soul;  
    7.         This.body = body;  
    8.     }  
    9.   
    10.     Public void study(){  
    11.         System.out.println(“学习要用灵魂”+soul.getName());  
    12.     }  
    13.     Public void eat(){  
    14.         System.out.println(“吃饭用身体:”+body.getName());  
    15.     }  
    16. }  

    5.继承(Generalization)

            继承表示类与类(或者接口与接口)之间的父子关系。在java中,用关键字extends表示继承关系。UML图例中,继承关系用实线+空心箭头表示,箭头指向父类。

    6.实现(Implementation)

             表示一个类实现一个或多个接口的方法。接口定义好操作的集合,由实现类去完成接口的具体操作。在java中使用implements表示。UML图例中,实现关系用虚线+空心箭头表示,箭头指向接口。

            在java中继承使用extends关键字,实现使用implements关键字,很直观。就不代码演示了。

    展开全文
  • 关于设计模式的总结没有落实到代码上,而且设计模式自己确实动手实现的非常少。所以在这一周里,除了看网站开发的视频,着手开始对设计模式进行实现以下。设计模式非常经典,每次看都有不同的收获,写一下自己的收获...

    关于设计模式的总结没有落实到代码上,而且设计模式自己确实动手实现的非常少。所以在这一周里,除了看网站开发的视频,着手开始对设计模式进行实现以下。设计模式非常经典,每次看都有不同的收获,写一下自己的收获吧,请大家指正。

     在实现设计模式之前,首先来复习以下UML中的五种关系图

    <1>依赖

    依赖关系用虚线加箭头表示,如图所示:

    上图表示:Animal类依赖于Water类(动物依赖于水)。

     依赖是类的五种关系中耦合最小的一种关系。因为依赖关系在生成代码的时候,这两个关系类都不会增加属性。这种微弱的关系可以用类之间的相互了解的程度来说明。(下图为代码生成图)

      

    由上图可见生成的代码中Animal类的属性中没有增加Water类。那么Animal类如何使用Water类呢,有三种方式:

    依赖关系的三种表现形式:

    ①     Water类是全局的,则Animal类可以调用它
     

    ②     Water类是Animal类的某个方法中的变量,则Animal类可以调用它。代码演示如下:

      PS:Animal有一个长大(GrownUp)方法,Water类作为该方法的变量来使用。
              请注意Water类的生命期,它是当Animal类的GrounUp方法被调用的时候,才被实例化。
             持有Water类的是Animal的一个方法而不是Animal类,这点是最重要的。

    ③     Water类是作为Animal类中某个方法的参数或者返回值时。代码演示如下

    无用多说,Water类被Animal类的一个方法持有。生命期随着方法的执行结束而结束。

     

    在依赖关系中,必须采用这三种方法之一。

    <2>关联

    关联是实线加箭头表示。表示类之间的耦合度比依赖要强。has a

    例:水与气候是关联的,表示图如下

     

    生成代码如下:


     

    可见生成的代码中,Water类的属性中增加了Climate类。

     

    关联既有单向关联又有双向关联。

    单向关联:Water类和Climate类单向关联(如下图),则Water类称为源类,Climate类称为目标类。源类了解目标类的所有的属性和方法,但目标类并不了解源类的信息。

    双向关联:源类和目标类相互了解彼此的信息。如将Water类和Climate类之间改为双向关联,如下图

    依赖和关联的区别:

    ①     从类的属性是否增加的角度看:

    发生依赖关系的两个类都不会增加属性。其中的一个类作为另一个类的方法的参数或者返回值,或者是某个方法的变量而已。

    发生关联关系的两个类,其中的一个类成为另一个类的属性,而属性是一种更为紧密的耦合,更为长久的持有关系。

    ②     从关系的生命期角度看:

    依赖关系是仅当类的方法被调用时而产生,伴随着方法的结束而结束了。

    关联关系是当类实例化的时候即产生,当类销毁的时候,关系结束。相比依赖讲,关联关系的生存期更长。

     

    关联关系的细化

    关联关系又可以细化为聚合关系和组合关系

    聚合关系图:


     

    组合关系图:

     


     

    l       聚合和组合的区别:

    由于聚合和组合都是特殊的关联关系,在生成的代码上看不出区别,都是关联的形式。那到底这两种关系如何来区分呢。

     

    区分的关键有两点:

    ①     构造函数不同

    聚合关系下:雁群类(GooseGroup)和大雁类(Goose)代码如下:

     


     

    组合关系下:大雁类(Goose)和翅膀类(Wings)代码如下:

     


     

    这两种关系的区别在于:

    ①构造函数不同

         聚合类的构造函数中包含了另一个类作为参数。

    雁群类(GooseGroup)的构造函数中要用到大雁(Goose)作为参数传递进来。大雁类(Goose)可以脱离雁群类而独立存在。

         组合类的构造函数中包含了另一个类的实例化。

    表明大雁类在实例化之前,一定要先实例化翅膀类(Wings),这两个类紧密的耦合在一起,同生共灭。翅膀类(Wings)是不可以脱离大雁类(Goose)而独立存在

    ②     信息的封装性不同

    在聚合关系中,客户端可以同时了解雁群类和大雁类,因为他们都是独立的

    而在组合关系中,客户端只认识大雁类,根本就不知道翅膀类的存在,因为翅膀类被严密的封装在大雁类中。

     

    <3>泛化

    泛化就是一个类继承另一个类所有的描述,并且可以根据需要对父类进行拓展,是面向对象的重要特征之一。

    泛化使用一根实线加箭头,泛化关系图 is a

     


     

    泛化的用处:①实现了代码的复用

                            ②实现了多态

               

    <4>实现

     主要针对接口和抽象类而言,实现接口和抽象类的类必须要实现他们的方法。

    实现关系表示为:虚线加箭头,关系图如下:

     

    接口只包含方法、委托或事件的签名。方法的实现是在实现接口的类中完成的。

    关于泛化关系和实现关系比较简单,这里就不一一展开了。了解清楚了这几种关系以及他们的代码特点,才能更好的学习设计模式!

    展开全文
  • 对于很多刚刚接触UML的童鞋,可能会对类之间的关联与依赖关系不太理解,今天小菜就浅薄的讲一下。 这块的确是有点乱,不过小菜突然找到了一个比较好的切入点,拿出来分享一下。 接触过设计模式的读者,会经...
  • 设计模式的关系

    2017-02-16 15:28:00
    设计模式中,主要有以下一些关系: 实现,通常是继承基类; uml中是使用 空心虚线箭头。 泛化,是一种实现,在代码中表现为继承非基类。uml 中使用 空心实线箭头。...关联关系,是人为赋予的关系。u...
  • 设计模式总结(一) 类之间的关系:关联关系(1.双向关联2.单向关联3.自关联4.多重性关联5.聚合关系6.组合关系);依赖关系;泛化关系;接口与实现关系
  • 自关联4.多重性关联5.聚合关系6.组合关系二、依赖关系三、泛化关系四、实现关系(Realization) 设计模式的关系总结 在软件系统中,类并不是独立存在,类与类之间存在各种关系,对于不同类型的关系,UML提供了不同...
  • 关于设计模式的总结没有落实到代码上,而且设计模式自己确实动手实现的非常少。所以在这一周里,除了看网站开发的视频,着手开始对设计模式进行实现以下。设计模式非常经典,每次看都有不同的收获,写一下自己的收获...
  • 一.依赖关系 在代码中一般是:某个类方法通过局部变量,方法参数,静态方法调用来访问另外一个类中的的一些...当然可以是双向的关联关系,也可以是单向的关联关系。 单向关联关系:用一个带箭头实线表示...
  • Spring自动装配:无须在Spring配置文件中描述javabean之间依赖关系,IOC容器会自动建立JavaBean之间的关联关系。 ①. 根据属性名称自动装配autowire=”byName” ②. 根据数据类型自动装配autowire=”byType” ③...
  • 原标题:Java技术总结:Spring框架中自动装配模式的区别spring的自动装配功能的定义:无须在Spring配置文件中描述javaBean之间的依赖关系(如配置、)。IOC容器会自动建立javabean之间的关联关系。简而言之,一个类...
  • 设计模式的关系总结在软件系统中,类并不是独立存在,类与类之间存在各种关系,对于不同类型的关系,UML提供了不同表示方式。现在来总结梳理下:一、关联关系类与类之间最常用一种关系,是一种结构化的关系,...
  • 设计模式中类的关系

    2014-03-19 09:50:00
    在面向对象设计模式中,类与类之间主要有6种关系,他们分别是:依赖、关联、聚合、组合、继承、实现。他们耦合度依次增强。 1.依赖(Dependence) 依赖关系的定义为:对于两个相对独立对象,当一个对象负责...
  • 关于设计模式的总结没有落实到代码上,而且设计模式自己确实动手实现的非常少。所以在这一周里,除了看网站开发的视频,着手开始对设计模式进行实现以下。设计模式非常经典,每次看都有不同的收获,写一下自己的收获...
  • 他们在编程语言中体现却是基本相同,但是基本相同并不等于完全相同,这一点在我前一篇博文《设计模式中类的关系》中已经有所提及,下面就来详细论述一下在java中如何准确体现依赖、关联、聚合和组合。...
  • 他们在编程语言中体现却是基本相同,但是基本相同并不等于完全相同,这一点在我前一篇博文《设计模式中类的关系》中已经有所提及,下面就来详细论述一下在java中如何准确体现依赖、关联、聚合和组合。...
  • 在学习面向对象设计对象关系时,依赖、关联、聚合和组合这四种关系之间区别比较容易...他们在编程语言中体现却是基本相同,但是基本相同并不等于完全相同,这一点在我前一篇博文《设计模式中类的关系》中已经...
  • 在设计模式中类与类之间的关系主要有6种:依赖、关联、聚合、组合、继承、实现,它们之间耦合度依次增加。一、继承关系 继承是一种“is-a”关系。继承指是一个类(称为子类、子接口)继承另外一个类(称为...
  • spring自动装配功能定义:无须...IOC容器会自动建立javabean之间的关联关系。 简而言之,一个类就是一个Bean,Spring框架是一个Bean容器,替我们管理这些Bean。类似于舞台剧,需要很多角色,Spring就是来组织各...
  • 设计模式中类的关系这篇文章转快课网 http://www.cricode.com/1405.html 在Java及其他面向对象设计模式中,类与类之间的关系主要有6中关系: - 依赖(Dependence) - 关联(Association) - 聚合...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 705
精华内容 282
关键字:

关系模式的自关联