使用createrepo创建包依赖关系

使用createrepo创建包依赖关系

1.安装RPM配置工具关系库包：createrepo-0.4.11-3.el5.noarch.rpm包（注根据系统类型版本下载相应createrepo的rpm包安装）

2.安装yum包：rpm -ivh yum*（安装yum包管理工具）

3.建立yum目录：mkdir /yum/iso；mount /dev/cdrom /yum/iso （建立包目录并将包含包的光盘挂载到该目录）

4.使用createrepo进行设置生成关系库：createrepo -v /yum (在包目录所在的目录下生成repodata目录）

执行完毕后，会生成/yum/repodata路经。应该包括如下文件：

[root@RH opt]# ll /yum/repodata/

total 16

-rw-r--r-- 1 root root 155 Jul 31 17:21 filelists.xml.gz

-rw-r--r-- 1 root root 150 Jul 31 17:21 other.xml.gz

-rw-r--r-- 1 root root 162 Jul 31 17:21 primary.xml.gz

-rw-r--r-- 1 root root 951 Jul 31 17:21 repomd.xml

5.配置客户端

vi /etc/yum.conf

[iso]

name=iso

baseurl=file:///yum (就是去这个目录下面找/yum/repodata/repomd.xml这个文件）

mirrorlist=url://path/to/mirrorlist/repository/

gpgcheck=0

enable=1

gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-beta (不同系统和版本此值是不一样的)

iso ：用于指定一个仓库

name ：用于指定易读的仓库名称

baseurl ：用于指定本仓库的URL，可以是如下的几种类型：

http —用于指定远程HTTP 协议的源

ftp —用于指定远程FTP 协议的源

file —用于本地镜像或NFS 挂装文件系统

mirrorlist ：用于指定仓库的镜像站点

enabled ：用于指定是否使用本仓库，默认值为1，即可用

gpgcheck ：用于指定是否检查软件包的GPG 签名

gpgkey ：用于指定GPG 签名文件的URL

在name baseurl 中经常使用如下的变量：

UML类关系(依赖-泛化-关联-聚合-组合-实现)

UML图中类之间的关系:依赖,泛化,关联,聚合,组合,实现 类与类图 1) 类(Class)封装了数据和行为，是面向对象的重要组成部分，它是具有相同属性、操作、 关系的对象集合的总称。 2) 在系统中，每个类具有一定的职责，职责指的是类所担任的任务，即类要完成什么样的 功能，要承担什么样的义务。一个类可以有多种职责，设计得好的类一般只有一种职责，在 定义类的时候，将类的职责分解成为类的属性和操作（即方法）。 3) 类的属性即类的数据职责，类的操作即类的行为职责 依赖关系（Dependence）：假设A类的变化引起了B类的变化，则说名B类依赖于A类。 ? 依赖关系(Dependency) 是一种使用关系，特定事物的改变有可能会影响到使用该事物的其他事物，在需要表示一个事物使用另一个事物时使用依赖关系。大多数情况下，依赖关系体现在某个类的方法使用另一个类的对象作为参数。 ? 在UML中，依赖关系用带箭头的虚线表示，由依赖的一方指向被依赖的一方。 1.public class Driver 2.{ 3.public void drive(Car car) 4. { 5. car.move(); 6. } 7.…… 8.} 9.public class Car 10.{ 11.public void move() 12. { 13. ...... 14. }

15.…… 16.} 依赖关系有如下三种情况： 1、A类是B类中的（某中方法的）局部变量； 2、A类是B类方法当中的一个参数； 3、A类向B类发送消息，从而影响B类发生变化； 泛化关系（Generalization）：A是B和C的父类，B,C具有公共类（父类）A，说明A是B,C的一般化（概括，也称泛化） ? 泛化关系(Generalization)也就是继承关系，也称为“is-a-kind-of”关系，泛化关系用于描述父类与子类之间的关系，父类又称作基类或超类，子类又称作派生类。在UML中，泛化关系用带空心三角形的直线来表示。 ? 在代码实现时，使用面向对象的继承机制来实现泛化关系，如在Java语言中使用extends 关键字、在C++/C#中使用冒号“：”来实现。

数据库范式理解例题

范式分解 主属性：包含在任一候选关键字中的属性称主属性。 非主属性：不包含在主码中的属性称为非主属性。 函数依赖： 是指关系中一个或一组属性的值可以决定其它属性的值。函数依赖正象一个函数 y = f(x) 一样，x的值给定后，y的值也就唯一地确定了。 如果属性集合Y中每个属性的值构成的集合唯一地决定了属性集合X中每个属性的值构成的集合，则属性集合X函数依赖于属性集合Y，计为：Y→X。属性集合Y中的属性有时也称作函数依赖Y→X的决定因素（determinant）。例：身份证号→姓名。部分函数依赖： 设X,Y是关系R的两个属性集合，存在X→Y，若X’是X的真子集，存在X’→Y，则称Y部分函数依赖于X。 完全函数依赖： 在R(U)中，如果Y函数依赖于X,并且对于X的任何一个真子集X'，都有Y不函数依赖于X'，则称Y对X完全函数依赖。否则称Y对X部分函数依赖。

