精华内容
下载资源
问答
  • 它的前言里提到数学教授在证明定理的时候一时想不起思路,会在黑板上画些东西帮助整理思路,然后擦掉,然后开始继续条理的讲述,而学生们其实最想知道的是擦去的东西。在面向对象的分析和设计中,我们最需要的其实...

    感觉这本书最精彩的是前言。它的前言里提到数学教授在证明定理的时候一时想不起思路,会在黑板上画些东西帮助整理思路,然后擦掉,然后开始继续有条理的讲述,而学生们其实最想知道的是擦去的东西。在面向对象的分析和设计中,我们最需要的其实也是这个思路。前言中宣称它这本书将主要讲这个思路。 

    这个前言吸引我拿起了这本书。但是,通读下来,感觉它其实没讲思路,而只是带着读者把OOA和OOD的完整流程走了一遍,但是什么是好的分析和设计,什么是坏的,它阐述分析得不够深入,还需读者自己去体悟。这可能也是有我没仔细看例子的原因,毕竟我只花了十个小时左右来看它。 

    这本书以两个系统的OOA和OOD为例,完整地讲述了OOA和OOD的过程。这两个系统一个是需要和硬件中断打交道的电梯控制系统ECS,一个是需要和关系数据库打交道的杂志订阅系统SBSS。这两个例子都是挺具代表性的中小系统。 

    一个完整的OOA模型可以从5个层面去刻划(P7):

    (1)类及对象层

    (2)属性层

    (3)服务层(就是方法和消息)

    (4)结构层:就是类之间的继承关系——整体部分has(用三角)或泛化特化is(用半圆)P68P69

    (5)主题层:就是场景或分系统

     

    一个完整的OOD模型也要从上面5个层面去刻划。不过它还要从功能上进一步纵向划分为4个部分(P13):

    (1)problem domain components:一般直接对应于OOA模型里分析出来的对象。

    (2)human interface components

    (3)task management components:负责和外部系统的接口(比如中断、端口、寄存器啥的)。ECS有,SBSS就没有这部分。

    (4)data management components

    (5)以上这些组成部分把实现技术隐藏起来,使之与系统的基本问题论域行为分离开来,提高了产品的复用性和扩展升级的能力。

     

    OOA的一般过程

    (0)标识主题ch7。就是把复杂系统划分为一些较为独立的子系统。

    (1)初步发现和标识对象(ch3-5)。有两种方法,一种是Linguistic-based Information Analysis,另一种是3VM。前一种是基于语言学规则通过分析各种相关文档基于词频发现候选对象列表,然后再OOA/OOD工作表格(P31)上标识这些词是该作为候选对象、还是属性、还是服务、还是不要等,这是一种比较机械系统的方法;后一种是利用3种传统的系统分析工具:数据流图(或上下文图)、实体关系图以及状态迁移图(或事件响应模型),从这3种模型里找到可能的对象。

    a)3vm有一定的互补。比如ER图无法涵盖不存储数据的对象,而通过事件响应模型则可以发现它们。

    b)上下文图:可以看作是对象间的通信,有时又可用来标识系统和外部实体之间的通信,这些外部实体常常可以标识为外部界面的对象。有助于说明系统的范围以及系统接收和产生什么信息。P45P50

    c)事件响应模型:所包含的事件必须是系统能识别的并且系统能响应的。其中有些事件可以转化为事件识别者对象。因为,每个对象要么是事件识别者,要么是事件响应者。否则它就不该存在。

    d)ER图:"0:m"表示自己对应对方0到多个实例。

    (2)标识类间结构:就是对类之间的关系进行归纳整理,这时可能会提炼出一些抽象类。

    (3)标识类的属性ch8/9:

    a)在分析模型中,属性也许不需要那么明确,比如可以用address_details来代表,日后设计时再细化

    b)一个类的每个实例应都能被唯一标识,因此都至少需要一个ID属性?

    c)OOA模型中的实例连接日后可以转化为OOD模型中的指针,比如在subscriber对象中加入一个address_id属性。

    d)在ER图中如果有一个闭合的循环,则有一个实例链接是冗余的P88,应该去除

    e)多对多实例链接可能可以揭示新对象的存在。P85

    f)所有基本的实例关系都应包含在OOA模型里

    (4)标识服务和消息ch10:走查所有事件

    a)可以使用EROI图来辅助说明。P262

    b)每个属性应至少能被封装在该对象中的一个服务所访问,而其他对象中的服务无法访问该对象中封装的任何属性。

    c)每个对象至少有一个服务,从而可以访问其属性。

    d)服务的名字采取动宾结构

    e)如果有系统的上下文图,那所有的数据流成分都该转化为00A模型里的属性,所有的流则都被表示为消息。

    (5)模型文档和评审ch12/13:

    a)不同读者应该看不同形式的文档,但描述的是同一模型。最好以CASE工具百科书的形式存在。

    b)评审时不仅要检查“语法正确性”,更重要的是要检查“语义正确性”,确保正确理解和解释了用户的需求。

     

    OOD的一般过程

    (1)构建PDC-ch15

    a)从复制OOA模型开始,复制过来的OOA模型即是OOD模型的问题论域部分;

    b)修改1:要利用已有的类库,改动PDC里的类作为已有的类的继承类

    c)修改2:调整继承关系,或者提取出更多的抽象类或者因为开发语言不支持多继承而展平原来的层次结构

    d)修改3:为提高性能而打破封装。比如将两个类合在一起,从而类间通信转为类内通信;或者使用全局数据作用域。

    e)一开始不要为了性能设计得太精巧,可以之后再根据实际运行的情况去调整性能瓶颈。P139

    (2)构建HIC-ch16:添加一些用于负责界面交互的类

    a)状态迁移图是一个很好的模型化工具,用来描述用户和系统间的交互序列。

    b)好的用户界面:最好和用户原来的使用习惯相近,这样用户学习过程很短;能引导用户完成他的工作,而不是强迫用户按某种特定的方式工作。

    c)界面原型在OOA的时候就可以开始做了,以便帮助确认需求。

    d)用VB之类开发工具的人可能不需要HIC,因为开发工具已经提供了相应的类,只需要通过使用菜单树说明大致界面就行了。

    (3)构建TMC-ch17:标识一些新的类

    a)TMC将(上下)站台技术从系统的其他部分剥离。这部分包括操作系统或执行程序的界面、任务、寄存器、中断、存储映射、端口等。

    b)没有平台接口需求的系统可以没有TMC.

    (4)构建DMC-ch18:标识一些新的类

    a)为每个关系表建立一个对象

    b)DMC将数据库技术从系统的其他部分剥离。

    c)没有永久存储数据要求的系统可以没有DMC

    (5)好的设计和坏的设计ch19

    a)类要简单。公共方法不应多于6、7个。

    b)类的层次结构不要太多。中等规模的7+/-2层

    c)方法要简单。每个方法使用的属性1、2个;每个方法的代码应在1到2屏。如果代码中有很多case语句,则说明这个方法的类分解得很差?P160

    d)复杂的消息协议通常意味过强的耦合。消息参数多于3个,坏的设计;在对象之间传递打而复杂的数据结构,很差的耦合。

    e)应该尽量减少对象之间的消息数目。完成某件事情不应有多于7+/-2个对象参与。比如像按消防队的方式在一长串的对象之间进行接力传递的数据?

    f)避免改一个类会引起一连串的改变。

    (6)实现方面的问题ch20

    a)即使用汇编语言,也可以采用面向对象的方法P166

    b)用vb时,PDC中的每个对象对应一个BAS;没有HIC部分,HIC部分的对象由VB的窗体实现;数据库接口由VB的对象实现;对象之间的调用通过函数或子程序调用完成?;实例连接、整体部分关系、泛化特化关系由类之间的共享变量实现;

    c)系统级测试和对象级测试都需要。两种测试都有黑盒测试和白盒测试。对象级的黑盒测试需要stub消息的源端和目的端。P172

    (7)另外ch21简单讲了一个公司转向OO方法时需要采取的步骤和可能遇到的问题,主要是人员、组织、项目管理方面的一些建议。

     

    希望进一步了解的

    (1)如何更有效的OOA,即用对象建模现实世界,也许看看《分析模式》?翻翻评论,决定暂缓。

    (2)如何更有效的OOD,即如何形成更有利于重用的设计,看看《设计模式

    (3)系统分析的方法:数据流图、实体关系图、状态迁移图。了解这些图的一般表示法和构造法。

    (4)更好的表达系统的方法:《编写有效用例》?《UML精粹》?

    (5)对中大型系统进行子系统划分的系统方法:也就是这本书中语焉不详的标识主题部分。

     

     

    展开全文
  • 哈希值:它是一个地址,用于栈对堆空间中对象的引用指向,不然栈是无法找到堆中对象的 GC分代年龄:记录幸存者区对象被GC之后的年龄age,,一般age为15之后下一次GC就会直接进入老年代 锁状态标志:记录一些加锁的...


    1、创建了Customer()实例 和 Account()实例
    在这里插入图片描述
    一个对象的内存结构包括:运行时元数据、类型指针、数据类型、对齐填充

    2、对象头里包括(64位机器占96位):运行时元数据(Mark Word)(占64位)、类型指针(Klass Point)(占32位)

    (1) 运行时元数据里又包括:哈希值(HashCode)、GC分代年龄、锁状态标志

    哈希值:31位的对象标识hashCode,采用延迟加载技术。调用方法System.identityHashCode()计算,并会将结果写到该对象头中。它是一个地址,用于栈对堆空间中对象的引用指向,不然栈是无法找到堆中对象的

    GC分代年龄(占4位):记录幸存者区对象被GC之后的年龄age,一般age为15(阈值为15的原因是因为age只有4位最大就可以将阈值设置15)之后下一次GC就会直接进入老年代,要是还没有等到年龄为15,幸存者区就满了怎么办,那就下一次GC就将大对象或者年龄大者直接进入老年代。

    锁状态标志:记录一些加锁的信息(我们都是使用加锁的话,在底层是锁的对象,而不是锁的代码,锁对象的话,那会改变什么信息来表示这个对象被改变了呢?也就是怎么才算加锁了呢?

    答案就是改变这个对象的对象头的锁信息来标识已经加锁,下一个线程来获取是获取不到的,底层是通过比对当前的线程的那个值与它所期望的值是否相同,这时候一直自旋直到与期望值相同,相同就获取到锁,反之则进入到阻塞队列等待,这个机制叫做CAS,比较并交换。)
    在这里插入图片描述在这里插入图片描述

    那么怎样查看对象的对象头的信息呢 ?

    第一步:导入第三方依赖

        <dependency>
          <groupId>org.openjdk.jol</groupId>
          <artifactId>jol-core</artifactId>
          <version>0.11</version>
        </dependency>
    

    第二步:打印信息

    System.out.println(ClassLayout.parseInstance(o).toPrintable());
    

    打印结果:

    在这里插入图片描述
    其中VALUE分析:
    在这里插入图片描述

    另外:锁的状态有两位数的空间标识,这样就可以实现用较少的空间去存储更多的信息,0 表示不可偏向,1 表示可偏向

    标志位 锁状态
    01 无锁
    01 偏向锁
    00 轻量级
    10 重量级
    11 GC标记

    在这里插入图片描述
    具体的 synchronized 膨胀机制见:https://blog.csdn.net/qq_43012792/article

    (2)类型指针:是对方法区中类元信息的引用

    3、实例数据:真实记录一个对象包含的数据,比如说一个person对象,里面可能包含年龄、性别、身高等等

    其中数据为字符串的,要引用到字符串常量池。

    想了解jdk8字符串常量池到底在那个地方存储的可以看这里。

    4、对齐填充:填充部分仅起到占位符的作用, 原因是HotSpot要求对象起始地址必须是8字节的整数,假如不是,就采用对齐填充的方式将其补齐8字节整数倍,那么为什么是8呢?原因是64位机器能被8整除的效率是最高的。
    在这里插入图片描述
    另外这个过程还会涉及到逃逸分析。我写了一篇逃逸分析的具体作用,感兴趣可以看看。

    基本数据类型 所占字节数 默认值 包装类名称
    byte 1(1字节=8位) 0 Byte
    short 2 0 Short
    int 4 0 Integer
    long 8 0L Long
    double 8 0.0d Double
    float 4 0.0f Float
    char 2 ‘\u0000’ Character
    boolean 1 false Boolean

    怎样快速记住这些类型的方法,请看这里。

    盘点一下 Java创建对象的几种方式(6大种)全面版

    尚硅谷深解Java虚拟机(JVM)内存结构各部分总结【三层划分】https://blog.csdn.net/qq_43012792/article/details/107358550

    有用点个关注,手留余香!😐 😐 😐

    展开全文
  • IBM MQ中主要对象作用

    千次阅读 2016-10-30 14:41:55
    队列管理器队列管理器是为应用程序提供消息传递服务的程序。使用消息队列接口(MQI)的应用程序可以将消息放置到队列并可从队列中获取消息。队列管理器确保消息可以发送至正确的...队列管理器主管网络中的其他对象,例

    MQ基础概念,来自官方文档,感觉讲的还是蛮清楚的。

    队列管理器

    队列管理器是为应用程序提供消息传递服务的程序。使用消息队列接口(MQI)的应用程序可以将消息放置到队列并可从队列中获取消息。队列管理器确保消息可以发送至正确的队列或传递至另一个队列管理器。队列管理器处理向它发出的 MQI 调用以及提交给它的命令(无论从哪个源)。队列管理器为每个调用或命令生成合适的完成代码。
    队列管理器是 MQ 消息传递网络中的主要组件。队列管理器主管网络中的其他对象,例如,将队列管理器连接在一起的队列和通道。队列管理器必须正在运行以执行下列任务:
    * 启动通道
    * 处理 MQI 调用
    * 创建、删除或改变队列和通道定义
    * 运行命令服务器以处理 MQSC 命令

    队列

    队列是存放消息的容器。连接至主管队列的队列管理器的业务应用程序可从队列检索消息或将消息放置到队列。队列在它可保存的最大消息数和这些消息的最大长度方面存在限制。

    队列存在以下类型:

    本地队列

    本地队列是队列以及与此队列关联的一组消息的定义。
    主管队列的队列管理器在其本地队列中接收消息。
    

    传输队列

    传输队列是特殊类型的本地队列。
    当队列管理器将消息发送至远程队列管理器上的队列时,传输队列在本地存储此消息,直到远程队列管理器上的队列可用。
    要创建传输队列,创建一个本地队列并将其用法属性更改为“传输”。
    

    远程队列

    远程队列定义是属于另一个队列管理器的队列的本地队列管理器上的定义。
    要将消息发送至远程队列管理器上的队列,发送方队列管理器必须具有目标队列的远程定义。
    

    别名队列

    别名队列实际上不是队列;它们是现有队列的附加定义。
    您创建指向实际本地队列的别名队列定义,但可以用与本地队列(基本队列)不同的名称来命名别名队列定义。
    这表示您可更改应用程序使用的队列而无需更改此应用程序,您只需创建指向新的本地队列的别名队列定义。
    

    模型队列

    模型队列是您想让队列管理器根据需要动态创建的队列的模板。
    当应用程序尝试将消息放置到模型队列时,队列管理器将动态地创建与此模型队列同名的本地队列。
    以此方式创建的队列既可以是临时队列也可以是永久队列。
    

    集群队列

    集群队列是在集群中已共享的队列,这样的话,此集群中的所有队列管理器可使用集群通道在此队列放置和获取消息。
    

    主题

    主题标识发布的内容。主题是描述在发布/预订消息中所发布信息的主题的字符串。作为订户,您可以使用通配符指定主题或主题范围以接收您所需的信息。

    主题标识发布的内容,它由长度最大可为 10240 个字符的字符串组成。主题是发布/预订系统中成功传递消息的关键。发布者为每条消息分配一个主题,而不是在每条消息中包含一个特定目标地址。队列管理器使该主题与一组已预订该主题的订户匹配,并将消息传递至其中每个订户。

    发布者通过仔细选择消息中指定的主题,可以控制哪些订户接收到发布。
    在定义消息的主题之前,发布者也可以使用该消息;在发布或预订中首次指定消息时,会创建一个主题。

    预定或者订阅

    预订是一个记录,它包含关于订户感兴趣并希望接收关于其信息的主题的信息。因此,预订信息确定哪些发布内容会转发至订户。订户可以接收来自不同发布者的信息,并且也可以将他们接收的信息发送至其他订户。

    发布的信息将在 MQ 消息中进行发送,该信息的题目由一个主题进行标识。发布者在发布信息时指定主题,而订户则指定它要接收的发布所针对的主题。将仅对订户发送关于它预订的那些主题的信息。

    发布

    发布是由应用程序发送至发布/预订引擎的消息。然后,发布/预订引擎将消息发送至任何已预订接收这些消息的应用程序。

    发布/预订引擎可根据发布中包含的信息类型以不同方式处理它接收的发布。
    根据状态和事件信息,可以将发布按它们包含的信息类型进行分类:

    状态发布

    状态发布包含关于某件事的当前状态的信息,如股票价格或足球比赛的当前比分。
    当发生某件事(如股票价格更改或足球比分更改)时,将不再需要先前的状态信息,因为它已被新的信息取代。
    订户应用程序希望在启动时接收状态信息的当前版本,并希望在状态更改时接收到新的信息。
    

    事件发布

    事件发布包含关于发生的个别事件的信息,如购入某支股票或将球射进特定球门。
    每个事件独立于其他事件。订户希望在事件发生时接收关于事件的信息。
    

    保留发布

    缺省情况下,发布/预订引擎在将某个发布发送至所有感兴趣的订户之后会删除该发布。
    这种处理方法适合于事件信息,但并非始终适合于状态信息。发布者可以指定发布/预订引擎必须保存发布的副本,该副本则称为保留发布。
    可以将副本发送至对该主题有兴趣的后续订户。这表示新的订户不必等待再次发布信息也能接收到信息。
    因为发布/预订引擎仅为每个主题保留一个发布,所以当新发布到达时,将删除旧发布。
    因此,请确保只有一个发布者在发送针对每个主题的保留发布。订户可以指定他们不想接收到保留发布,并且现有订户可以要求将保留发布的重复副本发送给他们。
    

    通道

    WebSphere® MQ 使用两种不同类型的通道:
    * 消息通道,它是两个队列管理器之间的单向通信链路。WebSphere MQ 使用消息通道在队列管理器之间传送消息。要双向发送消息,您必须定义每个方向的通道。
    * MQI 通道,它是双向通道,用于将应用程序(MQI 客户机)连接至服务器上的队列管理器。WebSphere MQ 使用 MQI 通道在 MQI 客户机和队列管理器之间传送 MQI 调用和响应。

    消息通道

    消息通道定义可以是下列其中一个类型:

    发送方
    发送方通道是队列管理器用来将消息发送至其他队列管理器的消息通道。
    要使用发送方通道来发送消息,还必须在另一队列管理器上创建与此发送方通道同名的接收方通道。
    如果正在实现“回调”机制,那么还可以将发送方通道与请求方通道一起使用。

    服务器
    服务器通道是队列管理器用来将消息发送至其他队列管理器的消息通道。
    要使用服务器通道来发送消息,还必须在另一队列管理器上创建与此服务器通道同名的接收方通道。 您还可将服务器通道与请求方通道一起使用。
    在此情况下,在通道另一端的请求方通道定义请求要启动的服务器通道定义。服务器将消息发送至请求方。只要服务器知道对方通道的连接名称,它还可启动通信。

    接收方
    接收方通道是队列管理器用来从其他队列管理器接收消息的消息通道。
    要使用接收方通道来接收消息,还必须在另一队列管理器上创建与此接收方通道同名的发送方通道或服务器通道。

    请求方
    请求方通道是队列管理器用来将消息发送至其他队列管理器的消息通道。
    要使用请求方通道发送消息,还必须在另一队列管理器上创建发送方通道(如果您正在实现回调机制的话)或服务器通道。

    集群发送方
    集群发送方(CLUSSDR)通道定义用来定义通道发送端,集群队列管理器可通过它将集群信息发送至其中一个完整存储库。
    集群发送方通道用于告知存储库有关队列管理器状态的任何更改,例如,添加或除去队列。它还用于传输消息。完整存储库队列管理器自身拥有指向彼此的集群发送方通道。
    它们使用这些通道以就集群状态的更改进行相互通信。 队列管理器的 CLUSSDR 通道定义指向哪个完整存储库不是很重要。在进行了最初的接触之后,会根据需要自动定义更多的集群队列管理器对象,以便队列管理器可将集群信息发送至每个完整存储库并将消息发送至每个队列管理器。

    集群接收方
    集群接收方(CLUSRCVR)通道定义用来定义通道接收端,集群队列管理器可通过它从集群中的其他队列管理器接收消息。集群接收方通道还可传送有关集群的信息(发往存储库)。
    通过定义集群接收方通道,该队列管理器对其他集群队列管理器表示它可用于接收消息。每个集群队列管理器至少需要有一个集群接收方通道。有关更多信息,请参阅《队列管理器集群》。

    对于每个通道,您必须定义两端以便获取通道每一端的通道定义。通道的两端必须是兼容类型。
    您可使用下列通道定义的组合:

    * 发送方 - 接收方
    * 服务器 - 接收方
    * 请求方 - 服务器
    * 请求方(需要监听器) - 发送方(回调)
    * 集群发送方 - 集群接收方
    

    消息通道代理程序

    您创建的每个通道定义都属于特定队列管理器。队列管理器可具有同一类型或不同类型的几个通道。通道的每一端是一个程序,即消息通道代理程序(MCA)。在通道的一端,调用方 MCA 从传输队列获取消息并通过通道发送它们。在通道的另一端,响应方 MCA 接收这些消息并将它们传递至远程队列管理器。
    调用方 MCA 可与发送方通道、服务器通道或请求方通道关联。响应方 MCA 可与消息通道的任何类型关联。

    MQI 通道

    MQI 通道可以是下列其中一个类型:
    服务器连接
    服务器连接通道是双向 MQI 通道,用于将 WebSphere MQ 客户机连接至 WebSphere MQ 服务器。服务器连接通道是通道的服务器端。

    客户机连接
    客户机连接通道是双向 MQI 通道,用于将 WebSphere MQ 客户机连接至 WebSphere MQ 服务器。MQ 资源管理器还使用客户机连接来连接至远程队列管理器。客户机连接通道是通道的客户机端。当您创建客户机连接通道时,在主管队列管理器的计算机上创建一个文件。然后,您必须将该客户机连接文件复制到 WebSphere MQ 客户机计算机。

    监听器

    侦听器是一个 WebSphere® MQ 进程,它用来侦听与队列管理器的连接。MQ 资源管理器中的每个侦听器对象都表示一个侦听器进程;但是,如果从命令行启动侦听器进程,那么在 MQ 资源管理器中此侦听器不能由侦听器对象表示。因此,要从 MQ 资源管理器管理侦听器进程,请在 MQ 资源管理器中创建侦听器对象。当您在 MQ 资源管理器中启动侦听器对象时,侦听器进程也会启动。

    在 WebSphere MQ 中提供了多种不同类型的侦听器,这取决于消息通道代理程序 (MCA) 通过消息通道用来发送和接收消息的传输协议:
    * LU6.2
    * TCP/IP
    * NetBIOS
    * SPX

    进程

    进程定义包含应用程序的信息,此应用程序作为队列管理器上的触发器事件的响应而启动。当您在队列上启用触发时,您可创建进程定义并将它与此队列关联。每个队列可指定不同的进程定义,或几个队列可共享同一个进程定义。如果您创建进程定义,队列管理器将从此进程定义中抽取信息并将其放置到触发器消息中以供触发器监视器使用。
    如果要触发通道的启动而不是应用程序的启动,那么您不需要创建进程定义,因为可使用传输队列定义代替。

    名称列表

    名称列表是包含其他对象名称列表的 WebSphere® MQ 对象。通常,名称列表由诸如触发器监视器之类的应用程序使用,在这些应用程序中,名称列表用来标识一组队列,或者名称列表与队列管理器集群配合使用,以维护由多个 WebSphere MQ 对象引用的集群的列表。名称列表还用于维护认证信息对象的列表,这些认证信息对象包含连接至 LDAP 服务器的认证信息。

    通信信息对象

    WebSphere® MQ 多点广播提供低等待时间、高扇出和可靠的多点广播消息传递。需要通信信息 (COMMINFO) 对象才能使用多点广播传输。
    多点广播比传统的单点广播发布/预订消息传递更有效,因为它可以扩展至较大量的订户,而不会对性能产生不利影响。WebSphere MQ 使用应答、否定应答和序号来支持可靠的多点广播消息传递,以实现高扇出的低等待时间消息传递。
    WebSphere MQ 多点广播公平传递支持几乎同时的传递,从而确保不偏向任何接收方。WebSphere MQ 多点广播使用网络来传递消息,因此无需发布/预订引擎对数据进行扇出。将主题映射至组地址之后,就不需要队列管理器,因为发布者和订户可以采用对等方式运作。该过程允许减少队列管理器服务器上的负载,而队列管理器服务器将不再是潜在的故障点。

    触发器监视器

    触发器监视器是一个应用程序,它在发生触发器事件时处理放在启动队列上的触发器消息。
    如果触发队列并发生了触发器事件,那么队列管理器会将触发器消息发送至启动队列。触发器监视器读取触发器消息并根据触发器消息中的数据执行适当的操作。通常,此操作将启动某些其他应用程序以处理导致生成触发器消息的队列。从队列管理器的角度来看,触发器监视器没有任何特殊的地方,它只是读取来自队列(启动队列)的消息的另一个应用程序。
    当您启动了触发器监视器之后,它仅继续监视指定的启动队列。您不能直接停止触发器监视器。当您停止触发器监视器的队列管理器时,触发器监视器也会停止。

    通道启动程序

    通道启动程序是一个应用程序,它在发生触发器事件时处理放在启动队列上的触发器消息。通道启动程序是特殊类型的触发器监视器,它启动通道而不是启动应用程序。
    如果触发队列并发生了触发器事件,那么队列管理器会将触发器消息发送至启动队列。通道启动程序处理此触发器消息并启动通道。从队列管理器的角度来看,通道启动程序没有任何特殊的地方,它只是从队列(启动队列)读取消息的另一个应用程序。
    因为通道启动程序只是特殊类型的触发器监视器,所以当您启动了通道启动程序时,它只会继续监视指定的启动队列。您不能直接停止通道启动程序。当您停止通道启动程序的队列管理器时,通道启动程序也会停止。
    您也不能创建或删除通道启动程序。当创建或删除了通道启动程序的队列管理器时,就会创建或删除通道启动程序。

    定制服务

    定制服务是您创建以便自动运行命令的服务。定制服务存储在这些服务所属的队列管理器上的服务文件夹中。您可指定在服务启动和停止时运行的命令和其他选项。您可自动执行服务以在队列管理器启动时启动并运行命令

    集群

    集群是两个或更多队列管理器的组,这些队列管理器在逻辑上是关联的并可在彼此之间共享信息。任何队列管理器都可对同一集群中的任何其他队列管理器发送消息而无需设置特定的通道定义、远程队列定义或传输队列,这是因为所有这些信息都保留在存储库中,此集群中的所有队列管理器都对此存储库拥有访问权。可以实现负载均衡、互为热备。

    展开全文
  • 面向对象设计

    千次阅读 2018-07-16 10:52:39
    面向对象设计 面向对象基本概念 面向对象程序设计(Object-oriented ...类:类是变量与作用这些变量的方法集合,事物都具有其自身的属性和方法,通过这些属性和方法可以将不同的物质区分开来。 对象对象...

    面向对象设计

    面向对象基本概念

    面向对象程序设计(Object-oriented programmingOOP)是种具有对象概念的程序编程典范,同时也是一种程序开发的抽象方针。它可能包含数据、属性、代码与方法。

    面向对象编程的两个重要概念是类和对象。

    类:类是变量与作用这些变量的方法集合,事物都具有其自身的属性和方法,通过这些属性和方法可以将不同的物质区分开来。

    对象:对象是类进行实例化后的产物,是一个实体。

    面向对象基本特征

    封装

    封装是面向对象的特征之一,是对象和类概念的主要特性。

    封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的类进行信息隐藏。

    继承

    继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。

    • 通过继承创建的新类称为“子类”或“派生类”。
    • 被继承的类称为“基类”、“父类”或“超类”。
    • 继承的过程,就是从一般到特殊的过程。

    继承概念的实现方式有三类:实现继承、接口继承和可视继承。

    • 实现继承:使用基类的属性和方法而无需额外编码的能力;
    • 接口继承:仅使用属性和方法的名称、但是子类必须提供实现的能力;
    • 可视继承:子窗体(类)使用基窗体(类)的外观和实现代码的能力。

    OO开发范式大致为:划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

    多态

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

    最常见的多态就是将子类传入父类参数中,运行时调用父类方法时通过传入的子类决定具体的内部结构或行为。

    实现多态,有两种方式,覆盖和重载。覆盖和重载的区别在于,覆盖在运行时决定,重载是在编译时决定。并且覆盖和重载的机制不同,例如在 Java 中,重载方法的签名(方法签名:方法名+形参列表)必须不同于原先方法的,但对于覆盖签名必须相同。

    面向对象设计原则

    开闭原则

    开闭原则(Open Close PrincipleOCP)是Java中最基础的设计原则,它可以帮助我们建立一个稳定、灵活的系统。

    定义

    软件中的对象(类、模块、函数等)应该对于扩展是开放的,但是对于修改是封闭的。

    实例分析

    我们假设当前有一个书籍销售的功能模块,程序原本的类图如下:

    面向对象开闭原则1

    此时,因为书店打折活动,书籍价格会产生变化,我们需要修改程序的getPrice()方法,我们可以修改接口IBook,也可以修改其实现类NovelBook,但是这样的话都会在类中产生两个读取价格的方法,顾这两种方法都不是最优的解决办法。如下图所示,我们新建一个OffNovelBook,让其继承NovelBook并重写getPrice方法,新建高层类,通过复写来改变业务逻辑,减少底层代码的修改,减少代码风险。

    面向对象开闭原则2

    我们可以把变化归类为两种类型:

    • 逻辑变化:只变化了一个逻辑,而不涉及到其他模块的变化,可以直接修改原有类中的方法来实现,但这有一个前提条件是所有依赖或关联都按照相同的逻辑处理。
    • 子模块变化:一个模块的变化,会对其他模块产生影响,特别是一个低层次的模块变化必然引起高层模块的变化,因此诸如此类的变化应通过扩展来完成。

    总结

    • 抽象约束 :通过接口或抽象类约束扩展,对扩展进行边界限定 ;参数类型、引用对象尽量使用接口或抽象类,而不是具体的实现类 ;抽象层尽量保持稳定,一旦确定就不要修改 。
    • 元数据(metadata)控制模块行为 :元数据就是用来描述环境和数据的数据。尽量使用元数据来控制程序的行为,减少重复开发 。
    • 封装变化:将相同的变化封装到一个接口或抽象类中,不同的变化应封装在不同的接口或抽象类中,否则即违背了单一职责原则。

    单一职责原则

    单一职责原则(Single Responsibility PrincipleSRP),其核心的思想是: 一个类,最好只做一件事,只有一个引起它变化的原因。

    定义

    单一职责,强调的是职责的分离,在某种程度上对职责的理解,构成了不同类之间耦合关系的设计关键,因此单一职责原则或多或少成为设计过程中一个必须考虑的基础性原则。

    实例分析

    public void addProduct() {
        if (!getCuurentUserPermission.contains("product.add")) {
            //当前用户不具有add权限
            return;
        } 
        //业务逻辑
    }

    从以上代码,我们不难看出,如果该功能对应的权限规则发生了变化 ,那么我们需要对系统中所有诸如此类的类进行修改。这将大大降低程序的稳定性,同时也会大大的提高我们得工作量。

    对于这种情况我们可以新建一个类(权限控制类,比如shiro框架)来做处理。在shrio框架中,可以通过注解的方式去配置权限代码来实现权限控制,同理我们也可自己写一个方法,例如:PermisssionUtils.haveRight(String permissionCode),在调用addProduct之前去判断是否拥有权限,从而使业务逻辑与权限控制两个职责分离。

    PermisssionUtils.haveRight("product.add");
    addProduct();

    总结

    单一职责原则可以看作是低耦合、高内聚在面向对象原则上的引申,将职责定义为引起变化的原因,以提高内聚性来减少引起变化的原因。职责过多,可能引起它变化的原因就越多,这将导致职责依赖,相互之间就产生影响,从而极大的损伤其内聚性和耦合度。单一职责,通常意味着单一的功能,因此不要为类实现过多的功能点,以保证实体只有一个引起它变化的原因。

    里氏替换原则

    里氏替换原则(Liskov Substitution Principle,即LSP):所有引用父类的地方必须能使用其子类的对象。

    定义

    所有引用父类的地方必须能使用其子类的对象

    在软件中将一个基类对象替换成它的子类对象,程序将不会产生任何错误和异常,反过来则不成立,如果一个软件实体使用的是一个子类对象的话,那么它不一定能够使用父类对象。

    实例分析

    在下文关于依赖倒置原则的实例中:

    public class Client {
        public static void main(String[] args) {
            People jim = new Jim();
            Fruit apple = new Apple();
            Fruit banana = new Banana();
            jim.eat(apple);
            jim.eat(banana);
        }
    }

    我们将Banana赋值给其父类Banana,并且在执行jim.eat(Banana)方法时得到了我们期望的结果。

    总结

    里氏替换原则是实现开闭原则的重要方式之一,由于使用父类对象的地方都可以使用子类对象,因此在程序中尽量使用父类类型来对对象进行定义,而在运行时再确定其子类类型,用子类对象来替换父类对象。通常我们会使用接口或者抽象方法定义基类,然后子类中实现父类的方法,并在运行时通过各种手段进行类型选择调用(比如反射)。

    子类的所有方法必须在父类中声明,或子类必须实现父类中声明的所有方法。根据里氏替换原则,为了保证系统的扩展性,在程序中通常使用父类来进行定义,如果一个方法只存在子类中,在父类中不提供相应的声明,则无法在以父类定义的对象中使用该方法。

    我们在运用里氏替换原则时,尽量把父类设计为抽象类或者接口,让子类继承父类或实现父接口,并实现在父类中声明的方法,运行时,子类实例替换父类实例,我们可以很方便地扩展系统的功能,同时无须修改原有子类的代码,增加新的功能可以通过增加一个新的子类来实现。里氏替换原则是开闭原则的具体实现手段之一。这也就是我们应该更多的依赖抽象,尽量少的依赖实现细节, 也就是依赖倒置原则。

    依赖倒置原则

    依赖倒置原则(Dependency Inversion PrincipleDIP)

    定义

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

    抽象:抽象类或接口,两者是不能被实例化的

    细节:抽象具体的实现类,实现接口或继承抽象类所产生的类(可以被实例化的类)

    实例分析

    //具体Jim人类
    public class Jim {
        public void eat(Apple apple){
            System.out.println("Jim eat " + apple.getName());
        }
    }
    //具体苹果类
    public class Apple {
        public String getName(){
            return "apple";
        }
    }
    public class Client {
        public static void main(String[] args) {
            Jim jim = new Jim();
            Apple apple = new Apple();
            jim.eat(apple);
        }
    }

    从上述代码,我们不难看出,该程序所表示的人吃苹果。此时我们如果要加一条人吃香蕉,只能先定义一个Banana类,然后在修改Jim类,在其中加一个吃香蕉的方法。加一种尚且如此,那么加n种呢?并且修改Jim类的操作会大大减少系统的稳健性,顾应根据依赖倒置原则对源码进行修改,修改如下:

    //人接口
    public interface People {
        public void eat(Fruit fruit);//人都有吃的方法,不然都饿死了
    }
    //水果接口
    public interface Fruit {
        public String getName();//水果都是有名字的
    }
    //具体Jim人类
    public class Jim implements People{
        public void eat(Fruit fruit){
            System.out.println("Jim eat " + fruit.getName());
        }
    }
    //具体苹果类
    public class Apple implements Fruit{
        public String getName(){
            return "apple";
        }
    }
    //具体香蕉类
    public class Banana implements Fruit{
        public String getName(){
            return "banana";
        }
    }
    public class Client {
        public static void main(String[] args) {
            People jim = new Jim();
            Fruit apple = new Apple();
            Fruit banana = new Banana();
            jim.eat(apple);
            jim.eat(banana);
        }
    }

    总结

    总而言之,依赖倒置原则的核心就是面向接口编程,对于一些底层类都提取抽象类和公共接口,顶层类依赖抽象类或接口而不直接依赖具体实现。

    依赖倒置原则的本质是通过抽象类或接口使各个类或模块的实现彼此独立,不相互影响,实现模块之间的松耦合。

    在多人协作时,我们还可以遵循依赖倒置原则去设计程序,提取抽象,使得各模块相对独立,提升并行开发效率,提高开发速度。

    接口隔离原则

    接口隔离原则(Interface Segregation Principle, 即ISP):使用多个专门的接口,而不使用单一的总接口,即客户端不应该依赖那些它不需要的接口。

    定义

    • 客户端不应该依赖它不需要的接口。

    • 类间的依赖关系应该建立在最小的接口上。

    • 接口隔离原则将非常庞大、臃肿的接口拆分成为更小的和更具体的接口,这样客户将会只知道他们感兴趣的方法。

    实例分析

    例如:客户端的用户需要登录、登出、修改密码等操作,而后台的管理员则可以修改用户资料、删除用户等操作。

    public interface UserService{
        public void login();
        public void logout();
        public void changePassword();
    }
    public interface AdminUserService extends UserService {
        public void updateUser(User user);
        public void deleteUser(User user);
    }

    总结

    接口隔离原则的目的是系统解开耦合,从而容易重构、更改和重新部署。

    接口隔离原则与前面的单一职责原则相辅相成。但单一职责原则并不保证客户程序只知道必要的信息,甚至在有些情况下接口隔离原则与单一职责原则会出现一定的冲突,设计时我们要根据用户界面,性能等因素决策.。

    运用接口隔离原则,一定要适度,接口设计的过大或过小都不好。设计接口的时候,只有多花些时间去思考和筹划,才能准确地实践这一原则。

    迪米特法则

    迪米特法则(Law of Demeter, 即LOD):一个软件实体应当尽可能少地与其他实体发生相互作用。

    迪米特法则又称为最少知识原则(LeastKnowledge Principle,即LKP)

    定义

    不要和“陌生人”说话、只与你的直接朋友通信

    在迪米特法则中,对于一个对象,其朋友包括以下几类:

    • 当前对象本身(this)
    • 以参数形式传入到当前对象方法中的对象
    • 当前对象的成员对象
    • 如果当前对象的成员对象是一个集合,那么集合中的元素也都是朋友
    • 当前对象所创建的对象

    任何一个对象,如果满足上面的条件之一,就是当前对象的“朋友”,否则就是“陌生人”。在应用迪米特法则时,一个对象只能与直接朋友发生交互,不要与“陌生人”发生直接交互,这样做可以降低系统的耦合度,一个对象的改变不会给太多其他对象带来影响 。

    实例分析

    例如:现在用户像好友发送消息,用户可以对单个好友发送消息,也可以发送群消息。

    迪米特恩法则

    从上图不难看出,我们专门引入了一个MessageService用与控制消息转发,同时降低UserService与各系统之间的耦合度。当需要新增功能时,只需修改MessageSerice即可。

    总结

    迪米特法则要求我们在设计系统时,应该尽量减少对象之间的交互,如果两个对象之间不必彼此直接通信,那么这两个对象就不应当发生任何直接的相互作用,如果其中的一个对象需要调用另一个对象的某一个方法的话,可以通过第三者转发这个调用。简言之,就是通过引入一个合理的第三者来降低现有对象之间的耦合度

    在运用迪米特恩法则时应注意以下几点:

    • 在类的划分上,应当尽量创建松耦合的类,类之间的耦合度越低,就越有利于复用,一个处在松耦合中的类一旦被修改,不会对关联的类造成太大波及。
    • 在类的结构设计上,每一个类都应当尽量降低其成员变量和成员函数的访问权限。
    • 在类的设计上,只要有可能,一个类型应当设计成不变类;在对其他类的引用上,一个对象对其他对象的引用应当降到最低。

    组合/聚合复用原则

    组合/聚合复用原则(Composite/Aggregate Reuse PrincipleCARP

    定义

    组合和聚合都是对象建模中关联(Association)关系的一种.聚合表示整体与部分的关系,表示“含有”,整体由部分组合而成,部分可以脱离整体作为一个独立的个体存在。组合则是一种更强的聚合,部分组成整体,而且不可分割,部分不能脱离整体而单独存在。在合成关系中,部分和整体的生命周期一样,组合的新的对象完全支配其组成部分,包括他们的创建和销毁。一个合成关系中成分对象是不能与另外一个合成关系共享。

    实例分析

    组合/聚合和继承是实现复用的两个基本途径。合成复用原则是指尽量使用合成/聚合,而不是使用继承。 只有当以下的条件全部被满足时,才应当使用继承关系。

    • 继承复用破坏包装,它把父类的实现细节直接暴露给了子类,这违背了信息隐藏的原则。
    • 如果父类发生了改变,那么子类也要发生相应的改变,这就直接导致了类与类之间的高耦合,不利于类的扩展、复用、维护等,也带来了系统僵硬和脆弱的设计。
    • 合成和聚合的时候新对象和已有对象的交互往往是通过接口或者抽象类进行的,就可以很好的避免上面的不足,而且这也可以让每一个新的类专注于实现自己的任务,符合单一职责原则。

    判断方法:

    1.使用“Has-A”和“Is-A”来判断:

    “Has-A”:代表的是 对象和它的成员的从属关系。同一种类的对象,通过它们的属性的不同值来区别。比如一个人可以是医生、警察、教师等。此时可使用继承关系

    “Is-A”:代表的是类之间的继承关系,比如一个人可以是男人、女人。此时应使用组合/聚合

    2.使用里氏替换原则来判断

    里氏代换原则是继承复用的基础。

    总结

    继承的缺点:

    • 继承复用破坏数据封装性,将基类的实现细节全部暴露给了派生类,基类的内部细节常常对派生类是透明的,白箱复用。虽然简单,但不安全,不能在程序的运行过程中随便改变。
    • 基类的实现发生了改变,派生类的实现也不得不改变。
    • 从基类继承而来的派生类是静态的,不可能在运行时间内发生改变,因此没有足够的灵活性。

    组合/聚合优点:

    • 新对象存取组成对象的唯一方法是通过组成对象getter/setter方法。
    • 组合复用是黑箱复用,因为组成对象的内部细节是新对象所看不见的。
    • 组合复用所需要的依赖较少。
    • 每一个新的类可以将焦点集中到一个任务上。
    • 组合复用可以在运行时间动态进行,新对象可以动态的引用与成分对象类型相同的对象。

    组合/聚合缺点:组合复用建造的系统会有较多的对象需要管理。

    展开全文
  • 看完之后,突然想起‘皇帝新装’的寓言,整本书80%的内容可以合并到剩下的20%,除去一些经典的设计模式,其余的模式太多的牵强附会,如同是为写书而写,论述罗嗦,例子不完善。我想只适合c++的新手阅读,可惜...
  • JavaScript核心 作者: JeremyWei | 可以转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明 网址: http://weizhifeng.net/javascript-the-core.html ...对象原型链构造函数执行上下文
  • 在HotSpot虚拟机中,对象在内存中存储的布局可以分为3块区域:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。 具体如下图 java 普通对象结构 java 数组对象结构 对象结构组成 对象头 ...
  • 浅析面向对象

    千次阅读 多人点赞 2012-06-17 16:02:56
    浅析面向对象   毕业已经上了日程,马上开始做毕业设计了,java书再一次被我拿了出来。结果看得时候发现一个令人兴奋的现象,发现原来学的时候好多不懂的地方,现在好像都懂了,现在就来简明的谈谈什么是...其中,
  • VR中对带约束的物理对象的交互

    千次阅读 2016-12-07 23:12:44
    在VR游戏中, 使用双手(控制器)直接对虚拟世界中的对象进行交互, 已经成为一种”标准化”的设计, 一切看起来能够用手去交互的物体, 都需要附合物理规则....稍微复杂一点儿的物理对象, 是带约束(Co
  • 直接量(literal) Undefine NULL 包装对象 变量作用域 函数作用域 块级作用作用域链 变量解析 引用错误
  • 在学过JavaScript之后,我们都知道对象分为内置对象 、宿主对象 、自定义对象,我们经常用到的浏览器中的内置对象就是宿主对象的一种,浏览器的内置对象有很多,本文就来详细讲解一下History对象的属性与方法吧。...
  • JavaScript中的变量对象,简约却不简单(系列五)

    万次阅读 多人点赞 2020-06-17 18:52:05
    本篇文章:主要介绍执行上下文的组成部分之一——变量对象(VO)和活动对象(AO)。本文是与系列的前几篇文章存在一定的承接关系,大家兴趣的话不妨从头阅读~
  • 面向对象的程序设计读书笔记

    千次阅读 2017-10-17 23:33:02
    封装,对象有一个明确的边界,声明公开,实现隐藏,实现的更改,对对象的使用没有影响。多态,子类的对象可以放到父类的引用中,子类的方法可以覆盖父类的公有非final、或者protected方法。方法可以同名重载。每个...
  • Java对象内存布局概述

    千次阅读 多人点赞 2019-09-22 23:17:42
    以HotSpot虚拟机为例,对象在内存中可以分为三块区域:对象头、实例数据和对齐填充。其中,对象头包含Mark Word和类型指针,关于对象头的内容,在...对齐填充则不是必须存在的,只是起占位符的作用,比如Hot Spot...
  • 对象头的内部结构一张图了解所有细节 1、创建了Customer()实例 和 Account()实例 2、对象头里包括:运行时元数据、类型指针、实例数据、对齐填充 ① 运行时元数据里又包括:哈希值(HashCode)、GC分代年龄、锁状态...
  • Scala Predef对象详解

    万次阅读 2018-11-16 13:39:14
    Scala Predef对象 Scala程序设计 第2版 - 原版.pdf 下载:https://download.csdn.net/download/u014646662/10805074 目录: 1.Predef源码 2.类型装换 3.类型定义 4.条件检查方法 5.输入输出方法 6.其他 对...
  • C++类和对象详解

    千次阅读 多人点赞 2020-05-08 00:43:54
    创建对象 两种创建对象的方式:一种是在栈上创建,形式和定义普通变量类似;另外一种是在堆上使用 new ...类可以看做是一种数据类型,它类似于普通的数据类型,但是又别于普通的数据类型。类这种数据类型是一个包...
  • 5w字长文带你彻底看懂Spring是怎么创建对象的!附10几张图,在创作这篇文章的过程中给官方提交了两个issue
  • Scala面向对象编程

    万次阅读 2018-11-07 11:18:49
    Scala面向对象编程 Scala程序设计 第2版 - 原版.pdf 下载: https://download.csdn.net/download/u014646662/10805074 目录: 1 类与对象初步 2 引用与值类型 3 价值类 4 父类 5 Scala的构造器 6 类的字段 6.1...
  • 今天闲来无事,空闲的时间,所以想坐下来聊一聊Java的GC以及Java对象在内存中的分配。 和标题一样,本篇绝对是用最直接最通俗易懂的大白话来聊 文章中基本不会听起来很高大上专业术语,也不会太多概念性的...
  • 要看的懂对象的创建过程,首先你得对Java虚拟机和Java基础以及JUC很是熟悉,比如类的加载过程,CAS、多线程、JVM的GC等等 首先好看一个图,我大概会根据图中的内容来分享这六个步骤(其实几个步骤不重要,只要包括...
  • 文件对象及文件映射对象

    千次阅读 2010-03-24 09:11:00
    文件对象和文件映射对象(问题来源:IPP例子simple_player vm_mmap _win32.c文件中的vm_mmap_create函数)1.内存映射文件 内存映射文件与虚拟内存有些类似,通过内存映射文件可以保留一个地址空间的区域,同时将...
  • 内核同步对象

    千次阅读 2013-11-21 20:56:51
    表4-1列出了这些内核同步对象的类型及它们的用途。在任何时刻,任何对象都处于两种状态中的一种:信号态或非信号态。有时,当代码运行在某个线程的上下文中时,它可以阻塞这个线程的执行,调用KeWaitForSingleObject...
  • 在本文将 ,我对 Java 对象创建、对象内存布局、对象访问定位的三个过程 进行了详细介绍,希望你们会喜欢
  • 对他提出的这个问题很兴趣,深入研究了一下,便了这篇文章。 更新引用是JVM的职责 任何一款JVM的设计,采用任何一种GC算法进行对象的移动操作时,如何更新对象引用都是JVM的基本职责。也就是说,当移动对象时,...
  • 文件对象和文件映射对象

    千次阅读 2016-04-21 12:02:09
    所以,如果想对内存映射文件更深刻的认识,必须对Windows操作系统的内存管理机制【参见windows核心编程Chapt13】清楚的认识,内存管理的相关知识非常复杂,超出了本文的讨论范畴,在此就不再赘述,兴趣的读者...
  • Java对象与Java类

    千次阅读 多人点赞 2021-07-28 22:23:35
    文章目录1.面向对象是什么?...包包的概念:包的作用:包(package)的命名规范:访问权限修饰符11.面向对象语言的三大特征1.封装2.多态3.继承12.类于类之间的关系1.关联关系(has-a)2.依赖关系(uses-a
  • C++对象内存模型

    千次阅读 2016-11-21 14:37:07
    谈VC++对象模型 (美)简.格雷 程化 译 译者前言 一个C++程序员,想要进一步提升技术水平的话,应该多了解一些语言的语意细 节。对于使用VC++的程序员来说,还应该了解一些VC++对于C++的诠释。 Inside the ...
  • 每个对象在出生的时候就一把钥匙(监视器Monitor),那么被synchronized 修饰的方法相当于给方法加了一个锁,这个方法就可以进行同步,在多线程的时候,不会出现线程安全问题。 注:Monitor是 Java中用以实现线程...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 150,633
精华内容 60,253
关键字:

对象感的作用有哪些