精华内容
下载资源
问答
  • hibernate 对象的种关系: one – to – one : 身份证人 one – to – many : 部门 员工 many-to-one : 员工部门 many-to-many : 学生老师 在实际开发中,如果出现了many-to-many关系,我们应该将其转换...
    hibernate 对象的三种关系:
    one – to – one : 身份证<--->人
    one – to – many : 部门 <---> 员工
    many-to-one :  员工<--->部门
    many-to-many : 学生<--->老师

    在实际开发中,如果出现了many-to-many关系,我们应该将其转换成两个one-to-many 或者 many-to-one,这个程序好控制,同时不会有冗余.

    单向多对一(Employee - Department)
    Employee映射文件
    <many-to-one name=”dept” column=”dept_id”/>
    class Department{
    private Integer id;
    private String name;
    }
    class Employee{
    private Integer id;
    private String name;
    private Department dept;
    }
    添加一个部门,并给部门加入二个人
    public static void add() {
        //把对象模型-》关系模型
        //当你获取一个session ,就会让hiberate去读取
        //hibernate.cfg.xml,这就会加载对象映射文件,从而完成创建
        Session session=null;
        Transaction ts=null;
        try {           
            session=HibernateUtil.getThreadLocalSession();
            ts=session.beginTransaction();           
            //添加一个记录
            Department d1=new Department();
            d1.setName("财务部");
            Employee e1=new Employee();
            e1.setName("张三");
            e1.setDepartment(d1);
            Employee e2=new Employee();
            e2.setName("邵阳");
            e2.setDepartment(d1);           
            session.save(d1);
            session.save(e1);
            session.save(e2);           
            ts.commit();
        } catch (Exception e) {
            e.printStackTrace();
            if(ts!=null){
                ts.rollback();
            }
            // TODO: handle exception
        }finally{
            if(session!=null&&session.isOpen()){
                session.close();
            }
        }
    }

    简述: 当我们查询一个对象的时候,在默认情况下,返回的只是该对象的普通属性,当用户去使用对象属性时,才会向数据库发出再一次的查询.这种现象我们称为 lazy现象 .
    解决方法可以这样:
    显示初始化 Hibernate.initized(代理对象)
    修改对象关系文件 lazy  改写 lazy=false
    通过过滤器(web项目) openSessionInView
     
    双向一对多(Department-Employee)
    Department映射文件添加
    <set name=”集合对象属性名”>
        <key column=”外键名”/>
        <one-to-many class=”集合放入的类名”/>
    </set>
    class Department{
    private Integer id;
    private String name;
    private Set<Employee> emps
    }

    一对一(Person - IdCard)
    1)基于主键的one-to-one(IdCard的映射文件)
    <id name=”id”>
        <generator class=”foreign”><param name=”property”>person</param></generator>
    <id>
    <one-to-one name=” person” constrained=”true”/>
    [没有constraned true将不会生成外键约束]
    Person映射文件: <one-to-one name=“idCard” />
    class Person{
    private Integer id;
    private String name;
    private IdCard idCard
    }
    class IdCard{
    private Integer id;
    private java.util.Date useful_life;
    private Person person
    }
    **添加案例***
    session =HibernateUtil.getThreadLocalSession();
    ts=session.beginTransaction();
    //添加一个Person Idcard
    Person p1=new Person();p1.setName("孙悟空");
    IdCard id1=new IdCard();
    id1.setUseful_time(new java.util.Date());           
    //这句话就可以表示id1是p1这个人.
    id1.setPerson(p1);
    session.save(p1);//insert
    session.save(id1);//insert

    2)基于外健的one-to-one,可以描述为多对一,加unique=“true”约束,
    IdCard的映射文件 中:
    <many-to-one name=”person” column=”person_id” unique=”true” not-null=”true”/>
    <!-唯一的多对一,其实就便成了一对一了就会在Idcard表生成外键-->
    class Person{
    private Integer id;
    private String name;
    private IdCard idCard;
    }
    class IdCard{
    private Integer id;
    private Date validate,
    private Person person;
    }

    多对多(student - course)
    在操作和性能方面都不太理想,所以多对多的映射使用较少,实际使用中最好转换成一对多的对象模型;Hibernate会为我们创建中间关联表,转

    换成两个一对多。
    public class Student {
        private Integer id;
        private String name;
        private Set<StuCourse> stuCourses;
    }
    public class StuCourse {
        private Integer id;
        private Student student;
        private Course course;
        private Integer grade;
    }
    public class Course {
        private Integer id;
        private String name;
        private Set<StuCourse> stuCourses;
    }

    <class name="Student">
    <id name="id" type="java.lang.Integer">
    <generator class="sequence">
    <param name="sequence">stu_seq</param>
    </generator>
    </id>
    <property name="name" type="java.lang.String">
    <column name="name" length="64"/>
    </property>
    <!-- 这里我们配置了one-to-many 一个学生可以对应多个选课记录 -->
    <set name="stuCourses">
    <key column="student_id"/>
    <one-to-many class="StuCourse"/>
    </set>
    </class>

    <class name="StuCourse" >
    <id name="id" type="java.lang.Integer">
    <generator class="sequence">
    <param name="sequence">stucourse_seq</param>
    </generator>
    </id>
    <property name="grade" type="java.lang.Integer">
    <column name="grade" length="3"/>
    </property>
    <many-to-one name="course" column="course_id"/>
    <many-to-one name="student" column="student_id"/>

    </class>

    <class name="Course">
    <id name="id" type="java.lang.Integer">
    <generator class="sequence">
    <param name="sequence">course_seq</param>
    </generator>
    </id>
    <property name="name" type="java.lang.String">
    <column name="name" length="64"/>
    </property>
    <!-- 配置one-to-many 表示一门课程可以对应多个选课记录 -->
    <set name="stuCourses">
    <key column="course_id"/>
    <one-to-many class="StuCourse"/>
    </set>
    </class>
    展开全文
  • `matplotlib`有两种绘图方式,...这两种方式之间并不是完全独立,而是通过某种机制进行了联结,`pylot`绘图模式其实隐式创建了面向对象模式相关对象,其中关键是`matplotlib._pylab_helpers`模块中单例类`Gcf`

    matplotlib有两种绘图方式,一种是依托matplotlib.pyplot模块实现类似matlab绘图指令的绘图方式,一种是面向对象式绘图,依靠FigureCanvas(画布)、 Figure (图像)、 Axes (轴域) 等对象绘图。
    这两种方式之间并不是完全独立的,而是通过某种机制进行了联结,pylot绘图模式其实隐式创建了面向对象模式的相关对象,其中的关键是matplotlib._pylab_helpers模块中的单例类Gcf,它的作用是追踪当前活动的画布及图像。
    因此,可以说matplotlib绘图的基础是面向对象式绘图,pylot绘图模式只是一种简便绘图方式。

    先不分析源码,先做实验!

    实验

    先通过实验,看一看我们常用的那些pyplot绘图模式
    实验一
    无绘图窗口显示

    from matplotlib import pyplot as plt
    plt.show()
    

    实验二
    出现绘图结果

    from matplotlib import pyplot as plt
    plt.plot([1,2])
    plt.show()
    

    实验三
    出现绘图结果

    from matplotlib import pyplot as plt
    plt.gca()
    plt.show()
    

    实验四
    出现绘图结果

    from matplotlib import pyplot as plt
    plt.figure()
    # 或者plt.gcf()
    plt.show()
    

    pyplot模块绘图原理

    通过查看pyplot模块figure()函数、gcf()函数、gca()函数、plot()函数和其他绘图函数的源码,可以简单理个思路!

    • figure()函数:如果有现成图像,返回值就是当前图像,如果没有现成的图像,就初始化一个新图像,返回值为Figure对象。
    • gcf()函数:如果有现成图像,返回值就是当前图像,如果没有现成的图像,就调用figure()函数,返回值为Figure对象。
    • gca()函数:调用gcf()函数返回对象的gca方法,返回值为Axes对象。
    • plot()函数:调用gca()函数返回对象的plot方法。
    • pyplot模块其他绘图函数:均调用gca()函数的相关方法。

    因此,pyplot绘图模式,使用plot()函数或者其他绘图函数,如果没有现成图像对象,直接会先创建图像对象。
    当然使用figure()函数、gcf()函数和gca()函数,如果没有现成图像对象,也会先创建图像对象。

    更进一步,在matplotlib.pyplot模块源码中出现了如下代码,因此再查看matplotlib._pylab_helpers模块它的作用是追踪当前活动的画布及图像

    figManager = _pylab_helpers.Gcf.get_fig_manager(num)
    figManager = _pylab_helpers.Gcf.get_active()
    

    matplotlib._pylab_helpers模块作用是管理pyplot绘图模式中的图像。该模块只有一个类——Gcf,它的作用是追踪当前活动的画布及图像。

    matplotlib.pyplot模块部分源码

    def figure(num=None,  # autoincrement if None, else integer from 1-N
               figsize=None,  # defaults to rc figure.figsize
               dpi=None,  # defaults to rc figure.dpi
               facecolor=None,  # defaults to rc figure.facecolor
               edgecolor=None,  # defaults to rc figure.edgecolor
               frameon=True,
               FigureClass=Figure,
               clear=False,
               **kwargs
               ):
    
        figManager = _pylab_helpers.Gcf.get_fig_manager(num)
        if figManager is None:
            max_open_warning = rcParams['figure.max_open_warning']
    
            if len(allnums) == max_open_warning >= 1:
                cbook._warn_external(
                    "More than %d figures have been opened. Figures "
                    "created through the pyplot interface "
                    "(`matplotlib.pyplot.figure`) are retained until "
                    "explicitly closed and may consume too much memory. "
                    "(To control this warning, see the rcParam "
                    "`figure.max_open_warning`)." %
                    max_open_warning, RuntimeWarning)
    
            if get_backend().lower() == 'ps':
                dpi = 72
    
            figManager = new_figure_manager(num, figsize=figsize,
                                            dpi=dpi,
                                            facecolor=facecolor,
                                            edgecolor=edgecolor,
                                            frameon=frameon,
                                            FigureClass=FigureClass,
                                            **kwargs)
        return figManager.canvas.figure
    
    def plot(*args, scalex=True, scaley=True, data=None, **kwargs):
        return gca().plot(
            *args, scalex=scalex, scaley=scaley,
            **({"data": data} if data is not None else {}), **kwargs)
    
    def gcf():
        """
        Get the current figure.
    
        If no current figure exists, a new one is created using
        `~.pyplot.figure()`.
        """
        figManager = _pylab_helpers.Gcf.get_active()
        if figManager is not None:
            return figManager.canvas.figure
        else:
            return figure()
    
    def gca(**kwargs):
        return gcf().gca(**kwargs)
    
    def get_current_fig_manager():
        """
        Return the figure manager of the current figure.
    
        The figure manager is a container for the actual backend-depended window
        that displays the figure on screen.
    
        If if no current figure exists, a new one is created an its figure
        manager is returned.
    
        Returns
        -------
        `.FigureManagerBase` or backend-dependent subclass thereof
        """
        return gcf().canvas.manager
    

    Gcf类源码

    class Gcf:
        """
        Singleton to maintain the relation between figures and their managers, and
        keep track of and "active" figure and manager.
    
        The canvas of a figure created through pyplot is associated with a figure
        manager, which handles the interaction between the figure and the backend.
        pyplot keeps track of figure managers using an identifier, the "figure
        number" or "manager number" (which can actually be any hashable value);
        this number is available as the :attr:`number` attribute of the manager.
    
        This class is never instantiated; it consists of an `OrderedDict` mapping
        figure/manager numbers to managers, and a set of class methods that
        manipulate this `OrderedDict`.
    
        Attributes
        ----------
        figs : OrderedDict
            `OrderedDict` mapping numbers to managers; the active manager is at the
            end.
        """
    
    展开全文
  • 对象之间的关系

    2012-10-07 10:16:00
    对象之间的关系 1、静态关系 关联、聚合或组合关系,通常归类为静态关系。 静态关系意味着在对象的存活期间,与其他对象之间的链接也会存在,因此这些链接可以跨操作使用。 1)、关联关系 * 两种对象之间有一种...

    ■ 对象之间的关系

    1、静态关系

        关联、聚合或组合关系,通常归类为静态关系。

        静态关系意味着在对象的存活期间,与其他对象之间的链接也会存在,因此这些链接可以跨操作使用。

     

        1)、关联关系

            * 两种对象之间有一种固定不变且需保存的静态关系;

            * 系统会用到这些静态关系,且会将它们保存起来。

        2)、聚合关系

            * 上述 2 关联关系;

            * 两种对象之间有 whole-part 的静态关系。

        3)、组合关系

            * 上述 3 聚合关系;

            * 且 whole 对象被注销(destroy)时,part 对象必须一块被注销。

    2、动态关系

        依赖关系被归类为动态关系。

        该链接只能存活于操作执行期间,无法跨操作使用。

        使用是最常见的依赖。

        依赖是一种单向的关系,所以依赖虚线一定带有箭头,这不同于关联。

     

    ■ 类之间的关系

        1)、泛化关系
            多种特殊对象里,有部分通用的属性与操作,也有部分独有的属性与操作。
     

    转载于:https://www.cnblogs.com/nliao/archive/2012/10/07/2713587.html

    展开全文
  • 面向对象模型之间的关系

    千次阅读 2017-03-11 16:39:14
    功能模型指明了系统应该“做什么”;动态模型明确规定了什么时候(即在何种状态下接受了什么事件...在面向对象方法学中,对象模型是最基本最重要,它为其他两种模型奠定了基础,人们依靠对象模型完成3种模型集成。

    功能模型指明了系统应该“做什么”动态模型明确规定了什么时候(即在何种状态下接受了什么事件的触发)做对象模型定义了做事情的实体。在面向对象方法学中,对象模型是最基本最重要的,它为其他两种模型奠定了基础,人们依靠对象模型完成3种模型的集成。

    展开全文
  • 类与类之间的两种关系------新标准c++程序设计  在c++中,类和类之间有两种基本关系:复合关系和继承关系。  复合关系也称为“has a”关系或“有”的关系,表现为封闭类,即一个类以另一个类的...
  • 为什么要写有关对象-关系数据库之间的映射的文章呢?因为在对象范例和关系范例之间“阻抗不匹配”。对象范例基于软件工程的一些原理,例如耦合、聚合和封装,而关系范例则基于数学原理,特别是集合论的原理。两种...
  • 然而类与类之间还有另一种关系,这就是组合。先来看个例子:先定义个类,一个老师类,老师类有名字,年龄,出生年,月和日,所教课程等特征以及走路,教书技能。class Teacher:def __init__(self,name,age...
  • 在搜索平台上关于类以及对象都已经被霸屏了,主要的问题无非就是个,一个是理解二者,另一个就是理解二者之间的使用关系,对于小编来说,两者统一跟大家讲清,相信也很难被大家消化,这不,给大家想出来比较好理解...
  • 关联体现个类之间语义级别强依赖关系,有时也被称为“相识”或“引用”关系。这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性,一般是长期性,而且双方的关系一般是平等。关联可以...
  • 用例图之间的种关系

    万次阅读 2019-05-03 23:58:54
    用例图之间的种关系 1.执行者与执行者之间的唯一关系(继承) A.解释 执行者与执行者之间只有一种关系即继承(也叫泛化)。其意义与面向对象过程中的继承关系类似,但它主要强调子类执行者对父类执行者与用例之间的...
  • 面向对象的种关系

    千次阅读 2017-03-06 10:27:28
    如果你确定两件对象之间是is-a的关系,那么此时你应该使用继承;比如菱形、圆形和方形都是形状,那么他们都应该从形状类继承而不是聚合。 如果你确定两件对象之间是has-a的关系,那么此时你应该使用聚合;...
  • 我们执着于面《向对象编程》,而多数情况我们都在使用《面向类型编程》,今天简单快速的回顾一下对象之间的关系。 先谈谈类型之间的关系 类型之间的依赖,这里进一步划分为类: 显式依赖:在参数中显式的...
  • ADO.Net支持两种访问数据的模型:无连接模式和连接模式 无连接模式将数据下载到客户机器上,并在客户机上将...ADO.NET对象模型之间的关系进行描述 (1)数据库好比水源,存储了大量的数据(2)Connection对象好比伸入水中...
  • 之间的关系有以下四—— 一、关联关系 单向关联:从一个类中可以访问另一个类的成员,有这个类的引用。 双向关联:个类可以互相访问,互相有引用。 自身关联:本类中调用自身self or this. 多维关联:...
  • Hibernate中表现对象之间关系有:一对一单向,一对一双向,(二者都分主键与外键两种);一对多单向,多对一单向,一对多(多对一)双向,多对多单向,多对多双向,一个是另一个一部分。其中重要是下面做总结...
  • 在搜索平台上关于类以及对象都已经被霸屏了,主要的问题无非就是个,一个是理解二者,另一个就是理解二者之间的使用关系,对于小编来说,两者统一跟大家讲清,相信也很难被大家消化,这不,给大家想出来比较好理解...
  • 构造函数是一特殊函数,主要用来初始化对象,即为对象成员变量赋初始值,它总与 new 一起使用。一般情况下我们会把公共属性定义到构造函数里面,而公共方法放到原型对象身上。 在 JS 中,使用构造函数时要...
  • 在面向对象程序设计时,类与类之间的关系主要分为继承,实现,依赖,关联,聚合,组合六种关系。其中前两种理解很简单,重点是比较容易混淆的后四种。继承(或叫泛化):指的是一个类(称为子类、子接口)继承另外的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,803
精华内容 1,521
关键字:

对象之间的两种关系