【例】； 举个例子就明白了。假设一个学生有几个属性 SNO 学号 SNAME 姓名 SDEPT系 SAGE 年龄 CNO 班级号 G 成绩 对于(SNO,SNAME,SDEPT,SAGE,CNO,G)来说，G完全依赖于(SNO, CNO), 因为(SNO,CNO)可以决定G，而SNO和CNO都不能单独决定G。 而SAGE部分函数依赖于(SNO,CNO),因为(SNO,CNO)可以决定SAGE，而单独的SNO也可以决定SAGE。 传递函数依赖： 设R（U）是属性集U上的关系，x、y、z是U的子集，在R（U）中，若x→y，但y→x，若y→z，则x→z，称z传递函数依赖于x，记作X→TZ。 如果X->Y, Y->Z, 则称Z对X传递函数依赖。 计算X+ （属性的闭包）算法： a.初始化，令X+ = X; b.在F中依次查找每个没有被标记的函数依赖，若“左边属性集”包含于X+ ，则令X+ = X+∪“右边属性集”, 并为访问过的函数依赖设置标记。

类与类之间的关系

类与类之间存在以下关系: (1)泛化(Generalization) (2)关联(Association) (3)依赖(Dependency) (4)聚合(Aggregation) 1.泛化(Generalization) [泛化] 表示类与类之间的继承关系，接口与接口之间的继承关系，或类对接口的实现关系。一般化的关系是从子类指向父类的，与继承或实现的方法相反。 父类父类实例＝new 子类() [UML图](图1.1) 2.依赖(Dependency) [依赖] 对于两个相对独立的对象，当一个对象负责构造另一个对象的实例，或者依赖另一个对象的服务时，这两个对象之间主要体现为依赖关系。 依赖关系表现在局部变量，方法的参数，以及对静态方法的调用 [现实例子] 比如说你要去拧螺丝，你是不是要借助(也就是依赖)螺丝刀(Screwdriver)来帮助你完成拧螺

丝(screw)的工作 [UML表现](图1.2) 3.关联(Association) [关联] 对于两个相对独立的对象，当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时，这两个对象之间为关联关系。[具体表现] 关联关系是使用实例变量来实现[现实例子] 比如客 3.关联(Association) [关联] 对于两个相对独立的对象，当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时，这两个对象之间为关联关系。 [具体表现] 关联关系是使用实例变量来实现 [现实例子] 比如客户和订单，每个订单对应特定的客户，每个客户对应一些特定的订单；再例如公司和员工，每个公司对应一些特定的员工，每个员工对应一特定的公司 [UML图] (图1.3) (4)聚合（Aggregation） [聚合] 当对象A被加入到对象B中，成为对象B的组成部分时，对象B和对象A之间为聚集关系。聚合是关联关系的一种，是较强的关联关系，强调的是整体与部分之间的关系。 [具体表现] 与关联关系一样，聚合关系也是通过实例变量来实现这样关系的。关联关系和聚合关系来语

类与类之间的关系

一、继承关系 继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力。在Java中继承关系通过关键字extends明确标识，在设计时一般没有争议性。在UML类图设计中，继承用一条带空心三角箭头的实线表示，从子类指向父类，或者子接口指向父接口。 二、实现关系 实现指的是一个class类实现interface接口（可以是多个）的功能，实现是类与接口之间最常见的关系。在Java中此类关系通过关键字implements明确标识，在设计时一般没有争议性。在UML类图设计中，实现用一条带空心三角箭头的虚线表示，从类指向实现的接口。 三、依赖关系 简单的理解，依赖就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖。表现在代码层面，为类B作为参数被类A在某个method方法中使用。在UML类图设计中，依赖关系用由类A指向类B的带箭头虚线表示。 四、关联关系 关联体现的是两个类之间语义级别的一种强依赖关系，比如我和我的朋友，这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的。关联可以是单向、双向的。表现在代码层面，为被关联类B以类的属性形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量。在UML类图设计中，关联关系用由关联类A指向被关联类B的带箭头实线表示，在关联的两端可以标注关联双方的角色和多重性标记。 五、聚合关系 聚合是关联关系的一种特例，它体现的是整体与部分的关系，即has-a的关系。此时整体与部分之间是可分离的，它们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享。比如计算机与CPU、公司与员工的关系等，比如一个航母编队包括海空母舰、驱护舰艇、舰载飞机及核动力

数据库范式理解例题

范式分解 主属性: 包含在任一候选关键字中得属性称主属性。 非主属性: 不包含在主码中得属性称为非主属性。 函数依赖: 就是指关系中一个或一组属性得值可以决定其它属性得值。函数依赖正象一个函数y ＝f(ｘ) 一样，x得值给定后，y 得值也就唯一地确定了。 如果属性集合Y中每个属性得值构成得集合唯一地决定了属性集合X中每个属性得值构成得集合,则属性集合X函数依赖于属性集合Y,计为：Y→X。属性集合Y中得属性有时也称作函数依赖Y→X得决定因素（deterｍｉnaｎt).例：身份证号→姓名。 部分函数依赖: 设Ｘ，Y就是关系R得两个属性集合，存在Ｘ→Ｙ，若X’就是X得真子集，存在Ｘ’→Y,则称Y部分函数依赖于X。 完全函数依赖: 在R（Ｕ)中，如果Y函数依赖于Ｘ,并且对于X得任何一个真子集X’,都有Y不函数依赖于X', 则称Y对X完全函数依赖。否则称Y对Ｘ部分函数依赖。 【例】;

