精华内容
下载资源
问答
  • 面向对象面向对象技术核心内容归纳总结
    千次阅读
    2019-12-01 14:46:06

    核心知识点

    1. 编译器和解释器的区别,java程序的执行过程,java为什么是跨平台的语言
    2. java基本数据类型,java中的运算符,Java中的流程控制语句
    3. 类的定义,类中属性的定义(会进行默认的初始化),类中方法的定义,方法中的局部变量(必须初始化)
    4. 对象的定义,通过点运算符访问对象的属性和方法
    5. 构造方法的定义,默认构造方法,使用new运算符调用构造方法
    6. 组合(在类中定义另外一个类的对象作为属性)
    7. 传值方法调用,传引用方法调用(类的对象作为参数)
    8. 包的定义,包的引入(import),信息隐藏,访问控制权限,Public private protected 缺省
    9. 方法重载,构造方法的重载
    10. this 关键字,使用this关键字调用类中其它构造方法
    11. 关联、多重性(一对一,一对多,多对多)、聚合、组合、集合类的使用(ArrayList,Vector,add方法,get方法)
    12. 一维数组的定义、初始化,二维数组的定义,对象数组的定义、初始化
    13. 匿名对象的使用
    14. 继承的定义,extends关键字的使用,面向对象代码的复用,子类自动继承父类中的属性和方法。
    15. 子类对象可以自动向父类对象进行类型转换,instanceof的使用
    16. 子类对父类构造方法的调用(隐式调用父类无参构造方法,使用s
    更多相关内容
  • 本书详细介绍了面向对象的分析与设计,全面探讨了面向对象概念、软件开发过程、UML和多层技术,通过一个贯穿全书的案例分析,对面向对象的软件开发过程和使用面向对象技术的编程过程进行了透彻的讨论。
  • 面向对象程序设计技术的现状及发展趋势;WORD文件,报告类
  • 本书针对Java 2平台标准版5.0详细介绍了如何使用Java语言进行面向对象编程 较早地把有关面向对象的内容贯穿其中使初学程序开发的读者们能够逐步体会并深刻理解对象技术的强大功能较早地引入事件的处理与GUI的使用等...
  • 面向对象程序设计概念

    千次阅读 2019-09-26 17:03:28
    面向对象设计范型的主要特征是:  程序=对象+消息   面向对象程序的基本元素是对象。面向对象程序的主要结构特点是:一、程序一般由类的定义和类的使用两部分组成;二、程序中的一切操作都是向对象发...

    一. 程序设计范型

      面向对象程序设计(object-oriented programming,OOP)是一种新的程序设计的范型。程序设计范型是设计程序的规范、模型和风格,它是一类程序设计语言的基础。
    面向对象设计范型的主要特征是:

     程序=对象+消息

      面向对象程序的基本元素是对象。面向对象程序的主要结构特点是:一、程序一般由类的定义和类的使用两部分组成;二、程序中的一切操作都是向对象发送消息来实现的,对象收到消息后,启动有关方法完成相应的操作。
      需要说明的是,某一种程序设计语言不一定与一种程序设计范型相对应。实际上具有两种或多种范型特征的程序设计语言,即混合型语言。例如,C++就不是纯粹的面向对象程序设计范型的语言,而是具有面向过程程序设计范型和面向对象设计范型的混合性设计语言。

    二. 面向对象程序设计的基本概念

    1. 对象
     现实中的对象,具有以下特征:

    1. 每个对象必须有一个名字以区别其他对象;
    2. 用属性来描述对象的耨些特征;
    3. 有一组操作,每一组操作决定对象的一种行为;
    4. 对象的行为可以分为两类:一类作用于自身的行为,另一类作用与其他对象的行为。

    2. 类
      类是一组具有相同属性和行为的对象的抽象。类与对象之间的关系是抽象与具体的关系。类是对多个对象进行综合抽象的结果。

    3. 消息与方法
      面向对象程序设计中,对象之间也需要联系,称为对象的交互。面向对象程序设计技术必须提供一种机制允许一个对象与另一个对象的交互。这种机制称为消息传递。
      对象所能实现的行为(操作),在程序设计方法中称为方法。它们是通过调用相应的函数来实现的,在C++语言中方法是通过成员函数来实现的。方法包括界面和方法体两部分。方法的界面给出了方法名和调用协议(相对于C++中的成员函数的函数名和参数表);方法体则是实现某种操作的一系列计算步骤,也就是一段程序(相对于C++中成员函数的函数体)。

    三. 面向对象程序设计的基本特征

    1. 抽象
      抽象是通过特定的实例(对象)抽取共同性质后形成概念的过程。面向对象程序设计中的抽象包括两个方面:数据抽象和代码抽象(或称为行为抽象)。前者描述某类对象的属性或状态,也就是此类对象区别于彼类对象的特征物理量:后者描述了某类对象的共同行为特征或具有的共同功能。对于一组具有相同属性和行为的对象,可以抽象成一种类型,在C++中,这种类型就称为类(class),类是对象的抽象,而对象是类的实例。
      抽象在系统分析、系统设计以及程序设计的发展中一直起着重要的作用。在面向对象程序设计方法中,对一个具体问题的抽象分析的结果,是通过类来描述和实现的。

    2. 封装
      在现实世界中,所谓封装就是把某个事物包围起来,使外界不知道该事物的具体内容。在面向对象程序设计中,封装是指把数据和实现操作的代码集中起来放在对象内部,并尽可能隐蔽对象的内部细节。对象好像是一个不透明的黑盒子.表示对象属性的数据和实现各个操作的代码都被封装在黑盒子里,从外面是看不见的,更不能从外面直接访问或修改这些数据及代码。使用一个对象的时候,只需知道它向外界提供的接口而无需知道它的数据结构细节和实现操作的算法。
      C++对象中的函数名就是对象的对外接口,外界可以通过函数名来调用这些函数来实现某些行为(功能)。封装的好处是可以将对象的使用者与设计者分开,大大降低了人们操作对象的复杂度。使用者不必知道对象行为实现的细节,只需要使用设计者提供的接口的功能即可自由地操作对象。封装的结果实际上隐藏了复杂性,并提供了代码重用性,从而减轻了开发软件系统的难度。
      封装是面向对象程序设计方法的一个重要特性,封装具有两方面的含义:一是将有的数据和操作代码封装在一个对象中,各个对象相对独立、互不干扰;二是将对象中某此据与操作代码对外隐蔽,即隐蔽其内部细节,只留下少量接口,以便与外界联系,接收外界消息,这种对外界隐蔽的做法称为信息隐蔽。信息隐蔽有利于数据安全,防止无关人员访和修改数据。

    3. 继承
      继承是面向对象软件技术当中的一个概念。如果一个类别A“继承自”另一个类别B,就把这个A称为“B的子类别”,而把B称为“A的父类别”也可以称“B是A的超类”。在令子类别继承父类别的同时,可以重新定义某些属性,并重写某些方法,即覆盖父类别的原有属性和方法,使其获得与父类别不同的功能。另外,为子类别追加新的属性和方法也是常见的做法。 从继承源上分,继承又分为单继承和多继承。

    4. 多态
      面向对象系统的多态性是指不同的对象收到相同的消息时执行不同的操作。
      C++语言支持两种多态性即编译时的多 态性和运行时的多态性。 编译时的多态性是通过函数重载(包括运算符重载)来实现的,运行时的多态性是通过虚函数来实现的。
      多态性增强了软件的灵活性和重用性,为软件的开发与维护提供了极大的便利。尤其是采用了虚函数和动态联编机制后,允许用户以更为明确、易懂的方式建立通用的软件。

    展开全文
  • 面向对象程序设计

    千次阅读 2020-12-09 15:37:28
    一、面向对象程序设计的基本概念 1.面向对象的基本思想 (1)客观事物是由对象组成的,对象是在原事物基础上抽象的结果。 (2)对象是由属性和操作组成的,其属性反映了对象的数据信息特征,而操作则用来定义改变对象...

    之前复习面向对象的时候整理的,丢出来一起分享一下。因为复习得很赶,只是大致的整理,且大部分图片来自老师的ppt,可能不是很准确。如果要详细了解其中的某个知识点请另外搜索。
    但是老师不讲武德啊,明明提纲给了不按提纲考,还从开卷变成闭卷。大意了,当时就不应该报啊。

    一、面向对象程序设计的基本概念

    1.面向对象的基本思想

    (1)客观事物是由对象组成的,对象是在原事物基础上抽象的结果。
    (2)对象是由属性和操作组成的,其属性反映了对象的数据信息特征,而操作则用来定义改变对象属性状态的各种操作方式。
    (3)对象之间的联系通过消息传递机制来实现。
    (4)对象可以按其属性来归类。
    (5)对象具有封装的特性,可达到软件复用的目的。
    Ps:面向对象的三大特性是"封装、“继承”、“多态”
    五大原则是"单一职责原则"
    “开放封闭原则”:对扩展是开放的,对修改是封闭的
    “里氏替换原则”:子类应当可以替换父类,并能出现在父类能出现的任何位置上
    “依赖倒置原则”:抽象不能依赖于具体,具体应该依赖于抽象
    “接口分离原则”:使用多个专门的接口,而不使用单一的总接口,即类不应该依赖那些它不需要的接口

    2.面向对象方法与面向过程方法的区别

    1.面向过程方法首先关心的是功能,强调以模块(即过程)为中心,采用模块化、自顶向下、逐步求精设计过程,系统是实现模块功能的函数和过程的集合。
    2.面向对象方法是一种运用对象、类、继承、聚合、关联、消息、封装等概念和原则来构造软件系统的开发方法。
    3.面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。
    4.面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。

    3.类和对象

    类(Class)是面向对象的基础。
    对象(Object)是具有明确语义边界并封装了状态和行为的实体,由一组属性和作用在这组属性上的一组操作构成,是构成软件的一个基本单位。
    类是对具有相同属性和操作的一组对象的统一抽象描述。
    对象是它所属的类的实例。

    4.类和类之间的关系

    类和类之间的关系主要有继承、实现、依赖、关联、聚合和组合、(细化)。
    继承和实现:子类和父类
    依赖:A使用B
    关联:强依赖\引用关系,类A中的某个属性的类型是类B
    聚合:聚合关系表示的是一种整体和部分的关系,聚合是一种较弱的关联关系,部分与整体可相互独立存在。
    组合:也表示一种整体和部分的关系。组合是一种较强的关联关系,部分与整体“共存亡”。
    实现:类指向接口。

    5.类的成员

    就是类里面的所有东西,包括成员变量和成员函数

    6.对象的生命周期

    构造函数到析构函数

    7.可见性(横着记)

    在这里插入图片描述

    8.继承
    继承的本质就是原型链
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    9. 消息通信

    对象只能通过消息进行通信,而不允许在对象之外直接地访问它内部的属性,这是由封装原则引起的。
    消息必须直接发给特定的对象,消息中包含所请求服务的必要信息,且遵守所规定的通信规格说明。一条消息的规格说明至少包括:消息名、入口参数、可能返回的参数。一个对象可以是消息的接受者、发送者和参数。

    10.抽象(定义以及抽象层次)

    抽象是指从事务中舍弃个别的、非本质的特征,而抽取共同的、本质特征的思维方式。在面向对象方法中、对象是对现实世界中事务的抽象,类是对对象的抽象,一般类是对特殊类的抽象。

    11.多态性

    多态性是指一般类和特殊类可以有相同的属性或操作,但这些属性或操作,但这些属性和操作具有不同的含义,即具有不同的数据类型或表现出不同的行为。针对同一个消息,不同的对象响应所做出的行为是不同的。

    二、UML

    作用+画法 用例图、类图、序列图、活动图、状态图
    在这里插入图片描述

    1.类图:

    定义:描述了系统中各类对象以及它们之间的静态关系。
    在这里插入图片描述

    作用:
    吴小竹:显示了信息的结构,同时描述了系统的行为。是定义其他图的基础
    1.描述了系统的类的集合,类的属性和类之间的关系,可以简化人们对系统的理解。
    2.类图为系统分析和设计阶段的重要产物,是系统编码和测试的重要模型。
    3.作为最常用的UML图,显示出类、接口以及它们之间的静态结构和关系。
    4.类图图示了所构建系统的所有实体、实体的内部结构以及实体之间的关系。
    5.它是构建其他设计模型的基础,也是面向对象编程的起点和依据。

    2.用例图:

    定义:一幅由参与者、用况以及这些元素之间的关系组成的图。
    主要的作用:(1)描述了待开发系统的功能需求;(2)将系统看作黑盒,从外部执行者的角度来理解系统;(3)驱动了需求分析之后各阶段的开发工作,不仅在开发过程中保证了系统所有功能的实现,而且被用于验证和检测所开发的系统,从而影响到开发工作的各个阶段和 UML 的各个模型。

    3.序列图(顺序图):

    定义:是一种详细描述对象之间以及对象与参与者之间交互的图,由一组相互协作的对象或参与者实例以及它们之间发送的消息组成,强调消息之间的顺序。
    作用:1.把用例表达的需求,转化为进一步、更加正式层次的精细表达。2.用例常常被细化为一个或者更多的序列图。同时序列图更有效地描述如何分配各个类的职责以及各类具有相应职责的原因。
    序列图是由对象、生命线、激活、消息、分支与从属流等元素构成的
    生命线(Lifeline)是一条垂直的虚线,用来表示序列图中的对象在一段时间内的存在激活。
    激活(Activation)表示一个对象直接或通过从属操作完成操作的过程。在UML图中通过一个窄长的矩形来表示,矩形的高度表示对象存在的过程。
    在这里插入图片描述

    4.活动图:

    定义:是描述动作、动作的执行顺序以及动作的输入与输出的图,由动作结点和边组成
    动作:是可执行的基本功能单元,用以描述系统中的状态转换或活动,是原子性的和实时的。
    活动:是一组相互协作的动作构成的行为单元,在执行中可被事务中断。
    作用: (1)描述复杂过程的算法。(2)活动图对用例描述尤其有用,它可建模用例的工作流,显示用例内部和用例之间的路径。它可以说明用例的实例是如何执行动作以及如何改变对象状态。(3)活动图对理解业务处理过程十分有用。活动图可以画出工作流用以描述业务,有利于与领域专家进行交流。(4)描述一个操作执行过程中所完成的工作。说明角色、工作流、组织和对象是如何工作的。发送信号接收信号
    在这里插入图片描述

    5.状态图:

    定义:描述了一个对象在其生命周期内因响应事件所经历的状态序列以及这些事件所做出的反应。主要由状态和状态间的转移构成。
    事件的定义:指时间上和空间上可以定位并具有实际意义、值得注意的所发生的事情。
    UML中把事件分为
    信号事件:一个对象对一个信号实例的接受,特征标记放在由它触发的转移上。
    调用事件:对操作的调用的接受,导致一个调用事件,由接受事件的对象实现事件。
    改变事件:用布尔表达式描述的指派条件变为真。
    状态的定义:对象在其生命周期内满足特定条件,进行特定活动或等待特定事件的状况。
    在这里插入图片描述

    三、面向对象设计方法(具体不懂的可以去菜鸟教程看)

    要解决的问题、结构(uml类图)、优缺点
    开-闭原则:要求一个系统的设计能够允许系统在无需修改的情况下,扩展其功能。

    简单工厂

    由一个工厂对象决定创建出哪一种产品类的实例。
    解决的问题:
    专门负责将大量有共同接口的类实例化。
    结构:
    在这里插入图片描述

    优点:
    1.客户端则可以免除直接创建产品对象的责任,而仅仅负责“消费”产品。
    2.对于消费者角色来说,任何时候需要某种产品,只需要向工厂角色(下订单)请求即可,而无需知道产品创建细节。
    3.实现了客户端类与产品类的解耦。
    缺点:对“开-闭”原则的支持不够,因为如果有新的产品加入到系统中去,就需要修改工厂类,将必要的逻辑加入到工厂类中。

    &工厂方法

    工厂方法模式将定义一个创建产品对象的工厂接口,将实际创建功能放到具体工厂子类中。

    解决的问题:

    对简单工厂模式加以改进,使得新增产品时依旧符合开放-封闭原则。

    类图:

    在这里插入图片描述

    Creator:工厂 ConcreteCreator:具体工厂 Product:产品 ConcreteCreator:抽象产品

    序列图:

    在这里插入图片描述

    工厂模式和简单工厂模式的区别:

    工厂方法模式的核心是一个抽象工厂类,而简单工厂模式把核心放在一个具体类上。
    工厂方法模式可以允许很多具体工厂类从抽象工厂类中将创建行为继承下来,从而可以成为多个简单工厂模式的综合,进而推广了简单工厂模式。
    工厂方法模式退化后可以变得很像简单工厂模式。如果确定一个系统只需要一个具体工厂类,把抽象工厂类合并到具体的工厂类中去。将工厂方法改成为静态方法,这时候就得到了简单工厂模式。

    优点:

    如果系统需要加入一个新的产品,那么所需要的就是向系统中加入一个这个产品类以及它所对应的工厂类。没有必要修改客户端,也没有必要修改抽象工厂角色或者其他已有的具体工厂角色。对于增加新的产品类而言,这个系统完全支持“开-闭”原则。

    &单例模式

    用法即优点:

    单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

    解决的问题:

    用于资源管理器对多个设备的管理。在一个系统要求一个类只有一个实例时才应当使用单例模式。反过来说,如果一个类可以有几个实例共存,那么就没有必要使用单例类。

    类图:

    在这里插入图片描述

    饿汉单例:

    public class EagerSingleton
    {
    private static final EagerSingleton m_instance =new EagerSingleton();
    //私有的默认构造子
    private EagerSingleton() { }
    //静态工厂方法
    public static EagerSingleton getInstance()
    {
    return m_instance;//对方调用时实例化
    }
    }
    

    类图:
    在这里插入图片描述

    懒汉式单例:

    与饿汉式单例类相同之处是,类的构造函数是私有的。与饿汉式单例类不同的是,懒汉式单例类在第一次被引用时将自己实例化。
    类图:
    在这里插入图片描述

    package com.javapatterns.singleton.demos;
    public class LazySingleton
    {
       private static LazySingleton  m_instance = null;
    //私有的默认构造子,保证外界无法直接实例化
       private LazySingleton() { }
    //静态工厂方法,返还此类的惟一实例
       synchronized public static LazySingleton getInstance()
       {
          if (m_instance == null)//第一次引用就实例化
          {
             m_instance = new LazySingleton();
          }
          return m_instance;
       }
    }
    

    &克隆模式(原型模式)

    通过给出一个原型对象来指明所要创建的对象类型,然后用复制这个原型对象的办法创建出更多的同类型对象。

    类图:

    在这里插入图片描述

    public class Client
    {
       private Prototype prototype;
       public void operation(Prototype example)
       {
          Prototype p=(Prototype)example.clone();
       }
    }
    抽象原型角色声明了一个clone()方法
    pubilc interface Prototype  extends Cloneable
    {   
       Object clone();
    }
    具体原型角色实现clone()方法
    public class ConcretePrototype implements Prototype/** 克隆方法*/
    {   public Object clone()
       {try 
            {  return new ConcretePrototype(); }
            catch( CloneNotSupportedException e)
            {  return null; }
       }
    }
    

    在这里插入图片描述

    客户端(Client)角色:向原型管理器提出存储或提取对象的请求。
    抽象原型(Prototype)角色:这是一个抽象角色,通常由一个接口或抽象类实现。此角色给出所有的具体原型类所需的接口。
    具体原型(Concrete Prototype)角色:被复制的对象。此角色需要实现抽象的原型角色所要求的接口。
    原型管理器(Prototype Manager)角色:管理记录每一个被创建的对象。
    优点:1.简化了对象的创建过程。2.在有大对象或多个对象的复制时,可提高系统性能。
    缺点:1.每个类必须额外增加一个克隆方法。2.深复制的实现较复杂。

    &适配器模式

    分为类的适配器模式(类的结构模式)和对象的适配器模式(对象的结构模式)

    需要用到的情况:

    (1)系统需要使用现有的类,而此类的接口不符合系统的需要。
    (2)想要建立一个可以重复使用的类.用于一些彼此之间没有太大关联的一些类,包括一些可能在将来引进的类一起工作,这些源类不一定有很复杂的接口。

    1.类的适配器模式:

    把一个类的接口变换成客户端所需要的另一种接口,从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。
    被适配的类的API转换成为目标类的API,其静态结构图如下图所示。

    结构图:

    在这里插入图片描述

    目标(Target)角色:这就是所期待得到的接口。
    源(Adaptee)角色:现有需要适配的接口。
    适配器(Adapter)角色:适配器类是本模式的核心,把源接口转换成目标接口。不可以是接口,而必须是具体类。

    public interface Target
    {
         void sampleOperation1();  //源类的方法
         void sampleOperation2();  //源类没有的方法
    } 
    public class Adaptee
    {
        public void sampleOperation1() { }
    }
    public class Adapter extends Adaptee implements Target
    {
        /** 由于源类没有方法sampleOperation2,因此适配器类补上这个方法 */
        public void sampleOperation2()
        {
            // Write your code here
        }
    }
    

    2.对象的适配器模式

    对象的适配器模式不是使用继承关系连接到adaptee类,而是使用委派关系连接到Adaptee类。

    结构:

    在这里插入图片描述

    Adapter的源代码如下:

    public class Adapter implements Target
    {    private Adaptee adaptee;
        public Adapter(Adaptee adaptee)
        {      super();
                this.adaptee = adaptee;
        }
        public void sampleOperation1()
        {        adaptee.sampleOperation1();
        }
        public void sampleOperation2()
        {        // Write your code here
        }
    }
    

    &合成模式(对象的结构模式)

    1.合成模式将对象组织到树结构中,可以用来描述整体与部分的关系。
    2.合成模式可以使客户端将整体对象与部分对象同等看待。

    需要用到的情况:

    (1)需要描述对象的部分和整体的等级结构
    (2)需要客户端忽略掉整体对象和部分对象的区别。
    抽象构件(Component)角色:这是一个抽象角色,给参加组合的对象规定一个接口。这个角色给出共有的接口及其默认行为。
    树叶构件(Leaf)角色:代表参加组合的树叶对象。没有下级的子对象。定义出参加组合的原始对象的行为。
    树枝构件(Composite)角色:代表参加组合的所有包含子对象的对象,并给出树枝构件对象的行为。

    两种形式

    1.透明方式
    透明式的合成模式要求所有的具体构件类,不论是树枝还是树叶,均符合一个固定的接口。
    在这里插入图片描述

    优点:所有的构件类都有相同的接口 缺点:不够安全
    2.安全方式
    安全式的合成模式要求管理聚集的方法只出现在树枝构件类中,而不出现在树叶构件类中。
    在这里插入图片描述

    优点:很安全 缺点:不够透明,树叶类和合成类将具有不同的接口
    eg:安全模式

     public abstract class Graphics
    {
        public abstract void draw();
    }
    public class Picture extends Graphics
    {
       private Vector list=new Vector(10);
       public void draw()
       {
          for (int i=0;i< list.size();i++)
    {
             Graphics g=(Graphics)list.get(i);
             g.draw();
          }
       }
    public void add(Graphics g)
    {
          list.add(g);
        }
       public void remove(Graphics g)
    {/*删除一个子构件 */
          list.remove(g);
       }
       public void getChild(int i)
    {/* 返还一个子构件 */
          return (Graphics)list.get(i);
       }
    }
    public class Line extends Graphics
    {
    public void draw()
    {
          //write your code 
        }
    }
    

    在这里插入图片描述

    透明模式

    abstract public class Graphics
    {
       public abstract void draw();
       public void add(Graphics g);/* 聚集管理方法,增加一个子构件 */
       public void remove(Graphics g);/* 聚集管理方法,删除一个子构件 */
       public Graphics getChild(int i);/* 返还一个子构件 */
    }
    package com.javapatterns.composite.drawingtransparent;
    import java.util.Vector;
    public class Picture extends Graphics
    {
       private Vector list=new Vector(10);
       public void draw()
       {
          for (int i=0;i< list.size();i++)
          {
             Graphics g=(Graphics)list.get(i);
             g.draw();
          }
       }
       public void add(Graphics g){
          list.add(g);
       }
       public void remove(Graphics g){
          list.remove(g);
       }
       public Graphics getChild(int i){
          return (Graphics)list.get(i);
       }
    }
    public class Line extends Graphics
    {
        public void draw(){//do nothing }
       public void add(Graphics g){//do nothing }
       public void remove(Graphics g){//do nothing }
       public Graphics getChild(int i){//do nothing }
    }
    

    在这里插入图片描述

    &代理模式(对象的结构模式)

    代理(Proxy)模式给某一个对象提供一个代理,并由代理对象控制对原对象的引用
    在这里插入图片描述

    抽象主体角色(Subject):声明了真实主体和代理主体的共同接口
    代理主体(Proxy)角色:内部含有对真实主体的引用;供一个与真实主体角色相同的接口;负责在需要的时候创建真实主体对象(和删除真实主体对象),在将客户端调用传递给真实的主体之前或之后,都要执行某个操作
    真实主体角色(RealSubject)角色:定义了代理角色所代表的真实对象。

    Package com.javapatterns.proxy;
    Abstract public class Subject
    {
          abctract public void request();//抽象请求方法
    }
    Public class RealSubject extends Subject
    { 
       public RealSubject(){}
       public void request(){//具体请求方法}
    }
    Public class ProxySubject extends Subject
    {
       private RealSubject realSubject;
       public ProxySubject(){}
       public void request()//实现请求方法
       {  preRequest();//请求先先进行的操作
          if (realSubject==null)
          	realSubject=new RealSubject(); 
          realSubject.request();
          postRequest();//请求后进行的操作
       }
      private void preRequest()//请求前的操作
       { 
            //something you want to do before requesting
       }
       private void postRequest()//请求后的操作
       {
             //something you want to do before requesting 
       }
    }
    

    &装饰模式/包装模式(对象的结构模式)

    以对客户端透明的方式扩展对象的功能。是继承关系的一种替代方案。
    在这里插入图片描述

    抽象构件(Component)角色:给出一个接口,以规范准备接收附加责任(扩展功能)的对象。
    具体构件(Concrete Component)角色:定义一个准备接收附加责任的类。
    装饰(Decorator)角色:持有一个构件的实例,并定义与抽象构件接口一致的接口。
    具体装饰(Concrete Decorator)角色:负责给构件对象“贴上”附加的责任。

    Public interface Component
    {
          void sampleOperation();//某业务逻辑方法
    }
    Public class Decorator  implements Component
    {
    	private Component component;
     	public Decorator(Component component)
    	{
    		this.component = component;
    	}
      	public void sampleOperation()/** 业务方法,委派给构件*/
    	{
    		component.sampleOperation();
    	}
    }
    Public class ConcreteComponent implements Component
    {
    	public ConcreteComponent()  {//Write your code here}
    	public void sampleOperation()  {//Write your code here}
    }
    Public class ConcreteDecorator  extends Decorator
    {
    	public void sampleOperation()//进一步增强功能
    	{	super.sampleOperation();	}
    }
    

    优点:

    1.可以提供比继承更多的灵活性.
    2.通过使用不同的具体装饰类以及这些装饰类的排列组合,可以创造出很多不同的行为的组合.

    缺点:

    1.产生出较多的对象;
    2.比继承更易出错;

    &观察者模式

    一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时,会通知所有观察者对象,使它们能够自动更新自己。
    解决的问题:一个对象状态改变给其他对象通知的问题,而且要考虑到易用和低耦合,保证高度的协作。
    在这里插入图片描述

    抽象主题(Subject)角色:把所有对观察者对象的引用保存在一个聚集里;提供接口,可以增加和删除观察者对象。
    抽象观察者(Observer)角色:为所有的具体观察者定义一个接口,在得到主题的通知时更新自己。这个接口叫做更新接口。
    具体主题(Concrete Subject)角色:将有关状态存入具体观察者对象;在具体主题的内部状态改变时,给所有登记过的观察者发出通知。负责实现对观察者引用的聚集的管理方法。
    具体观察者(Concrete Observer)角色:实现抽象观察者角色所要求的更新接口,以便使本身的状态与主题 的状态相协调。

    所有具体主题管理聚集的方法都相同,因此可以将它移到抽象主题中.
    第二种实现方案和第一种实现方案的主要区别就是代表存储观察者对象的聚集连线是从抽象主题到抽象观察者.
    在这里插入图片描述

    优点

    1.观察者模式在被观察者和观察者之间建立一个抽象的耦合。2.观察者模式支持广播通信。
    缺点
    1.如果一个被观察者有很多的观察者,将所有的观察者都通知到会花费很多时间。
    2.如果在被观察者之间有循环依赖,被观察者会触发它们之间进行循环调用,导致系统崩溃。
    3.虽然观察者随时知道所观察的对象发生了变化,但是观察者模式没有相应的机制使观察者知道所观察的对象是怎样发生变化的。

    &命令模式/行动模式/事物模式

    请求以命令的形式包裹在对象中,并传给调用对象。调用对象寻找可以处理该命令的合适的对象,并把该命令传给相应的对象,该对象执行命令。请求的一方和接收的一方独立开来。
    在这里插入图片描述

    客户端(Client)角色:创建了一个具体命令(ConcreteCommand)对象并确定其接收者。
    命令角色(Command):声明了一个给所有具体命令类的抽象接口。
    具体命令(ConcreteCommand)角色:定义一个接收者和行为之间的弱耦合;实现execute()方法,负责调用接收者的相应操作。execute()方法通常叫做执行方法。
    请求者(Invoker)角色:负责发出一个请求。
    接收者(Receiver)角色:任何一个类都可以成为接收者;实施和执行请求的方法叫做行动方法。

    public class Invoker
    {   private Command command;
        public Invoker(Command command)
        { 
            this.command=command;
         }
       /* 行动方法 */
       public void action()
       {
          command.execute();
       }
    }
    
    public class Receiver
    {
       public Receiver()
       {   }
       public void action()
       {
          System.out.println(“Action has been taken.);
       }
    }
    
    
    
    
    
    public interface Command
    {   void execute(); }
    
    Public class ConcreteCommand implements Command
    {
       private Receiver receiver;
       public ConcreteCommand(Receiver receiver)
       {
          this.receiver=receiver;
       }
       public void execute()
       {
          receiver.action();//调用接受者的接受方法
       }
    }
    
    public class Client
    {   public static void main(String[] args)
        {   Receiver receiver=new Receiver();
            Command command=new ConcreteCommand(receiver);
            Invoker invoker=new Invoker(command);
            invoker.action();//发出请求
        }
    }
    

    在这里插入图片描述

    优点:

    1.命令模式把请求一个操作的对象与知道怎么执行一个操作的对象分割开。
    2.命令类与其他任何别的类一样,可以修改和扩展。
    3.可以把命令对象聚合在一起,合成为合成命令。
    4.由于加进新的具体命令类不影响其他的类,因此增加新的具体命令类很容易。

    缺点:

    1使用命令模式会导致某些系统有过多的具体命令类。

    &模板方法模式

    模板方法模式是所有模式中最为常见的几个模式之一。模板方法模式是基于继承的代码复用的基本技术,模板方法模式的结构和用法也是面向对象设计的核心。
    模板方法模式为设计抽象类和实现具体子类的设计师之间的协作提供了可能:一个设计师负责给出一个算法的轮廓和骨架,另一些设计师则负责给出这个算法的各个逻辑步骤。
    解决的问题:一些方法通用,却在每一个子类都重新写了这一方法。
    在这里插入图片描述

    意图:

    定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

    主要解决:

    一些方法通用,却在每一个子类都重新写了这一方法。

    优点:

    1、封装不变部分,扩展可变部分。
    2、提取公共代码,便于维护。
    3、行为由父类控制,子类实现。(即好莱坞原则)

    缺点:

    每一个不同的实现都需要一个子类来实现,导致类的个数增加,使得系统更加庞大。
    在这里插入图片描述

    策略模式

    针对一组算法,将每一个算法封装到具有共同接口的独立的类中,从而使得他们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。
    何时使用:
    1.如果在一个系统里面有许多类,它们之间的区别仅在于它们的行为。
    2.一个系统需要动态地在几种算法中选择一种。
    3.一个系统的算法使用的数据不可以让客户端知道。
    4.如果一个对象有很多的行为,
    在这里插入图片描述
    在这里插入图片描述

    环境(Context)角色:表示策略的使用环境,它持有一个Strategy对象的引用。
    抽象策略(Strategy)角色:这是一个抽象角色,通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
    具体策略(ConcreteStrategy)角色:包装了相关的算法或行为。

    优点:

    1、算法可以自由切换。
    2、避免使用多重条件判断。
    3、扩展性良好。

    缺点:

    1、策略类会增多。
    2、所有策略类都需要对外暴露。
    (ppt无)
    java语法:
    继承:extends class A extends B接口:implements eg: class A implements B
    浅复制:
    被复制对象的所有变量都含有与原对象相同的值,而所有的对其它对象的引用都仍然指向原来的对象。浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。
    深复制:
    被复制对象的所有变量都含有与原对象相同的值,除去那些引用其它对象的变量。那些引用其它对象的变量将指向被复制过的新对象。深复制把要复制的对象所引用的对象都复制了一遍,而这种对被引用到的对象的复制叫做间接复制。

    展开全文
  • 软件工程——面向对象设计详解

    千次阅读 2021-02-23 14:42:48
    软件工程——面向对象设计详解面向对象设计过程面向对象设计准则体系结构模块及依赖性接口及其依赖性包及其依赖性构件及其依赖性人机交互部分的设计用户界面设计步骤界面设计目标界面设计工作流 面向对象设计过程 ...

    面向对象设计过程

    • (1)建立系统环境模型。在设计的初始阶段,系统设计师用系统环境图对软件与外部实体交互的方式进行建模。下图给出了系统环境图的一般的结构。
    • List item
    • (2) 设计系统体系结构。体系结构设计可以自底向上进行,如将关系紧密的对象组织成子系统或层;也可以自顶向下进行,尤其是使用设计模式或遗产系统时,会从子系统的划分入手。
    • (3) 对各个子系统进行设计。对于面向对象的系统,典型的子系统有问题域子系统、人机交互子系统和任务管理子系统。
    • (4) 对象设计及优化。对象设计以问题领域的对象设计为核心,其结果是一个详细的对象模型。对象设计过程包括使用模式设计对象、接口规格说明、对象模型重构、对象模型优化4组活动。

    面向对象设计准则

    • 1.模块化
      传统的面向过程方法中的模块通常是函数、过程及子程序等,而面向对象方法中的模块则是类、对象、接口、构件等。
      在面向过程的方法中,数据及在数据上的处理是分离的;而在面向对象方法中,数据及其上的处理是封装在一起的,具有更好的独立性,也能够更好地支持复用。
    • 2.抽象
      面向对象方法不仅支持过程抽象,而且支持数据抽象。类实际上就是一种抽象数据类型。可以将类的抽象分为规格说明抽象及参数化抽象。
      类对外开放的公共接口构成了类的规格说明,即协议。这种接口规定了外部可以使用的服务,使用者无需知道这些服务的具体实现算法。通常将这类抽象称为规格说明抽象。
      参数化抽象是指当描述类的规格说明时并不具体指定所要操作的数据类型,而是将数据类型作为参数。
    • 3.信息隐藏
      在面向对象方法中,信息隐藏通过对象的封装性实现。对于类的用户来说,属性的表示方法和操作的实现算法都应该是隐藏的。
    • 4.弱耦合
      耦合是指一个软件结构内不同模块之间互连的紧密程度。在面向对象方法中,对象是最基本的模块,因此,耦合主要指不同对象之间相互关联的紧密程度。
    • 5.强内聚
      内聚衡量一个模块内各个元素彼此结合的紧密程度。在面向对象设计中存在以下3种内聚:
      (1) 服务内聚:一个服务应该完成一个且仅完成一个功能。
      (2) 类内聚:设计类的原则是,一个类应该只有一个用途,它的属性和服务应该是高内聚的。类的属性和服务应该全都是完成该类对象的任务所必需的,其中不包含无用的属性或服务。如果某个类有多个用途,通常应该把它分解成多个专用的类。
      (3) 一般—特殊内聚:设计出的一般—特殊结构,应该符合多数人的概念,更准确地说,这种结构应该是对相应的领域知识的正确抽取。
    • 6.可重用
      软件重用是提高软件开发生产率和目标系统质量的重要途径。
      重用基本上从设计阶段开始。重用有两方面的含义:
      一是尽量使用已有的类(包括开发环境提供的类库,及以往开发类似系统时创建的类),
      二是如果确实需要创建新类,则在设计这些新类的协议时,应该考虑将来的可重复使用性。

    体系结构模块及依赖性

    • 体系结构设计描述了建立计算机系统所需的数据结构和程序构件。一个好的体系结构设计要求软件模块的分层及编程标准的执行。
    • 在面向对象软件中,常见的软件模块有类、接口、包和构件。
    • (1)类
      在面向对象的程序设计中,类和接口是程序的基本组成单元。
      一个典型程序需要界面类专门负责表示用户界面信息,需要数据库类负责与数据库进行交互,需要有业务逻辑类负责算法计算等。
      在计算机程序中,要设计和实现的所有类都具有唯一的名字,在不同的阶段或从不同的角度可以将它们称为设计类、实现类、系统类、应用类等。
    • (2)继承依赖性.继承是一种在父类和子类之间共享属性和行为的方式,所以运行时可以用一个子类对象代替其父类对象。程序中凡是使用父类对象的地方,都可以用子类对象来代替。
    • 多态继承
      根据为请求提供服务的对象不同可以得到不同的行为,这种现象称为多态。多态并不是伴随着继承而出现。如果在子类中不覆盖父类中的任何方法,就不会产生多态行为。
      继承会带来类和方法之间的依赖性。继承带来的依赖性有编译时继承依赖性和运行时继承依赖性。

    接口及其依赖性

    • 接口是不可直接实例化的特性集合的声明,即其对象不能直接实例化,需要通过类来实现,实现接口的类需要实现接口中声明的方法。接口中不仅可以声明操作,还可以声明属性。

    • 由于允许在接口中存在属性,因此,在接口之间或者接口和类之间可能会产生关联。用另一个接口或类作为属性的类型可以表示关联。

    • 一个类只能有一个直接父类,但是却可以实现多个接口。

    • **实现依赖性:**一个类可以实现多个接口,由类实现的接口集合称为该类的供给接口。一个类和该类实现的接口
      之间的依赖性称为实现依赖性。

    • 使用依赖性 一个接口可以为其他类或接口提供服务,同时也可能需要其他接口的服务。一个接口所需要的其他接口所提供的服务称为这个类的需求接口。需求接口详细说明一个类或接口需要的服务,从而可以为其客户提供服务,通过类(接口)和它所需接口之间的依赖关系来说明需求接口,这称为使用依赖性。

    包及其依赖性

    • 包(package)又可称为层或子系统,是表示组织类的一种方式,用于划分应用程序的逻辑模型。包是高度相关的类的聚合,这些类本身是内聚的,但相对于其他聚合来说又是松散耦合的。
    • 包可以嵌套。外层包可以直接访问包括在它的嵌套包中的任何类。包还可以导入其他包,
    • 包依赖性
      本质上,两个包之间的依赖性来自于两个包中类之间的依赖性。类之间的循环依赖性是个特别棘手的问题,好在大多数情况下可以通过重新设计避免循环依赖性。

    构件及其依赖性

    • 构件级复用则是比类级复用更高一级的复用,它是对一组类的组合进行封装(当然,在某些情况下,一个构件可能只包含一个单独的类),并代表完成一个或多个功能的特定服务,也为用户提供了多个接口。
    • 一个构件可以是一个编译的类,可以是一组编译的类,也 可以是其他独立的部署单元.
    • 构件是指在软件开发过程中可以重 复使用的软件元素,这些软件元素包括程序代码、测试用 例、设计文档、设计过程、需求分析文档、甚至领域知识。可复用的软件元素越大,我们称复用的粒度就越大。
    • 软件构件应具有以下特性
    • (1)独立部署单元:一个构件是独立部署的,意味着它必须能与它所在的环境及其他构件完全分离。
    • (2)作为第三方的组装单元:构件必须具备很好的内聚性,必须封装它的实现,并且只通过良好定义的接口与外部环境进行交互。
    • (3)一个构件不能有任何(外部的)可见状态:即构件不能与自己的拷贝有所区别。

    人机交互部分的设计

    用户界面设计步骤

    • (1) 从系统的输入、输出及与用户的交互中获得信息,定义界面对象和行为(操作)。
    • (2) 定义那些导致用户界面状态发生变化的事件,对事件建模。
    • (3) 描述最终向用户展示的每一个界面的状态,。
    • (4)简要说明用户如何从界面提供的界面信息来解释系统状态。

    界面设计目标

    (1) 简单性:尽量做到适度和简单,不要在页面上提供太多的东西。
    (2) 一致性:这一设计目标几乎适用于设计模型的每一个元素。
    (3) 确定性:Web应用系统的美学、界面和导航设计必须与将要构造的应用系统所处的领域保持一致。
    (4) 健壮性:在已经建立的确定性的基础上,Web应用系统通常会给用户明确的“承诺”。
    (5) 导航性:我们已经在前面提及了导航应该简单和一致,也应该以直观的和可预测的方式来设计。也就是说,用户不必搜索导航链接和帮助就知道如何使用Web应用系统。
    (6) 视觉吸引:在所有类型的软件中,Web应用系统毫无疑问是最具有视觉效果的、最生动的、也是最具有审美感的。
    (7) 兼容性:Web应用系统会应用于不同的环境(例如,不同的硬件、Internet连接类型、操作系统、浏览器),并且必须互相兼容。

    界面设计工作流

    (1) 回顾那些在分析模型中的信息,并根据需要进行优化。
    (2) 开发Web应用系统界面布局的草图。
    (3) 将用户目标映射到特定的界面行为。
    (4) 定义与每个行为相关的一组用户任务。
    (5) 为每个界面行为设计情节串联图板屏像。
    (6) 利用从美学设计中的输入来优化界面布局和情节串联图板。
    (7) 明确实现界面功能的界面对象。
    (8) 开发用户与界面交互的过程表示。
    (9) 开发界面的行为表示法。
    (10) 描述每种状态的界面布局。
    (11) 优化和评审界面设计模型。

    展开全文
  • 面向对象设计的七大设计原则详解

    万次阅读 多人点赞 2018-10-03 12:32:21
    面向对象的七大设计原则 文章目录面向对象的七大设计原则简述七大原则之间的关系一、开闭原则(The Open-Closed Principle ,OCP)概念理解系统设计需要遵循开闭原则的原因开闭原则的实现方法一个符合开闭原则的...
  • 软考(软件设计师)考点总结 -- 面向对象设计基础

    千次阅读 多人点赞 2021-05-21 17:31:21
    软考软件设计师考点总结 -- 面向对象基础:面向对象基本概念、面向对象的特性、分析、设计原则、设计模式:创建型模式、结构型模式、行为型模式、UML基本概念、UML模型。
  • 面向对象设计六大基本原则

    千次阅读 2020-12-22 23:20:34
    面向对象设计模式六大基本原则 本篇开始介绍面向对象设计思想 提示:写完文章后,目录可以自动生成,如何生成可参考右边的帮助文档 文章目录面向对象设计模式六大基本原则前言一、pandas是什么?二、使用步骤1.引...
  • C++面向对象程序设计 面向对象编程

    万次阅读 多人点赞 2018-09-12 22:39:50
    1.1 面向过程的编程风格与面向对象的编程风格 C语言是面向过程语言,也称为命令型语言,面向过程通常采用自顶向下设计,问题复杂时不断运用自顶向下设计(即函数分解法)直到容易处理。自顶向下设计优点是直观有...
  • 1、概述  谈到流程,大家都会想到熟悉的瀑布模型、螺旋模型、迭代开发、敏捷、RUP等一...而本文的流程是技术流程,是给技术人员(主要是设计人员)看的流程。 在开始讲解之前,看看如下问题你是否能够回答? 1、客户
  • Java 面 向对 象 程 序 设 计习题 解 答 与 实验张桂珠 姚晓峰 陈爱国 主编北 京 邮 电 大 学 出 版 社·北 京·内 容 简 介Java 面向对象程序设计需要做大量的练习题和大量的上机实验题才能逐步掌握 其精髓 。...
  • 本书以面向对象的软件工程思想为主线,细致深入地讲解了C#语言面向对象程序设计的方法和技巧,内容涵盖面向对象的基本概念、基于接口的设计、泛型程序设计方法、Windows和Web应用开发,以及数据库访问技术。...
  • 设计模式与面向对象

    千次阅读 2018-10-03 00:06:25
    本问对设计模式与面向对象,博主的个人理解和记录,仅供技术学习分享使用. 本文面向的学习对象:即使你是刚入门的学习者(任何一门编程语言,C#、smalltalk、EIFFEL、python、Java、OC等),或者已经拥有几年开发经验的开发...
  • 面向对象设计原则与23种设计模式

    千次阅读 2019-04-25 11:45:07
    23种设计模式优秀贴汇总: 1、【23种设计模式全解析】 2、【软件设计模式】 ...3、【面向对象设计原则与模式(JDK中模式)】 4、【23种设计模式(推荐)】 5、【设计模式】 6、【设计模式汇总】 ...
  • 转载请标明出处: ...总之,从结构化到面向对象,不仅仅是模型形式上的变化,而且有哲学思想上的变化,试图从形式上进行嫁接的努力一定得不到好结果 。 关注我的公众号,轻松了解和学习更多技术
  • 在计算机科学中,对象(英语:object),台湾译作物件,是一个存储器地址,...是面向对象(Object Oriented)中的术语,既表示客观世界问题空间(Namespace)中的某个具体的事物,又表示软件系统解空间中的基本元素。
  • UML--面向对象技术(一)

    千次阅读 热门讨论 2018-07-26 20:24:36
    二、面向对象技术 与现实世界的联系 面向对象方法(Object-Oriented Method)是一种把面向对象的思想应用于软件开发过程中,指导开发活动的系统方法,简称OO (Object-Oriented)方法,是建立在“对象”概念基础...
  • 面向对象程序设计的特点

    千次阅读 2020-07-18 15:11:54
    面向对象程序设计OOP是一种计算机编程架构。OOP的一条基本原理是计算机程序由单个能够起到子程序作用的单元或者对象组合而成。 面向对象程序设计方法是尽可能模拟人类的思维方式,使得软件的开发方法与过程尽可能...
  • 面向对象程序设计》课程设计

    千次阅读 2020-06-29 16:22:21
    结合实际,用面向对象程序设计的思想设计一个应用实例,要求用到下面设计要求中提到的知识点5个以上。 二、设计要求 通过此次课程设计,更好地掌握面向对象程序设计的基本概念及编程方法,进一步加深对继承性、多...
  • 面向对象的语言技术特点

    千次阅读 2018-06-30 20:24:31
    具有支持类和对象概念的定义与实现机制 具有实现继承的语言机制 具有实现属性和服务的机制 具有参数化类 提供类型检查 提供类库 提供持久对象的保存 提供封装与打包 提供可视化开发环境 ...
  • 面向对象分析与设计

    千人学习 2019-05-01 05:47:41
    本课程介绍软件设计理念、方法,帮助学员成长为优秀的软件设计师!当学员完成了Java等语言的学习之后,或者从事 软件开发一段时间之后,面对一个需要开发的新软件系统: 该如何入手呢?定义多少个模块?定义多少个类...
  • 面向对象七大设计原则

    千次阅读 2020-06-15 23:49:37
    面向对象设计的七大原则 前言 在软件开发中,为了提高软件系统的可维护性和可复用性,增加软件的可扩展性和灵活性,我们能要尽量根据 7 条原则来开发程序,从而提高软件开发效率、节约软件开发成本和维护成本。 面向...
  • 面向对象程序设计 面向过程程序设计 (也叫结构化编程) 定义 面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的...
  •  面向对象技巧:对“内聚耦合”、“设计模式”、“设计原则”、“UML”等最常见的面向对象技术进行了深入和别具一格的阐述,让读者不但知道“what”(是什么),还能知道“why”(为什么)和“how”(如何用)。...
  • 面向对象程序设计的基本概念

    千次阅读 多人点赞 2021-01-31 17:03:44
    1.基本术语 (1) 对象和对象类   对象是代码和数据的...类是面向对象程序设计的核心技术,可以理解成一种定义了对象行为和外观的模板;把对象看作是类的原原本本的复制品,类具有继承性、封装性、多态性、抽象性。  
  • 面向对象的分析与设计

    千次阅读 2018-12-26 21:11:04
    目录 介绍 你会学到什么? 你不会学到什么? 背景 软件开发过程模型简介 为什么我需要了解过程模型 面向对象的分析和设计——最需要的定义 开发过程与开发方法论的区别 ...面向对象设计的步骤 序列图 ...
  • 面向对象分析设计的核心概念。 顺序图: 类图模型描述了系统的类及类之间的关系。类图模型也称为系统的静态结构,因此从类图模型中我们还看不到业务的处理过程以及类与类交互的信息,在UML建模语言中,这些信息是...
  • 为什么使用面向对象设计程序 面向对象程序设计的由来软件技术专业教学资源库1.为什么使用面向对象设计程序输出学生教师行政人员的基本信息 面向对象程序设计的由来软件技术专业教学资源库1.为什么使用面向对象设计...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 377,592
精华内容 151,036
关键字:

面向对象设计技术

友情链接: netwinder-hw.rar