精华内容
下载资源
问答
  • 在分析了面向对象数据库(OODB)及数据库视图功能特征的基础上,讨论了面向对象数据库视图的实现方法,在OODB中实现了基于对象查询的数据库视图的部分功能,并研制了一个档案管理系统加以验证。
  • 第八章_具有面向对象特征数据库系统 本章不是重点章,通过学习,可以了解两类具有面向对象特征数据库系统的基本概念。仅此而已。 一、数据模型的演变过程 第一代数据库系统是70年代流行的层次、网状DBS。第二...

    第八章_具有面向对象特征的数据库系统

    本章不是重点章,通过学习,可以了解两类具有面向对象特征的数据库系统的基本概念。仅此而已。

    一、数据模型的演变过程

    第一代数据库系统是70年代流行的层次、网状DBS。第二代DBS80年代流行的关系数据库系统。

    但是这两代数据库不能适应新的应用需要:

    多媒体数据

    空间数据

    时态数据

    复合对象

    新一代的数据库系统从面向对象技术和数据库结构的角度出发。形成两种风格,一是"面向对象的数据库系统"(OODBS),另一种是"对象关系数据库系统"(ORDBS)

    二、嵌套关系和复合对象

    关系模式中的数据结构层次是"关系---元组---属性"而属性类型是一些基本的数据类型。元组是属性值的有序集合,关系是元组的无序集合,关系具有规范化结构(1NF).因此,传统关系模型称为"平面关系模型"

    若允许关系的属性值又可以是关系,而且可以嵌套,形成非1NF关系,则形成嵌套关系模型。

    若进一步放宽限制,允许关系中的属性可以是基本数据类型、结构类型(元组类型)或集合类型(即关系类型)。则形成复合对象模型。

    三、对象关系数据库

    在传统的关系数据模型基础上,提供元组、数组、集合一类更为丰富的数据类型以及处理新的数据类型操作的能力,这样形成的数据模型称为"对象关系数据模型",基于对象关系数据模型的DBS称为对象关系数据库系统(ORDBS)

    三、面向对象数据库

    在面向对象程序设计语言(OOPL)

    C++基础上进行扩充,引入数据库技术,能操作持久数据,处理数据库。形成持久化C++系统。也就是面向对象数据库系统

    转载于:https://www.cnblogs.com/gzhnan/articles/1596704.html

    展开全文
  • 无论您是狂热的数据库开发人员还是以前从未使用过数据库,ZozaniDB 都会让您沉迷于将数据保存在数据库系统中。 要下载您的 ZozaniDB 免费副本,请访问: http://zozani.com/zozanidb 特征: * 无SQL访问:插入、...
  • 数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。 起初,“面向对象”是专指在程序设计中采用封装、继承、多态和抽象等设计方法。可是目前面向对象的思想已经...

    面向对象思想

    面向对象的概念和应用已超越了程序设计和软件开发,扩展到很宽的范围。如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。

    起初,“面向对象”是专指在程序设计中采用封装、继承多态和抽象等设计方法。可是目前面向对象的思想已经涉及到软件开发的各个方面。如,面向对象的分析(OOA,Object Oriented Analysis),面向对象的设计(OOD,Object Oriented Design)、以及我们经常说的面向对象的编程实现(OOP,Object Oriented Programming)。

    面向对象三大特征:

    ①封装

    封装是指将数据与具体操作的实现代码放在某个对象内部,使这些代码的实现细节不被外界发现,外界只能通过接口使用该对象,而不能通过任何形式修改对象内部实现,正是由于封装机制,程序在使用某一对象时不需要关心该对象的数据结构细节及实现操作的方法。使用封装能隐藏对象实现细节,使代码更易维护,同时因为不能直接调用、修改对象内部的私有信息,在一定程度上保证了系统安全性。

    ②继承

    面向对象之所以使用继承机制主要是用于实现代码的复用多个类所公用的代码部分可以只在一个类中提供,而其他类只需要继承即可。

    ③多态

    多态是指在继承体系中,所有派生类都从基类继承接口,但由于每个派生类都是独立的实体,因此在接收同一消息的时候,可能会生成不同的响应。多态的作用作为隐藏代码实现细节,使得代码能够模块化;扩展代码模块,实现接口重用。简单来说:一种行为产生多种效果。

    总的来说:封装可以隐藏实现细节同时包含私有成员,使得代码模块化并增加安全指数;继承可以扩展已存在的模块,目的是为了代码重用;多态则是为了保证:类在继承和派生的时候,保证家谱中任何类的实例被正确调用,实现了接口重用。

    #include<iostream>
    using namespace std;
    
    class people
    {
    public:
    	void eat()
    	{
    		cout << "eat" << endl;
    	}
    	virtual void speak()
    	{
    		cout << "hahaha!" << endl;
    	}
    private:
    	int a;
    	int b;
    };//封装性
    class student :public people//继承性
    {
    public:
    	virtual void speak()
    	{
    		cout << "nihaoma" << endl;
    	}
    private:
    	int b;
    };
    
    
    int main()
    {
    	student s;
    	people *p = &s;
    	p->speak();//多态性
    	people peo;
    	people *pp = &peo;
    	pp->speak();
    }

     

    C++同名函数的关系

    成员函数被重载的特征:

    (1)相同的范围(在同一个类中);

    (2)函数名字相同;

    (3)参数不同;

    (4)virtual关键字可有可无。

    覆盖是指派生类函数覆盖基类函数,特征是:

    (1)不同的范围(分别位于派生类与基类);

    (2)函数名字相同;

    (3)参数相同;

    (4)基类函数必须有virtual关键字。

    “隐藏”是指派生类的函数屏蔽了与其同名的基类函数,

    规则如下:

    (1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual关键字,基类的函数将被隐藏(注意别与重载混淆)。

    (2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual关键字。(这里与覆盖唯一区别是在于有没有virtual) 此时,基类的函数被隐藏(注意别与覆盖混淆)。

    C++三种继承的访问权限控制

    众所周知,C++类中的成员(函数/变量)拥有三种访问权限:

           public:用该关键字修饰的成员表示公有成员,该成员不仅可以在类内可以被访问,在类外也是可以被访问的,是类对外提供的可访问接口;

           private:用该关键字修饰的成员表示私有成员,该成员仅在类内可以被访问,在类体外是隐藏状态;

           protected:用该关键字修饰的成员表示保护成员,保护成员在类体外同样是隐藏状态,但是对于该类的派生类来说,相当于公有成员,在派生类中可以被访问。

           对一个类的派生类来说,在继承基类的过程中,不仅包含了基类的所有成员,还增加了自己的成员,而派生类中成员的访问权限则会因为继承权限方式的不同而不同。

           相对于派生类成员的访问权限比较简单(派生类成员的访问权限就是取决于派生类中定义的权限),从基类中继承的成员的访问权限就相对较为复杂,这并不是简单地照搬基类的成员访问权限。基类成员在派生类中的访问权限与继承的方式有着密切的关系,在不同的继承方式下,访问权限也是不同的,总结如下:

           若继承方式是public,基类成员在派生类中的访问权限保持不变,也就是说,基类中的成员访问权限,在派生类中仍然保持原来的访问权限;

           若继承方式是private,基类所有成员在派生类中的访问权限都会变为私有(private)权限;

           若继承方式是protected,基类的共有成员和保护成员在派生类中的访问权限都会变为保护(protected)权限,私有成员在派生类中的访问权限仍然是私有(private)权限。

           总结上述规则,可以如下表所示:

    展开全文
  • 从设计虚拟GIS数据模型应考虑的问题出发,提出一种全新的基于特征面向对象虚拟GIS数据模型构建思路,并详细分析了其对象的结构;最后介绍基于该数据模型的数据库构建过程和步骤,为后续原型系统的开发提供数据支持...
  • 面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法,是...

    OOP面向对象 ----三大特征 继承封装多态

      面向对象(Object Oriented,OO)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法,是计算机编程技术[1] 发展到一定阶段后的产物。 

    三大特性:继承,封装,多态

      封装:使用访问控制符可以将对象中不允许外部程序直接访问的重要属性隐藏在对象内部,这一过程叫封装。封装减少了大量的冗余代码,封装将复杂的功能封装起来,对外开放一个接口,将描述事物的数据和操作封装在一起,形成一个类;被封装的数据和操作只有通过提供的公共方法才能被外界访问(封装隐藏了对象的属性和实施细节),私有属性和方法是无法被访问的,表现了封装的隐藏性,增加数据的安全性。

      个人理解来说:  封装分两类,方法的封装和属性的封装,分别将类方法和类属性私有化,进而限制访问,注意!!并不是拒绝访问,而是限制访问 。

              方法私有化之后,在类外部无法使用,属性私有化之后,需要使用设置和读取私有属性的get/set的方法,外部才能使用

        然后啥叫私有方法私有属性呢?

          白话来说,在构造函数中,使用var生命的变量叫做私有属性,使用function声明的方法就叫做私有方法 (记住)私有属性和私有方法只在构造函数中有效啊,这点很重要啊 (你要是问我啥叫构造函数的话,emmmm自己百度好不好呀)

    /**
                 *  oop封装实现
                 * @author gongliying
                 *  @data 2019-06-10
                 */
                aaa(){
                    function Person(name){
                        this.name=name
                        var content = "这是私有属性"-------------------//私有属性
                        //使用get/set访问私有属性
                        this.setcontent = function(value){
                            content = value
                        }
                        this.getcontent = function(){
                            return content
                        }
                        //私有方法
                        function say(){
                            content = "这是私有方法里面的"
                            console.log(content)
                        }
                        say()   ------------------------------------------------  //在构造函数中可以调用私有方法
                    }
                    var gong = new Person("宫")
                    var zhang = new Person("張")
                    gong.age = 18    --------------------------------------- //追加宫的属性 年龄为18
                    console.log(gong.name)    -------------------------- //调用属性
                    console.log(gong.age)   ------------------------------//调用追加属性
                    // gong.say()      -----------------------------------------//报错 私有方法不会被调用
                    console.log(gong.content)      -----------------------//调用私有属性 为underfined
                    zhang.setcontent("这是显示之后的私有属性") ---//使用set/get 访问私有属性
                    console.log(zhang.getcontent())
                    console.log(zhang.content)  ---------------------------//调用私用属性 为underfined

                }

      结果如图:

        

     

      继承  被继承的类叫做父类,继承父类的类叫做子类,继承中子类将会获得父类的属性和方法,同时子类也可以定义自己的属性和方法,继承概念的实现方式有二类:实现继承与接口继承。实现继承是指直接使用 基类的属性和方法而无需额外编码的能力;接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力。

      js实现继承是通过 apply方法或者是通过prototype实现的,如果使用apply方法,子类的原型是子类,如果使用prototype,那么子类的原型也将继承父类。

      

    /**
     * 点击查询
     * @author gongliying
     * @date 2019-06-03
    */
    search(val) {
      function fatherClass(name,age){
            this.name = name;
            this.age = age;
            this.say = function(){
            console.log(" the say method of father class");
         }
      }
    
       function oneSon(name,age){
            fatherClass.apply(this,[name,age]);
       }
    
            var objOneSon = new oneSon("oneSon",20);
            console.log(objOneSon.name,'这是name');
            console.log(objOneSon.age,'这是age');
            objOneSon.say();
            //instanceof运算符用于测试构造函数的prototype属性是否出现在对象的原型链中的任何位置
            console.log(objOneSon instanceof fatherClass,'是否出现在父类');
            console.log(objOneSon instanceof oneSon,'是否出现在子类'); 
    },
    

      结果为         

     

     如果使用prototype方法

      以上方法不变

        

    //加入prototype
    oneSon.prototype = new fatherClass(); var objOneSon = new oneSon("oneSon",20); console.log(objOneSon.name,'这是name');
    console.log(objOneSon.age,'这是age'); objOneSon.say(); //instanceof运算符用于测试构造函数的prototype属性是否出现在对象的原型链中的任何位置 console.log(objOneSon instanceof fatherClass,'是否出现在父类'); console.log(objOneSon instanceof oneSon,'是否出现在子类');

      结果如右图       

      此外 还有一个就是咱么ES6上面的了   extends    他的实质呢  就是说先创造实例对象this,然后再 子类继承的时候修改父类this   重新写个例子~~ (夸赞的话请忽略~~~)

      

    /**
    			 * 	oopES6 extend 继承实现
    			 *  @author gongliying
    			 * 	@data 2019-06-10
    			 */
    		        class gong{
    					//构造函数
    					constructor(props) {
    						this.name = props.name
    					}
    					age() {
    						console.log(this.name + "今年18岁~~");
    					}
    				}
    				class zhang extends gong {
    					//构造函数
    					constructor(props) {
    					//调用实现父类的构造函数
    						super(props);
    						this.type = props.type;
    					}
    					character() {
    						console.log(this.name + "是个温柔的女孩子~~");
    					}
    				}
    				var Gong = new zhang({
    					name :'丽颖'
    				})
                      //结果为 Gong.age() --------------------//丽颖今年18岁~~ Gong.character() ---------------//丽颖是个温柔的女孩子~~

      多态     是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着,虽然针对不同对象的具体操作不同,但通过一个公共的类,它们(那些操作)可以通过相同的方式予以调用。子类的方法会覆盖父类的方法,即表现的就是多态性

      

    /**
    			 * 点击查询
    			 * @author gongliying
    			 * @date 2019-06-03
    			 */
    			search(val) {
                   function fatherClass(name,age){
                        this.name = name;
                        this.age = age;
                        this.say = function(){
                            console.log(" the say method of father class");
                        }
                    }
    
                    function anotherSon(name,age){
                        this.say = function(){
                            console.log("i am anotherSon");
                        }
                    }
    
                    anotherSon.prototype = new fatherClass();
    
                    function twoSon(name,age){
                        this.say = function(){
                            console.log("i am twoSon");
                        }
                    }
    
                    twoSon.prototype = new fatherClass();
    
                    function yes_or_no(cls){
                        if(cls instanceof fatherClass){
                            cls.say();
                        }
                    }
    
                    var objanotherSon = new anotherSon();
                    var objtwoSon = new twoSon();
                    yes_or_no(objanotherSon);
                    yes_or_no(objtwoSon);
    },
    

      结果为          即实现了类的多态

     

      多态的主要体现在重写和重载          但是何为重写重载呢?

         重写:子类定义了与父类相同的方法,并且有相同的参数类型和参数个数

         重载:具有不同参数列表的同名方法,参数的类型或者参数的个数不同,方法的返回值可以相同也可以不相同   

          我理解的重写和重载就是  --- 重写:  改变方法的实现方式,发生在继承类中,但是被重写的方法不能拥有更严格的权限即子类的访问权限>父类的访问权限        重载:好多种方式,就是说参数不同 但是发生在一个类中并且对权限没有要求

           (emmmmm重写重载这么直白的区别就不需要我说了把-_-  ~~)

       重写:

       子类继承父类时,将相同的方法重写

    /**
    			 * 	oop 多态重写实现
    			 *  @author gongliying
    			 * 	@data 2019-06-10
    			 */
    			aaa(){
    				class gong{
    					//构造函数
    					constructor(props) {
    					  this.name = props.name
    					}
    					age() {
    					  console.log(this.name + "今年18岁~~");
    					}
    				}
    				class zhang extends gong {
    					//构造函数
    					constructor(props) {
    					//调用实现父类的构造函数
    					  super(props);
    				       this.type = props.type;
    					}
    					age() {
    					  console.log(this.name + "是个温柔的女孩子~~");
    					}
    				}
    				var Gong = new zhang({
    					name :'丽颖'
    				})
    				Gong.age()  -----------------//丽颖是个温柔的女孩子~~
    
    			}
    

      

       重载:

        相同的方法,接收的参数类型不同,返回结果不同     但是    严格意义上说 JavaScript上并没有重载的概念,因为javaScript中的函数参数都保存在arguments对象中,重复定义相同名字的函数,后定义的会覆盖之前的。  但是我们可以模拟

        

    /**
    			 * 	oop 多态重载实现
    			 *  @author gongliying
    			 * 	@data 2019-06-10
    			 */
    			aaa(){
    				class gong{
    					constructor(content){
    						switch(typeof content){
    						case 'number':
    							console.log('数字')
    							break;
    						case 'string':
    							console.log('字符串')
    							break;
    						case 'boolean':
    							console.log('布尔')
    							break;
    						}
    					}
    				}
    				new gong(123)  -----------------//数字
    				new gong('liying')  ------------//字符串
    				new gong(false) ----------------//布尔
    			}
    

      

     模拟完毕~~~

    emmmmm,这是我目前的所有理解了  ,以后还有更生层次的理解会更新的,敬请期待哟~~~~

    写的不好多多见谅,欢迎评价~~~~中国特色社会主义式可爱~~~~

    转载于:https://www.cnblogs.com/gongliying/p/10988172.html

    展开全文
  • 面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法,是...

    面向对象三大特征及代码优化七大原则

      面向对象(Object Oriented,OO)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法,是计算机编程技术发展到一定阶段后的产物。

      一.面向对象的三大基本特性

      1.封装
      封装,就是把客观事物封装成抽象的类,并且类可以使自己的数据和方法只让可信的类或者对象操作,对不可信的则进行信息隐藏。一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部,某些代码或某些数据可以是私有的,不能被外界访问。通过这种方式,对象对内部数据提供了不同级别的保护,以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。
      2.继承
      继承,指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”,被继承的类称为“基类”、“父类”或“超类”。继承的过程,就是从一般到特殊的过程。要实现继承,可以通过 “继承”(Inheritance)和“组合”(Composition)来实现。继承概念的实现方式有二类:实现继承与接口继承(又称接口实现)。实现继承是指直接使用 基类的属性和方法而无需额外编码的能力;接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力。

    组合是has a的关系 
    继承是is a的关系
    为扩展而继承,为复用而组合

      3.多态
      多态,是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着,虽然针对不同对象的具体操作不同,但通过一个公共的类,它们(那些操作)可以通过相同的方式予以调用。

      二.OOP编程的七个基本原则

      1.单一职责原则SRP(Single Responsibility Principle)

      类的功能要单一,体积不要过于庞大。
         SRP是指一个类的功能要单一,不能包罗万象。如同一个人一样,分配的工作不能太多,否则一天到晚虽然忙忙碌碌的,但效率却高不起来。
      2.开放封闭原则OCP(Open-Close Principle)

      对扩展开放,对修改关闭。
         一个模块在扩展性方面应该是开放的,而在更改性方面应该是封闭的。比如:一个网络模块,原来只提供服务端功能,而现在要加入客户端功能,那么应当在不用修改服务端功能代码的前提下,就能够增加客户端功能的实现代码,这要求在设计之初,就应当将服务端和客户端分开,公共部分抽象出来。
      3.里式替换原则LSP(the Liskov Substitution Principle)

      父类出现的地方,子类都可以替换。
         子类应当可以替换父类并出现在父类能够出现的任何地方。比如:公司搞年度晚会,所有员工可以参加抽奖,那么不管是老员工还是新员工,也不管是总部员工还是外派员工,都应当可以参加抽奖,否则公司就不和谐了。
      4.依赖倒置原则DIP(the Dependency Inversion Principle)

      具体依赖抽象。面向对象、抽象编程,不要面向细节、过程编程。

    High level modules should not depend upon low level modules.Both should depend upon abstractions.
    Abstractions should not depend upon details.
    Details should depend upon abstracts.

       可以翻译为:

    • 高层模块不应该依赖低层模块,两者都应该依赖抽象
    • 抽象不应该依赖细节
    • 细节应该依赖抽象

      每一个逻辑的实现都是由颗粒原子逻辑组成的,颗粒原子逻辑就是低层模块,而颗粒原子逻辑组成的模块就是高层模块。在java语言中,抽象就是接口或抽象类,两都都是不能直接被实例化的,细节就是实现类,实现接口或继承抽象类而产生的类就是细节,两者都可以直接被实例化。

      依赖倒置原则在java语言中的表现是:

    • 模块间的依赖通过抽象发生,实现类之间不发生直接的依赖关系,其依赖关系是通过接口或抽象类产生的。
    • 接口或抽象类不依赖实现类
    • 实现类依赖接口或抽象类

      依赖倒置原则可以引申出OOD(Object-Oriented Design,面向对象设计)和OOP(Object-Oriented Programing,面向对象编程)。

      采用依赖倒置原则可以减少类间的耦合性,提高系统的稳定,降低并行开发引起的风险,提高代码的可读性和可维护性。  

    对象的依赖关系有三种方式来传递:
        ①构造函数传递依赖对象
        在类中通过构造函数声明依赖对象,按照依赖注入的说法,这种方式叫做构造函数注入。
        ②Setter方法传递依赖对象
        在类中通过Setter方法声明依赖关系,依照依赖注入的说法,这是Setter依赖注入。
        ③接口声明依赖
        在接口的方法中声明依赖对象,该方法也叫做接口注入。
    

       5.接口分离原则ISP(the Interface Segregation Principle)
      接口定义的标准尽可能单一,致力于对接口的多实现。接口规模不要臃肿。

      6.迪米特法则---最少知识原则。类与类之间尽量减少不必要的访问。降低耦合。

      7.合成复用原则。多用组合/聚合,少用继承,降低耦合度。

      最后,我们再谈下内聚与耦合。

      内聚标志一个模块内各个元素彼此结合的紧密程度,它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系,一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。
      耦合是软件结构中各模块之间相互连接的一种度量,耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合,高内聚。就是同一个模块内的各个元素之间要高度紧密,但是各个模块之间的相互依存度却要不那么紧密。
      内聚和耦合是密切相关的,同其他模块存在高耦合的模块意味着低内聚,而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时,应力争做到高内聚,低耦合。

      

      简单地说,软件工程中对象之间的耦合度就是对象之间的依赖性。指导使用和维护对象的主要问题是对象之间的多重依赖性。对象之间的耦合越高,维护成本越高。因此对象的设计应使类和构件之间的耦合最小。有软硬件之间的耦合,还有软件各模块之间的耦合。  

      耦合可以分为以下几种,它们之间的耦合度由高到低排列如下:

        内容耦合。当一个模块直接修改或操作另一个模块的数据时,或一个模块不通过正常入口而转入另一个模块时,这样的耦合被称为内容耦合。内容耦合是最高程度的耦合,应该避免使用之。
        公共耦合。两个或两个以上的模块共同引用一个全局数据项,这种耦合被称为公共耦合。在具有大量公共耦合的结构中,确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
        外部耦合。一组模块都访问同一全局简单变量而不是同一全局数据结构,而且不是通过参数表传递该全局变量的信息,则称之为外部耦合。
        控制耦合。一个模块通过接口向另一个模块传递一个控制信号,接受信号的模块根据信号值而进行适当的动作,这种耦合被称为控制耦合。
        标记耦合。若一个模块A通过接口向两个模块B和C传递一个公共参数,那么称模块B和C之间存在一个标记耦合。
        数据耦合。模块之间通过参数来传递数据,那么被称为数据耦合。数据耦合是最低的一种耦合形式,系统中一般都存在这种类型的耦合,因为为了完成一些有意义的功能,往往需要将某些模块的输出数据作为另一些模块的输入数据。
        非直接耦合。两个模块之间没有直接关系,它们之间的联系完全是通过主模块的控制和调用来实现的。 

      总的来说,耦合是影响软件复杂程度和设计质量的一个重要因素,在设计上我们应采用以下原则:

      如果模块间必须存在耦合,就尽量使用数据耦合,少用控制耦合,限制公共耦合的范围,尽量避免使用内容耦合。

    posted @ 2018-04-22 17:04 奔跑在梦想的道路上 阅读(...) 评论(...) 编辑 收藏
    展开全文
  • 对象关系数据库

    千次阅读 2014-05-30 11:23:53
    使用面向对象方法学...按照“第三代数据库系统宣言”的文章的思想,一个面向对象数据库系统(OODBS)必须满足两个条件: (1)支持统一核心的面向对象数据模型; (2)支持传统数据库系统所有的数据库特征。 也就是
  • 针对现有数据模型的不足,结合GIS数据模型的最新进展,在CAD、虚拟现实和仿真等领域得到...采用0racle0RDB管理模式实现其面向对象的虚拟GIS数据库,并依据该模型设计了Client/Server层次结构的分布式虚拟GIS原型系统
  • 面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法,是...
  • 面向对象

    2021-02-25 15:55:19
    面向对象的思想对软件开发相当重要,它的概念和应用已经超越了程序设计和软件开发,扩展到数据库系统、交互式页面、应用平台、人工智能等领域。面向对象是一种 对现实事物的理解和抽象的方法 面向对象的编程思想,...
  • 对象-关系数据库

    千次阅读 2006-03-03 10:00:00
    使用面向对象方法学可以定义...按照“第三代数据库系统宣言”的文章的思想,一个面向对象数据库系统(OODBS)必须满足两个条件:(1)支持统一核心的面向对象数据模型;(2)支持传统数据库系统所有的数据库特征。也就是
  • 0,什么是 “ 面向对象编程 ” ? 1,面向对象的基础实例 2,什么是封装?...面向对象的概念和应用已超越了程序设计和软件开发,扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络...
  • 数据库系统原理(1)

    2020-04-20 22:39:49
    第一章:数据库系统的基本概念 1.数据是数据库中存储的基本对象,数据的含义称为数据的语义 2.数据库是长期的储存在计算机中的有组织、可共享的大量数据集合 3.数据库的特征:数据按一定的数据模型组织、描述和存储...
  • 他的主要研究方向是数据库系统、时间数据库、概念建模、面向对象数据库、Wed建模和本体论数据库模型和语言、DBMS系统实现、检索技术等。  Shamkant B.Navathe 世界知名的数据库学者。现任佐治亚理工学院计算学院...
  • oracle 面向对象测试

    2012-01-12 11:06:56
    关系数据库在不断地发展时,许多数据库引入了面向对象的思想,这其中以Oracle为代表,Oracle9i就号称面向对象数据库。 自Oracle9i以来,Oracle就不再是单纯的关系数据库管理系统,它在关系数据库模型的基础上,添加...
  • Oracle面向对象编程OOP

    千次阅读 2014-01-04 16:57:03
    Oracle9i就号称面向对象数据库。Oracle的对象体系遵从面向对象思想的基本特征,许多概念同C++,JAVA中类似,具有继承,重载,多态等特征,但又有自己的特点。  下面详细介绍下Oracle面向对象编程。 1 面向对象类型...
  • PostgreSQL系统概述_PG数据库内核分析学习笔记 PG简介和发展历程 PG以一种先进的对象-关系数据库管理系统(ORDBMS), 它不仅支持关系数据库的各种功能, 而且还具备类, ...面向对象数据库系统(OODBS)支持定义和操作OODB...
  • 他的主要研究方向是数据库系统、时间数据库、概念建模、面向对象数据库、Wed建模和本体论数据库模型和语言、DBMS系统实现、检索技术等。  Shamkant B.Navathe 世界知名的数据库学者。现任佐治亚理工学院计算学院...
  • ( l )数据结构化数据库系统实现整体数据的结构化,这是数据库的主要特征之一,也是数 据库系统与文件系统的本质区别。解析注意这里的“整体’夕两个字。在数据库系统中,数 据不再针对某一个应用,而是面向全组织,...
  • 随着计算机技术的广泛应用,信息处理已经无处不在,而基于图像处理的目标检测和识别已成为计算机视觉领域的一个重要研究...本文以获取的图片及其特征数据为处理对象,开发一个面向图像及其特征的多信息管理系统的过程。
  • Oracle中的面向对象OOP

    2012-10-08 11:46:00
    关系数据库在不断地发展时,许多数据库引入了面向对象的思想,这其中以Oracle为代表,Oracle9i就号称面向对象数据库。 自Oracle9i以来,Oracle就不再是单纯的关系数据库管理系统,它在关系数据库模型的基础上,添加...
  • 数据模型是对现实世界数据特征的一种抽象,是用来描述数据、组织数据和对数据进行操作的,是数据库系统的核心与基础。 数据模型需要满足三个方面的要求:比较真实的模拟现实世界、容易为人所理解、便于在计算机中...
  • 面向对象的Oracle

    2008-01-22 13:45:00
    关系数据库在不断地发展时,许多数据库引入了面向对象的思想,这其中以Oracle为代表,Oracle9i就号称面向对象数据库。 自Oracle9i以来,Oracle就不再是单纯的关系数据库管理系统,它在关系数据库模型的基础上,添加...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 373
精华内容 149
关键字:

面向对象数据库系统特征