举个例子就明白了。假设一个学生有几个属性 SNO 学号SNAME 姓名ＳDEPT系 SAGE 年龄CNＯ班级号G 成绩 对于(SNO，SNＡMＥ，ＳDEPT，SＡＧE,CNO，Ｇ)来说,Ｇ完全依赖于（ＳＮO，CNO），因为（SNO,CＮO)可以决定G，而SＮO与CＮO都不能单独决定G。 而ＳＡＧE部分函数依赖于（SNO,CNO），因为（SNＯ，CNO)可以决定ＳAGE,而单独得SNO也可以决定SＡGE。 传递函数依赖： 设R（U）就是属性集U上得关系,x、y、ｚ就是U得子集，在R（U)中，若x→y，但y→ｘ,若ｙ→ｚ,则x→z，称ｚ传递函数依赖于x,记作X→ＴZ。 如果X—＞Y, Y—〉Z, 则称Z对Ｘ传递函数依赖。 计算Ｘ＋（属性得闭包) 算法: a、初始化，令X+ ＝ X; b、在F中依次查找每个没有被标记得函数依赖,若“左边属性集”包含于X＋，则令 X+ = X+∪“右边属性集"，并为访问过得函数依赖设置标记。 c、反复执行b直到Ｘ+不改变为止。 检验给定得任意函数依赖Ａ1A2、、、Aｎ->B就是否蕴含于依赖集S: 分析:

类与类之间的关系及代码表现

类与类之间的关系对于理解面向对象具有很重要的作用，以前在面试的时候也经常被问到这个问题，在这里我就介绍一下。 类与类之间存在以下关系: (1)泛化(Generalization) (2)关联(Association) (3)依赖(Dependency) (4)聚合(Aggregation) UML图与应用代码例子: 1.泛化(Generalization) [泛化] 表示类与类之间的继承关系，接口与接口之间的继承关系，或类对接口的实现关系。一般化的关系是从子类指向父类的，与继承或实现的方法相反。 [具体表现] 父类父类实例＝new 子类() [UML图](图1.1) 图1.1Animal类与Tiger类,Dog类的泛化关系 [代码表现] 1.class Animal{} 2.class Tiger extends Animal{} 3.public class Test 4.{ 5. public void test() 6. { 7. Animal a=new Tiger(); 8. } 9.} 2.依赖(Dependency) [依赖] 对于两个相对独立的对象，当一个对象负责构造另一个对象的实例，或者依赖另一个对象的服务时，这两个对象之间主要体现为依赖关系。 [具体表现]

依赖关系表现在局部变量，方法的参数，以及对静态方法的调用 [现实例子] 比如说你要去拧螺丝，你是不是要借助(也就是依赖)螺丝刀(Screwdriver)来帮助你完成拧螺丝(screw)的工作 [UML表现](图1.2) 图1.2 Person类与Screwdriver类的依赖关系 [代码表现] 1.public class Person{ 2. /** 拧螺丝 */ 3. public void screw(Screwdriver screwdriver){ 4. screwdriver.screw(); 5. } 6.} 3.关联(Association) [关联] 对于两个相对独立的对象，当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时，这两个对象之间为关联关系。 [具体表现] 关联关系是使用实例变量来实现 [现实例子] 比如客户和订单，每个订单对应特定的客户，每个客户对应一些特定的订单；再例如公司和员工，每个公司对应一些特定的员工，每个员工对应一特定的公司 [UML图] (图1.3) 图1.3 公司和员工的关联关系 [代码表现] 1.public class Company{ 2. private Employee employee;

数据库-部分函数依赖,传递函数依赖,完全函数依赖,三种范式的区别

数据库-部分函数依赖，传递函数依赖，完全函数依赖， 三种范式的区别 要讲清楚范式，就先讲讲几个名词的含义吧： 部分函数依赖：设X,Y是关系R的两个属性集合，存在X→Y，若X’是X的真子集，存在X’→Y，则称Y部分函数依赖于X。 举个例子：学生基本信息表R中（学号，身份证号，姓名）当然学号属性取值是唯一的，在R关系中，（学号，身份证号）->（姓名），（学号）->（姓名），（身份证号）->（姓名）；所以姓名部分函数依赖与（学号，身份证号）； 完全函数依赖：设X,Y是关系R的两个属性集合，X’是X的真子集，存在X→Y，但对每一个X’都有X’!→Y，则称Y完全函数依赖于X。例子：学生基本信息表R（学号，班级，姓名）假设不同的班级学号有相同的，班级内学号不能相同，在R关系中，（学号，班级）->（姓名），但是（学号）->(姓名)不成立，（班级）->(姓名)不成立，所以姓名完全函数依赖与（学号，班级）； 传递函数依赖：设X,Y,Z是关系R中互不相同的属性集合，存在X→Y(Y !→X),Y→Z，则称Z传递函数依赖于X。 例子：在关系R(学号 ,宿舍, 费用)中，(学号)->(宿舍),宿舍！=学号，(宿舍)->(费用),费用!=宿舍，所以符合传递函数的要求；

在任何一个关系数据库中，第一范式（1NF）是对关系模式的基本要求，不满足第一范式（1NF）的数据库就不是关系数据库。 所谓第一范式（1NF）是指数据库表的每一列(即每个属性)都是不可分割的基本数据项，同一列中不能有多个值，即实体中的某个属性不能有多个值或者不能有重复的属性。简而言之，第一范式就是无重复的列。 2、第二范式（2NF） 第二范式（2NF）是在第一范式（1NF）的基础上建立起来的，即满足第二范式（2NF）必须先满足第一范式（1NF）。第二范式（2NF）要求数据库表中的每个实例或行必须可以被唯一地区分。为实现区分通常需要为表加上一个列，以存储各个实例的唯一标识。员工信息表中加上了员工编号（emp_id）列，因为每个员工的员工编号是唯一的，因此每个员工可以被唯一区分。这个唯一属性列被称为主关键字或主键、主码。 第二范式（2NF）要求实体的属性完全依赖于主关键字。所谓完全依赖是指不能存在仅依赖主关键字一部分的属性，如果存在，那么这个属性和主关键字的这一部分应该分离出来形成一个新的实体，新实体与原实体之间是一对多的关系。为实现区分通常需要为表加上一个列，以存储各个实例的唯一标识。简而言之，第二范式就是非主属性依赖于主关键字。

关系模式规范化实例析解

关系模式规范化实例析解 摘要：关系模式是关系数据库的重要组成部份，其规范化理论在整个模式设计中占有主导地位。下面我们试图采用接近课堂教学的方式给出一个完整实例，希望对初学者有所帮助。 关键词：关系模式；规范化；函数依赖；范式 众所周知，关系模式是关系数据库的重要组成部份，其好坏直接影响关系数据库的性能。而关系模式的设计必须满足一定的规范化要求，从而满足不同的范式级别。[1],57)在指导关系模式的设计中，规范化理论占有着主导地位，其基本思想是：消除数据依赖中不合理的部份，使各关系模式达到某种程度的分离，使一个关系仅描述一个实体或者实体间的一种联系。[2]关系模式及其规范化的理论是我们设计和优化关系模式的指南。作为一种优秀而成熟的理论，学习和实践会有一定的难度，但在因特网和相关书籍中难得有比较全面的实例，给我们学习和实践造成不便。下面，我们试图采用接近课堂教学的方式给出一个完整的析解实例，以期对初学者有所帮助。 一、实例 假设某商业集团数据库中有一关系模式R（商店编号，商品编号，数量，部门编号，负责人），如果规定： （1）每个商店的每种商品只在一个部门销售； （2）每个商店的每个部门只有一个负责人； （3）每个商店的每种商品只有一个库存数量。 试回答下列问题： （1）根据上述规定，写出关系模式R的基本函数依赖； （2）找出关系模式R的候选关键字； （3）试问关系模式R最高已经达到第几范式为什么 （4）如果R已达3NF，是否已达BCNF 若不是BCNF，将其分解为BCNF模式集。 二、预处理 为了方便，我们用代号代表每个属性： A—商店编号 B—商品编号 C—部门编号 D—数量 E—负责人 这样，有关系模式：R（U，F） U={A，B，C，D，E}

东北农业大学 数据库概论及实例作业题参考答案

东北农业大学网络教育学院 数据库概论及实例作业题参考答案 复习题一 参考答案 一、单项选择题 CAABC BCCDC 二、填空题 1． 数据结构 数据操纵 完整性约束 2． 差 3． 12L L ? 4． 非空集合 5． 等值连接 自然连接 6． ? 非平凡的函数依赖 （或者? 平凡的函数依赖） 7． AB 8． 企业组织的信息要求 9． 事务管理子系统 10．属性 实体 联系 11．排它锁（写锁） 共享锁（读锁） 12．关系 元组 三、简答题 1． 答：数据库系统采用了“三级模式和两级映射”保证了数据库中的数据具有较高的逻辑独立性和物理 独立性。其优点是当数据的逻辑结构变了，用户程序可以不变。物理数据改变了，程序也可以不变 2． 答：数据模型是现实世界数据特征的抽象。数据库中用数据模型来抽象地表示现实世界的数据和信息。 数据模型的三要素：数据结构、数据操作、完整性性约束条件。 3． 答：在数据库系统中，关系的每一个属性都是不可再分的，关系中不允许出现重复元组，关系是一个 集合，其行列顺序无关 4． 答：SQL 语言可以作为独立的语言在终端一交互的方式是使用，是面向集合的描述性语言，是非过程 性的，大多数语句可独立执行，与上下文无关的。而许多事务处理应用都是过程性的，需要根据不同的条件来执行不同的任务，因此单纯用SQL 语言是很难实现这类应用的。为此将SQL 嵌入到某些高级语言中，利用高级语言的过程性结构来弥补SQL 语言实现复杂应用方面的不足。 四、答：（1）首先根据定理分析ρ相对于F 是否具有无损连接 因B U U A U U =-=?2121, 故 有+ ∈→F B A 则ρ相对于F 试无损联接的 （2）分析ρ是否保持函数依赖 因 相对于R 1的函数依赖集F 1为}{B A → 相对于R 2的函数依赖集F 2为}{Φ 故 ρ不保持函数依赖

UML中几种类间关系

UML中几种类间关系：继承、实现、依赖、关联、聚合、组合的联系与区别 继承 指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系；在Java中此类关系通过关键字extends明确标识，在设计时一般没有争议性； 实现 指的是一个class类实现interface接口（可以是多个）的功能；实现是类与接口之间最常见的关系；在Java中此类关系通过关键字implements明确标识，在设计时一般没有争议性；

依赖 可以简单的理解，就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是B类的变化会影响到A；比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖；表现在代码层面，为类B作为参数被类A在某个method 方法中使用； 关联 他体现的是两个类、或者类与接口之间语义级别的一种强依赖关系，比如我和我的朋友；这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的、关联可以是单向、双向的；表现在代码层面，为被关联类B 以类属性的形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量；

聚合 聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分； 组合 组合也是关联关系的一种特例，他体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合；他同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束；比如你和你的大脑；表现在代码层面，和关联关系是一致的，只能从语义级别来区分； 对于继承、实现这两种关系没多少疑问，他们体现的是一种类与类、

类与类之间的关系

类与类之间的关系对于理解面向对象具有很重要的作用，下面进行总结！ 一、类与类之间存在以下关系: ` UML图与应用代码例子: 1.泛化(Generalization) [泛化] 表示类与类之间的继承关系，接口与接口之间的继承关系，或类对接口的实现关系。一般化的关系是从子类指向父类的，与继承或实现的方法相反。 [简单理解] 是一个is a 的关系。如老虎是一个动物 [具体表现] 父类父类实例＝new 子类() [UML图](图1.1) 图1.1 Animal类与Tiger类,Dog类的泛化关系 [代码表现] 1. class Animal{ 2. 3. } 4. class Tiger extends Animal { 5. 6. } 7. public class Test 8. { 9. public void test() 10. { 11. Animal a=new Tiger(); 12. } 13. }

2.依赖(Dependency) [依赖] 对于两个相对独立的对象，当一个对象负责构造另一个对象的实例，或者依赖另一个对象的服务时，这两个对象之间主要体现为依赖关系。 [具体表现] 依赖关系表现在局部变量，方法的参数，以及对静态方法的调用 [简单理解] 一个类使用了另外一个类作为局部变量和方法参数。是一个use a关系！ [现实例子] 比如说你要去拧螺丝，你是不是要借助(也就是依赖)螺丝刀(Screwdriver)来帮助你完成拧螺丝(screw)的工作 [UML表现](图1.2) 有时在uml图中不出现箭头只是虚线 图1.2 Person类与Screwdriver类的依赖关系 理解： 指Person类可能要用到Screwdriver的一些方法，也可以这样说，要完成Person里的所有功能，一定要有Screwdriver的方法协助才行。Person依赖于Screwdriver的定义。 ROSE对依赖关系不产生属性。 注意，要避免双向依赖。一般来说，不应该存在双向依赖 [代码表现] 1. public class Person 2. { 3. /** 拧螺丝 */ 4. public void screw(Screwdriver screwdriver) 5. { 6. screwdriver.screw(); 7. } 8. }

计算最小函数依赖集示例

计算最小函数依赖集示例 举例：已知关系模式R，U={A,B,C,D,E,G}， F={AB→C,D→EG,C→A,BE→C,BC→D,CG→BD,ACD→B,CE→AG}，求 F的最小函数依赖集。 解：利用算法求解，使得其满足三个条件 ①利用分解规则，将所有的函数依赖变成右边都是单个属性的函数依赖，得F为： F={AB→C,D→E,D→G,C→A,BE→C,BC→D,CG→B,CG→D,ACD→B,CE→A,CE →G} ②去掉F中多余的函数依赖。 A．设AB→C为冗余的函数依赖，则去掉AB→C，得： F1={D→E,D→G,C→A,BE→C,BC→D,CG→B,CG→D,ACD→B,CE→A,CE→G}计算(AB)F1+：设X(0)=AB 计算X(1)：扫描F1中各个函数依赖，找到左部为AB或AB子集的函数依赖，因为找不到这样的函数依赖。故有X(1)=X(0)=AB，算法终止。 (AB)F1+= AB不包含C，故AB→C不是冗余的函数依赖，不能从F1中去掉。 B．设CG→B为冗余的函数依赖，则去掉CG→B，得： F2={AB→C,D→E,D→G,C→A,BE→C,BC→D,CG→D,ACD→B,CE→A,CE→G}计算(CG)F2+：设X(0)=CG 计算X(1)：扫描F2中的各个函数依赖，找到左部为CG或CG子集的函数依赖，得到一个C→A函数依赖。故有X(1)=X(0)∪A=CGA=ACG。 计算X(2)：扫描F2中的各个函数依赖，找到左部为ACG或ACG子集的函数依赖，得到一个CG→D函数依赖。故有X(2)=X(1)∪D=ACDG。 计算X(3)：扫描F2中的各个函数依赖，找到左部为ACDG或ACDG子集的函数依赖，得到两个ACD→B和D→E函数依赖。故有X(3)=X(2)∪ BE=ABCDEG，因为X(3)=U，算法终止。 (CG)F2+=ABCDEG包含B，故CG→B是冗余的函数依赖，从F2中去掉。 C．设CG→D为冗余的函数依赖，则去掉CG→D，得： F3={AB→C,D→E,D→G,C→A,BE→C,BC→D,ACD→B,CE→A,CE→G}计算(CG)F3+：设X(0)=CG 计算X(1)：扫描F3中的各个函数依赖，找到左部为CG或CG子集的函数依赖，得到一个C→A函数依赖。故有X(1)=X(0)∪A=CGA=ACG。 计算X(2)：扫描F3中的各个函数依赖，找到左部为ACG或ACG子集的函数依赖，因为找不到这样的函数依赖。故有X(2)=X(1)，算法终止。(CG)F3+=ACG。 (CG)F3+=ACG不包含D，故CG→D不是冗余的函数依赖，不能从F3中去掉。 D．设CE→A为冗余的函数依赖，则去掉CE→A，得： F4={AB→C,D→E,D→G,C→A,BE→C,BC→D,CG→D,ACD→B,CE→G}计算(CG)F4+：设X(0)=CE

类与类之间的关系(继承、实现、依赖、关联、聚合、组合)

类与类之间的关系继承 接口 依赖 关联 聚合 组合

继承 继承是一个类（子类,子接口）继承另一个类（父类，父接口）。 当父类为抽象时，该类不能够在实例化。当父类中有抽象方法时。 该类就必须为抽象类。其抽象方法没有方法体。当子类继承该父类时，抽象方法必须重写。 public class abstract Parents{ public abstract void method(); } public class Child extends Parents{ public void method(){ } }属性方法

接口 接口就是在接口中写出方法，然后在调用接口类 时实现所有接口类中方法。java中通过 interface来表示接口。其一个类可以实现多个 接口，用implement来实现接口，用“，”来连 接多个接口。接口不能够被实例化。 public interface iner{ public void print(); } public class Test implement iner{ public void print(){ System.out.print("接口"); } }

依赖 依赖就是要实现类A的功能必须引用到类B，而这种关系具有偶然性、临时性、非常弱的。同时B 类的变化会影响到A类。 人船类渡河 实例： 当你要渡河时，就必须要调用船类中的渡河方法。这就是依赖

关联 两个相对独立的对象，当一个对象的实例与另一个对象的特定实例存在固定关系时，就存在关联。亦是一种强的依赖性。不存在依赖的偶然性、临时性。是长时性的。而且双方是平等的。 可以是单向的、也可以是双向的。 单向关联 类A认识类B，类A知道类B的存在，类A可以调用类B的方法。 代码表现：类A中有类B的变量或引用。 public class Order{ public void addOrder(Product product ){ order.Add(product); } } public class Product{ }

函数依赖(理论及举例)

函数依赖（理论及举例） 教你如何理解函数依赖 一、函数依赖的概念 函数依赖：函数依赖就是讨论一个数据表（关系）中属性值之间所存在的函数关系。函数是一种数学中的概念，被引入到数据库中对数据的联系进行分析。 在一个关系中，属性相当于数学上的变量，属性的域相当于变量的取值范围，属性在一个元组上的取值相当于属性变量的当前值。 例如：在下面的这个职工关系中，职工号、姓名、性别、年龄、职务等属性都相当于变量；职工号属性的域，即四位十进制数字，就是取值范围，性别属性的域：{男、女}，就是性别属性的取值范围。此关系中包含有6个元组，如第2个元组为{3051、刘平、男、48、副处}，其中的每个属性值都是对应属性在该元组上的当前值。 单值函数和多值函数：元组中一个属性或一些属性值对另一个属性值的影响相当于自变量值对函数值的影响。当给定一个自变量值能求出唯一的一个函数值时，称此为单值函数或单映射函数，否则为多值函数。在单值函数中由自变量的一个值确定函数的一个值，但不同的自变量值允许具有相同的函数值。如f(x)=2x, f(n)=(-1)^n, f(x)=x^3+1等都是单值函数，由自变量x或n的值能够唯一确定f(x)或f(n)的值。

属性的单值函数决定（依赖）：在一个关系中，若一个或一组属性的值对另一个或一组属性值起到决定性的作用，则称为单值函数决定（依赖）。如上表中职工号的值就能够函数决定其余每个属性的值，也就是说，当职工号给定后，其他每个属性的值就跟着唯一地确定了。如假定职工号为3074，则他的姓名必定是王海，性别必定为男，年龄必定为32岁，职务必定为正科。这就叫做职工号能够分别单值函数决定姓名、性别和年龄属性，反过来，可以说姓名、性别和年龄等属性单值函数依赖于职工号属性。 二、函数依赖的定义 定义：设一个关系为R(U)，X和Y为属性集U上的子集，若对于X上的每个值都有Y上的一个唯一值与之对应，则称X和Y具有函数依赖关系，并称X 函数决定Y，或称Y函数依赖于X，记作X→Y，称X为决定因素。 例如：设一个职工关系为（职工号，姓名，性别，年龄，职务），职工号用来标识每个职工，选作为该关系的主码。对于该关系中每个职工的职工号，都对应着姓名属性中的唯一值，即该职工的姓名，或者说一个职工的姓名由其职工号唯一确定，所以称职工号函数决定姓名，或称姓名函数依赖于职工号，记作“职工号→姓名”，职工号为该函数依赖的决定因素。同理，当一名职工的职工号被确定之后，它所对应的性别、年龄、职务等属性值就被唯一确定下来了，所以职工号函数决定性别、年龄、职务等描述职工特征的每个属性，可以分别记作为“职工号→性别”、“职工号→年龄”、“职工号→职务”。 在该关系中除职工号外，其他属性都不能成为决定因素形成函数依赖，因为对于它们的每个属性值，都可能对应另一属性的多个不同的取值。如对于性别属性的一个取值“男”就会对应多个而不是一个职工号，此不是单值函数依赖，而是多值函数依赖，所以不能由性别来决定职工号。 相互函数依赖：在这个职工关系中，若规定不允许职工有重名，则姓名也能够唯一标识一个元组，这样姓名也能够函数确定其他每个属性，此时职工号和姓名在取值上一一对应，相互成为决定因素，即构成相互函数依赖，记作为“职工号←→姓名”。但通常是允许职工重名的，因为不应该让已经重名的职工重新起名，这样姓名就不能成为关系的候选码，就不能函数决定其他任何属性。 若一个关系中的属性子集X不能函数决定另一个属性子集Y，则记作X Y，读作X不能函数决定Y，或Y不能函数依赖于X。

UML类图关系(泛化、继承、实现、依赖、关联、聚合、组合)

继承、实现、依赖、关联、聚合、组合的联系与区别 分别介绍这几种关系： 继承 指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力，继承是类与类或者接口与接口之间最常见的关系；在Java 中此类关系通过关键字extends明确标识，在设计时一般没有争议性； 实现 指的是一个class类实现interface接口（可以是多个）的功能；实现是类与接口之间最常见的关系；在Java中此类关系通过关键字implements明确标识，在设计时一般没有争议性； 依赖 可以简单的理解，就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、、临时性的、非常弱的，但是B类的变化会影响到A；比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖；表现在代码层面，为类B作为参数被类A在某个method 方法中使用；

关联 他体现的是两个类、或者类与接口之间语义级别的一种强依赖关系，比如我和我的朋友；这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的、关联可以是单向、双向的；表现在代码层面，为被关联类B 以类属性的形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量； 聚合 聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系，此时整体与部分之间是可分离的，他们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享；比如计算机与CPU、公司与员工的关系等；表现在代码层面，和关联关系是一致的，只能从语义级别来区分； 组合 组合也是关联关系的一种特例，他体现的是一种contains-a的关系，这种关系比聚合更强，也称为强聚合；他同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束；比如你和你的大脑；表现在代码层面，和关联关系是一致的，只能从语义级别来区分； 对于继承、实现这两种关系没多少疑问，他们体现的是一种类与类、或者类与接口间的纵向关系；其他的四者关系则体现的是类与类、或者类与接口间的引用、横向关系，是比较难区分的，有很多事物间的关系要想准备定位是很难的，前面也提到，这几种关系都是语义级别的，所以从代码层面并不能完全区分各种关系； 但总的来说，后几种关系所表现的强弱程度依次为：组合>聚合>关联>依赖；

数据库三范式经典实例解析

数据库三范式经典实例解析 (2007-09-27 15:30) 数据库的设计范式是数据库设计所需要满足的规范，满足这些规范的数据库是简洁的、结构明晰的，同时，不会发生插入（insert）、删除（delete）和更新（update）操作异常。反之则是乱七八糟，不仅给数据库的编程人员制造麻烦，而且面目可憎，可能存储了大量不需要的冗余信息。 设计范式是不是很难懂呢？非也，大学教材上给我们一堆数学公式我们当然看不懂，也记不住。所以我们很多人就根本不按照范式来设计数据库。 实质上，设计范式用很形象、很简洁的话语就能说清楚，道明白。本文将对范式进行通俗地说明，并以笔者曾经设计的一个简单论坛的数据库为例来讲解怎样将这些范式应用于实际工程。 范式说明 第一范式（1NF）：数据库表中的字段都是单一属性的，不可再分。这个单一属性由基本类型构成，包括整型、实数、字符型、逻辑型、日期型等。 例如，如下的数据库表是符合第一范式： 而这样的数据库表是不符合第一范式的： 很显然，在当前的任何关系数据库管理系统（DBMS）中，傻瓜也不可能做出不符合第一范式的数据库，因为这些DBMS不允许你把数据库表的一列再分成二列或多列。因此，你想在现有的DBMS中设计出不符合第一范式的数据库都是不可能的。 第二范式（2NF）：数据库表中不存在非关键字段对任一候选关键字段的部分函数依赖（部分函数依赖指的是存在组合关键字中的某些字段决定非关键字段的情况），也即所有非关键字段都完全依赖于任意一组候选关键字。 假定选课关系表为SelectCourse(学号, 姓名, 年龄, 课程名称, 成绩, 学分)，关键字为组合关键字(学号, 课程名称)，因为存在如下决定关系： (学号, 课程名称) → (姓名, 年龄, 成绩, 学分) 这个数据库表不满足第二范式，因为存在如下决定关系： (课程名称) → (学分) (学号) → (姓名, 年龄) 即存在组合关键字中的字段决定非关键字的情况。 由于不符合2NF，这个选课关系表会存在如下问题： (1) 数据冗余： 同一门课程由n个学生选修，"学分"就重复n-1次；同一个学生选修了m门课程，姓名和年龄就重复了m-1次。 (2) 更新异常： 若调整了某门课程的学分，数据表中所有行的"学分"值都要更新，否则会出现同一门课程学分不同的情况。

数据库设计三大范式应用实例剖析

数据库设计三大范式应用实例剖析 范式说明 第一范式（1NF）：数据库表中的字段都是单一属性的，不可再分。这个单一属性由基本类型构成，包括整型、实数、字符型、逻辑型、日期型等。 例如，如下的数据库表是符合第一范式的： 很显然，在当前的任何关系数据库管理系统（DBMS）中，傻瓜也不可能做出不符合第一范式的数据库，因为这些DBMS不允许你把数据库表的一列再分成二列或多列。因此，你想在现有的DBMS中设计出不符合第一范式的数据库都是不可能的。 第二范式（2NF）：数据库表中不存在非关键字段对任一候选关键字段的部分函数依赖（部分函数依赖指的是存在组合关键字中的某些字段决定非关键字段的情况），也即所有非关键字段都完全依赖于任意一组候选关键字。 假定选课关系表为SelectCourse(学号, 姓名, 年龄, 课程名称, 成绩, 学分)，关键字为组合关键字(学号, 课程名称)，因为存在如下决定关系： (学号, 课程名称) → (姓名, 年龄, 成绩, 学分) 这个数据库表不满足第二范式，因为存在如下决定关系： (课程名称) → (学分) (学号) → (姓名, 年龄) 即存在组合关键字中的字段决定非关键字的情况。 由于不符合2NF，这个选课关系表会存在如下问题： (1) 数据冗余：

同一门课程由n个学生选修，"学分"就重复n-1次；同一个学生选修了m 门课程，姓名和年龄就重复了m-1次。 (2) 更新异常： 若调整了某门课程的学分，数据表中所有行的"学分"值都要更新，否则会出现同一门课程学分不同的情况。 (3) 插入异常： 假设要开设一门新的课程，暂时还没有人选修。这样，由于还没有"学号"关键字，课程名称和学分也无法记录入数据库。 (4) 删除异常： 假设一批学生已经完成课程的选修，这些选修记录就应该从数据库表中删除。但是，与此同时，课程名称和学分信息也被删除了。很显然，这也会导致插入异常。 把选课关系表SelectCourse改为如下三个表： 学生：Student(学号, 姓名, 年龄)； 课程：Course(课程名称, 学分)； 选课关系：SelectCourse(学号, 课程名称, 成绩)。 这样的数据库表是符合第二范式的，消除了数据冗余、更新异常、插入异常和删除异常。 另外，所有单关键字的数据库表都符合第二范式，因为不可能存在组合关键字。 第三范式（3NF）：在第二范式的基础上，数据表中如果不存在非关键字段对任一候选关键字段的传递函数依赖则符合第三范式。所谓传递函数依赖，指的是如果存在"A → B → C"的决定关系，则C传递函数依赖于A。因此，满足第三范式的数据库表应该不存在如下依赖关系： 关键字段→ 非关键字段x → 非关键字段y 假定学生关系表为Student(学号, 姓名, 年龄, 所在学院, 学院地点, 学院电话)，关键字为单一关键字"学号"，因为存在如下决定关系： (学号) → (姓名, 年龄, 所在学院, 学院地点, 学院电话) 这个数据库是符合2NF的，但是不符合3NF，因为存在如下决定关系：

函数依赖推理资料

5.2.3 函数依赖公理系统 1974年W.W.Armstrong首先提出了函数依赖的公理系统，称为Armstrong公理。对于一组已知的函数依赖，利用该公理可导出所蕴函的函数依赖。对于关系模式R(U,F)，为了确定一个关系模式的码，为了从一组函数依赖求得蕴含的函数依赖，我们需要从现有的函数依赖集合F下推导或者至少需要判断函数依赖X→Y是否为F所蕴含。为此，我们需要一套推理规则。这样的推理规则，在1974年由Armstrong首先提出来，称为Armstrong公理(Armstrong's axioms) 系统。 在介绍Armstrong公理系统之前，我们先给出逻辑蕴含和F的闭包的概念。 1. 逻辑蕴含 给定一个关系模式，只考虑给定的函数依赖是不够的，必须找出在该关系模式上成立的其他函数依赖。 逻辑蕴含：设F是关系模式R（U）的函数依赖集合，由F出发，可以证明其他某些函数依赖也成立，我们称这些函数依赖被F逻辑蕴含。 例如，设F={ A→B，B→C }，则函数依赖A→C被F逻辑蕴含，记作：F |= A→C。即函数依赖集F 逻辑蕴含函数依赖A→C。 2. F的闭包F+ 对于一个关系模式，如何由已知的函数依赖集合F，找出F逻辑蕴涵的所有函数依赖集合呢？这就是我们下面要讨论的问题。 F的闭包F+：设F为一个函数依赖集，F的闭包是指F逻辑蕴涵的所有函数依赖集合。F的闭包记作F+。 例如，给定关系模式R(A,B,C,G,H,I)，函数依赖集合F={A→B，A→C，CG→H，CG→I，B→H}。可以证明函数依赖A→H被F逻辑蕴涵。 设有元组s和t，满足s[A]=t[A]，根据函数依赖的定义，由已知的A→B，可以推出s[B]=t[B]。又根据函数依赖B→H，可以有s[H]=t[H]。因此，已经证明对任意的两个元组s和t，只要有s[A]=t[A]，就有s[H]=t[H]。所以，函数依赖A→H 被F逻辑蕴涵。 计算F的闭包F+，可以由函数依赖的定义直接计算，如上面的示例。但是，当F很大时，计算的过程会很长。为了从已知的函数依赖推导出其它函数依赖，Armstrong 提出了一套推理规则，称为Armstrong 公理，通过反复使用这些规则，可以找出给定F的闭包F+。其推理规则可归结为如下3条：自反律(reflexivity)、增广律(augmentation)和传递律(transitivity)。 3．Armstrong 公理 设U为属性总体集合，F为U上的一组函数依赖，对于关系模式R（U，F），X、Y、Z为属性U的子集，有下列推理规则： A1：自反律(reflexivity) 若Y X U，则X→Y为F所蕴函。 A2：增广律(augmentation) 若X→Y为F所蕴函，且Z是U的子集，则XZ→YZ为F所蕴函。式中XZ 和YZ是X∪Z 和Y∪Z的简写。 A3：传递律(transitivity) 若X→Y、Y→Z为F所蕴函，则X→Z为F所蕴函。 由自反律所得到的函数依赖都是平凡的函数依赖，自反律的使用并不依赖于F，而只依赖于属性集U。 Armstrong公理是有效的和完备的。可以利用该公理系统推导F的闭包F+。