学习札记

1.pureMVC

PureMVC
pureMVC既然是MVC（Model、View、Controller）框架，那你就必须要记住pureMVC中的四个主要结构类：

    * Proxy（相当于Model）
    * Mediator（相当于View）
    * Command（相当于Controller）
    * Facade（管理Proxy、Mediator和Command的东西）

也许上面小括号中的话说的不严谨，在本示例中MVC是这样划分的：

   1. Model：由VO（Value Object，即值对象）和Proxy组成；
   2. Mediator：由图1中的两个MXML文件及其对应的Mediator组成；
   3. Command：由一个MacroCommand和若干个SimpleCommand组成；
   pureMVC中的Command分为两种：多命令和单一命令，即MacroCommand和SimpleCommand。MacroCommand中通过addSubCommand(SimpleCommandName)来加入子命令
   4. Facade：即ApplicationFacade；
  
  
  
在每个Mediator中会看到有一个公有的静态的常量字符串，这个字符串用来表示Mediator的类名。同样的在Proxy和Command中你也会看到，这样就可以通过facade的
retrieveMediator、retrieveProxy和retieveCommand来检索对象。
关于Model层要记住：一个MXML可视控件对应一个Mediator，Mediator本身不处理操作但它会发送Notification（发送出去的Notification会自动被执行），关于界面
上的操作采用监听的方式即addEventLisentner。  
controller层通过使用facade的registerCommand就好象添加一个监听器一样，当有sendNotification发送出来的时候，就会有对应的Command的execute方法被执行  
自定义Facade必须继承Facade，在本示例中自定义Facade名称为ApplicationFacade，这个名称也是pureMVC组织建议的名称。

 

2.闭包是可以包含自由（未绑定）变量的代码块；这些变量不是在这个代码块或者任何全局上下文中定义的，而是在定义代码块的环境中定义。“闭包” 一词来源于以下两者的结合：要执行的代码块（由于自由变量的存在，相关变量引用没有释放）和为自由变量提供绑定的计算环境（作用域）。
在 Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby 和 Python 等语言中都能找到对闭包不同程度的支持。
闭包的价值在于可以作为函数对象 或者匿名函数，对于类型系统而言这就意味着不仅要表示数据还要表示代码。支持闭包的多数语言都将函数作为第一级对象，就是说这些函数可以存储到变量中、作为参数传递给其他函数，最重要的是能够被函数动态地创建和返回。
eg:
sumOfSquares = mapReduce(myBigCollection,
 function(x) {x * x},
 function(x, y) {x + y});

 

3.进程和线程的关系
（1）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。线程是操作系统可识别的最小执行和调度单位。
（2）资源分配给进程，同一进程的所有线程共享该进程的所有资源。 同一进程中的多个线程共享代码段(代码和常量)，数据段(全局变量和静态变量)，
扩展段(堆存储)。但是每个线程拥有自己的栈段，栈段又叫运行时段，用来存放所有局部变量和临时变量。
（3）进程是是资源分配的基本单位,线程是调度运行的基本单位

 

4.ADO.net
DO.NET中的五个主要对象
Connection 物件
   Connection 对象主要是开启程序和数据库之间的连结。没有利用连结对象将数据库打开，是无法从数据库中取得数据的。这个物件在ADO.NET 的最底层，我们可以自己产生这个对象，或是由其它的对象自动产生。

Command 物件
   Command 对象主要可以用来对数据库发出一些指令，例如可以对数据库下达查询、新增、修改、删除数据等指令，以及呼叫存在数据库中的预存程序等。这个对象是架构在Connection 对象上，也就是Command 对象是透过连结到数据源

DataAdapter 物件
   DataAdapter 对象主要是在数据源以及DataSet 之间执行数据传输的工作，它可以透过Command 对象下达命令后，并将取得的数据放入DataSet 对象中。这个对象是架构在Command对象上，并提供了许多配合DataSet 使用的功能。

DataSet 物件
   DataSet 这个对象可以视为一个暂存区（Cache），可以把从数据库中所查询到的数据保留起来，甚至可以将整个数据库显示出来。DataSet 的能力不只是可以储存多个Table 而已，还可以透过DataSetCommand 对象取得一些例如主键等的数据表结构，并可以记录数据表间的关联。DataSet 对象可以说是ADO.NET 中重量级的对象，这个对象架构在DataSetCommand 对象上，本身不具备和数据源沟通的能力；也就是说我们是将DataSetCommand 对象当做DataSet 对象以及数据源间传输数据的桥梁。

DataReader 物件
   当我们只需要循序的读取数据而不需要其它操作时，可以使用DataReader 对象。DataReader对象只是一次一笔向下循序的读取数据源中的数据，而且这些数据是只读的，并不允许作其它的操作。因为DataReader 在读取数据的时候限制了每次只读取一笔，而且只能只读，所以使用起来不但节省资源而且效率很好。使用DataReader 对象除了效率较好之外，因为不用把数据全部传回，故可以降低网络的负载。

5.Struts2机制
FilterDispatch 判断是否有合适该请求的ActionMapping,如果找到依次调用dispatcher.serviceAction方法, DefaultActionProxy.execute ,ActionInvocation.invoke ,在该方法中会依次调用Interceptors,Action,PreResultListener,Result
Struts2架构目标
概念分离 松耦合 易测试 模块化 惯例重于配置

Struts1机制
ActionServlet读入struts-config.xml配置文件,根据请求找到相应的form和action,Action， ActionForm， ActionForward， ActionMapping.扩展ActionServlet,三个扩展点——RequestProcessor, ExceptionHandler, 和PlugIn,RequestProcessor负责处理顶层的请求,当一个请求到达时，ActionServlet 选择应用模块并将请求转给相应的请求处理器。每个模
块都可以载入其自己的RequestProcessor 子类，或者使用框架提供的默认请求处理器。ExceptionHandler负责处理异常,
许多应用都需要访问特定的资源。它们可能是数据访问组件，属性文件，或者其它大量的业
务层组件。许多开发人员扩展了Struts，比如菜单系统，可选的校验器，数据转换器，XSL
转换器等等。这些组件都需要解析自己的配置文件并创建它们自己的控制器对象。
在一个常规的 Java web 应用中，这些对象通常在Servlet 的init 方法中初始化并在
destroy 方法中销毁。因为在大多数情况下，Action 已经是Servlet 的代表了，框架提供了一个PlugIn 接口
(org.apache.stuts.action.PlugIn)以允许Action 实现init 和destroy 方法，
就像在Servlet 中一样.

 

6.Oracle数据库并行处理:
　Oracle数据库并行处理技术是数据库的一项核心技术，它使组织能够高效地管理和访问TB级的数据。简而言之，并行处理就是利用多个CPU和I/O资源来执行单个数据库操作。
 Oracle临时表分为 会话级临时表 和 事务级临时表。
会话级临时表是指临时表中的数据只在会话生命周期之中存在，当用户退出会话结束的时候，Oracle自动清除临时表中数据。
事务级临时表是指临时表中的数据只在事务生命周期中存在。当一个事务结束（commit or rollback），Oracle自动清除临时表中数据。
 临时表作用
1）、当某一个SQL语句关联的表在2张及以上，并且和一些小表关联。可以采用将大表进行分拆并且得到比较小的结果集合存放在临时表中
2）、程序执行过程中可能需要存放一些临时的数据，这些数据在整个程序的会话过程中都需要用的等等。

 

7.GPS(Global Positioning System).GIS(Geographic Information System).RS(Remote Sensing) 就是俗称的3S技术，是测绘学的新技术。GPS是空间定位技术,RS是遥感（即通过电磁波判读和分析地表目标）,GIS是地理信息系统，是在计算机和硬件支持下，把各种地理信息按照空间分布和属性以一定的格式输入、存储、检索、更新、显示、制图和综合分析应用的技术系统。
   3S技术的集成，对传统测绘学和地图学有重大的意义。这些数据的互通，可以将地球作为一个整体来理解，就好像把地球放在实验室离进行观察、测绘和研究一样。可以从整体、动态、几何空间、地球内部等等来测量，这对于制作地图，研究地图有着不可替代的作用。

 

 

8.JPBM,JPDL:
process:流程处理定义的顶级元素,属性有name,key,version,元素description,activities
start:开始节点,每一个流程必须有一个开始节点,属性有name,元素transition
state:状态节点
使用状态节点实现路径的选择
<state name="a">
    <transition name="accept" to="B"/>
    <transition name="reject" to="C"/>
</state>
外部触发器将为向外的转移提供不同的信号名
excutionService.signalExecutionById(excutionId,"accept")
decision:决定节点在多个选择中选择一条路径,一个    决定活动拥有很多个向外的转移,当一个流向到达一个活动时,会自动执行并决定向外的转移
一个决定节点可以配置成三个方式之一
1.decision决定条件:
decision中会运行并判断每一个transition里的判断条件,当是TRUE时转移就会执行
<decision name="decision1">
    <transition to="submit document">
        <condition expr="#{content=="good"}"/>
    </transition>   
    <transition to="try again">
        <condition expr="#{content=="not good"}"/>
    </transition>
    <transition to="give up"/>
</decision>   
2.decision expression唯一性表达式
decision表达式返回类型为字符串的向外转移的名字
<decision name="decision1" expr="#{content}">
    <transition name="good" to="submit document">
    </transition>   
    <transition name="bad" to="try again">
    </transition>
    <transition name="ugly" to="give up"/>
</decision>
3.decision handle决定处理器
唯一性管理是继承了DecisionHandler接口的java类,决定处理器选择向外转移
接口方法:String decide(OpenExecution execution)
<decision name="decision1">
    <handler class="org.jbpm.example.aaa"/>
    <transition name="good" to="submit document">
    </transition>   
    <transition name="bad" to="try again">
    </transition>
    <transition name="ugly" to="give up"/>
</decision>
fork分支节点
分支把一个执行路径分裂成多个并发的执行路径。默认的分支行为是为每个离开分支的转换创建一个子令牌，并且与到达分支的令牌之间创建一个父子关系。
<fork name="aaa">
    <transition to="send invoice"/>
    <transition to="load truck"/>
    <transition to="print shipping documents"/>
</fork>
join联合节点
默认的联合假定到达联合的所有令牌都是同一父令牌的子令牌，这种情形当使用上面所提到的分支节点、并且当所有由分支创建的令牌到达同一联合时发生。
联合会结束进入联合的每个令牌，然后联合会检查进入联合的令牌的父子关系，当所有的兄弟令牌都到达联合时，父令牌将会通过离开转换传播，当仍然还有活动的兄弟令牌时，联合表现为一个等待状态。
<join name="aaa">
    <transition to="send invoice"/>
</join>
end结束节点
分为四种类型
1.结束流程处理实例 end process instance
默认情况下,结束活动会终结已完成流程处理实例,因此在流程处理实例中,仍然在活动的多个并发流向也会结束
2.结束流向 end execution
task任务节点
<task name="review" assignee="#{order.owner}">
    <transition to="wait">
</task>     
获得任务列表:
List<Task> taskList=taskService.findPersonalTasks("person1");
<task name="review" candidate-groups="sales-dept">
    <transition to="wait">
</task>     
indentityService.createGroup("sales-dept");
indentityService.createUser("johndoe","johndoe","johb","doe");
indentityService.createMembership("johndoe","sales-dept")
//list of tasks that can be taken by the given user.
taskService.findGroupTasks("johndoe");
taskService.takeTask(task.getDbid(),"johndoe");

//list of tasks that are assigned to the given user.
List<Task> taskList = taskService.findPersonalTasks(actorID);
taskService.completeTask(task.getId());结束任务
<task name="review">
    <assignment-handler class="org.AssignmentHandlerImpl">
        <field name="assignee">
            <string value="jphndoe">
        </field>
    </assignment-handle>
    <transition to="wait"/>
</task>
   
public class AssignmentHandlerImpl implements AssignmentHandler{
    String assignee;
   
    public void assign(Assignable a,OpenExecution o)
    {
        assignable.setAssignee(assignee);
    }
}

 

9.Web Service
Web Service：是一种革命性的分布是计算技术。它使用基于XML的消息处理作为基本的数据通讯方式，消除使用不同组件模型、操作系统和编程语言的系统之间存在的差异，使异类系统能够作为计算网络的一部分协同运行。开发人员可以使用像过去创建分布式应用程序时使用组件的方式，创建由各种来源的Web服务组合在一起的应用程序。由于Web服务是建立在一些通用协议的基础上，
如HTTP（Hypertext Transfer Protocol， WWW服务程序所用的协议），SOAP（Simple Object Access Protocol，简单对象访问协议），XML，WSDL（Web Services Description Language，Web服务描述语言），UDDI（Universal Description，Discovery，and Integration，通用描述发现和集成协议）等，这些协议在涉及到操作系统、对象模型和编程语言的选择时，没有任何倾向，因此Web服务将会有很强的生命力。

　　SOAP：是“Simple Object Access Protocol”的缩写，SOAP是消息传递的协议，它规定了Web Services之间是怎样传递信息的。简单的说，SOAP规定了：

　　1. 传递信息的格式为XML.这就使Web Services能够在任何平台上，用任何语言进行实现。

　　2. 远程对象方法调用的格式。规定了怎样表示被调用对象以及调用的方法名称和参数类型等。

　　3. 参数类型和XML格式之间的映射。这是因为，被调用的方法有时候需要传递一个复杂的参数，例如，一个Person对象。怎样用XML来表示一个对象参数，也是SOAP所定义的范围。

　　WSDL：是“Web Services Description Language”的缩写。WSDL是Web Services的定义语言。当实现了某种服务的时候（如：股票查询服务），为了让别的程序调用，必须告诉大家服务接口。例如：服务名称，服务所在的机器名称，监听端口号，传递参数的类型，个数和顺序，返回结果的类型等等。这样别的应用程序才能调用该服务。WSDL协议就是规定了有关Web Services描述的标准。

　　UDDI：是“Universal Description， Discovery，and Integration”的缩写。简单说，UDDI用于集中存放和查找WSDL描述文件，起着目录服务器的作用。

10.servlet 流程
1.Servlet装入和初始化。

第一次请求Servlet时，WEB服务器会装载Servlet（实例化）Servelt会调用init()方法执行初始化操作，init方法只有在Servlet被创建时才调用，所以它常被用来作为一次性初始化的工作，如装入默认数据，获取数据库连接等。

2.调用Servlet

每一个Servlet都有对应的URL，我们可以显示的去调用，可以嵌入在HTML中，有WEB应用程序去调用。每一个WEB应用都有一个配置文件 Web.xml。关于Servlet的名称，对应的Java类文件，URL地址映射等都会放在Web.xml中。当应用服务器收到对URL地址请求信息，则更具配置文件中URL地址与Servlet之间的映射关系将其转发到指定的Servlet来处理。

3.处理请求

当WEB容器接到对Servlet的请求，WEB容器会产生一个新的线程来调用sevice()方法。service()方法检查http请求类型（GET，POST,PUT,DELETE等），然后相应的调用doGet(),doPost(),doPut(),doDelete()等方法。如果 Servlet处理各种请求的方法相同，也可以尝试覆盖service()方法。

4.多个请求的处理

Servelt由WEB容器加载，一个Servlet在同一时刻只有一个实例，并且在Servlet的使用期间将一直保留。当同时有多个请求发送到一个Servlet时，服务器会为每个请求创建一个新的线程来处理客户端的请求。此时要注意servlet的多线程的并发访问问题。

5.退出

WEB容器关闭，或者Servlet空闲时间很长，服务器将Servlet实力从内存移除，移除前会调用servlet的destroy()方法，Servlet可以使用这个方法关闭数据库连接，中断后台线程，向磁盘写入cookie列表及其他一些清理工作

 

11.云计算
狭义云计算
　　狭义云计算是指IT基础设施的交付和使用模式，指通过网络以按需、易扩展的方式获得所需的资源（硬件、平台、软件）。 提供资源的网络被称为“云”。“云”中的资源在使用者看来是可以无限扩展的，并且可以随时获取，按需使用，随时扩展，按使用付费。这种特性经常被称为像水电一样使用 IT基础设施。
 
　　广义云计算
　　广义云计算是指服务的交付和使用模式，指通过网络以按需、易扩展的方式获得所需的服务。这种服务可以是IT和软件、互联网相关的，也可以是任意其他的服务。

云计算是并行计算(Parallel Computing)、分布式计算(Distributed Computing)和网格计算 (Grid Computing)的发展，或者说是这些计算机科学概念的商业实现。云计算是虚拟化(Virtualization)、效用计算 (Utility Computing)、IaaS(基础设施即服务)、PaaS(平台即服务)、SaaS(软件即服务)等概念混合演进并跃升的结果。
　　云计算具有以下特点：
　　(1) 超大规模。“云”具有相当的规模，Google云计算已经拥有100多万台服务器， Amazon、IBM、微软、Yahoo等的“云”均拥有几十万台服务器。企业私有云一般拥有数百上千台服务器。“云”能赋予用户前所未有的计算能力。
　　(2) 虚拟化。云计算支持用户在任意位置、使用各种终端获取应用服务。所请求的资源来自“云”，而不是固定的有形的实体。应用在“云”中某处运行，但实际上用户无需了解、也不用担心应用运行的具体位置。只需要一台笔记本或者一个手机，就可以通过网络服务来实现我们需要的一切，甚至包括超级计算这样的任务。
　　(3) 高可靠性。“云”使用了数据多副本容错、计算节点同构可互换等措施来保障服务的高可靠性，使用云计算比使用本地计算机可靠。
　　(4) 通用性。云计算不针对特定的应用，在“云”的支撑下可以构造出千变万化的应用，同一个“云”可以同时支撑不同的应用运行。
　　(5) 高可扩展性。“云”的规模可以动态伸缩，满足应用和用户规模增长的需要。
　　(6) 按需服务。“云”是一个庞大的资源池，你按需购买；云可以象自来水，电，煤气那样计费。
　　(7) 极其廉价。由于“云”的特殊容错措施可以采用极其廉价的节点来构成云，“云”的自动化集中式管理使大量企业无需负担日益高昂的数据中心管理成本，“云”的通用性使资源的利用率较之传统系统大幅提升，因此用户可以充分享受“云”的低成本优势，经常只要花费几百美元、几天时间就能完成以前需要数万美元、数月时间才能完成的任务。

 

 

12.WSDL 文档在Web服务的定义中使用下列元素：

·                Types - 数据类型定义的容器，它使用某种类型系统(一般地使用XML Schema中的类型系统)。

·                Message - 通信消息的数据结构的抽象类型化定义。使用Types所定义的类型来定义整个消息的数据结构。

·                Operation - 对服务中所支持的操作的抽象描述，一般单个Operation描述了一个访问入口的请求/响应消息对。

·                PortType - 对于某个访问入口点类型所支持的操作的抽象集合，这些操作可以由一个或多个服务访问点来支持。

·                Binding - 特定端口类型的具体协议和数据格式规范的绑定。

·                Port - 定义为协议/数据格式绑定与具体Web访问地址组合的单个服务访问点。

·                Service- 相关服务访问点的集合。

 

 

13.java xml 解析

  1）DOM（JAXP Crimson解析器）

    DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。DOM 以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。

   2）SAX

    SAX处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX还比它的替代者DOM快许多。

    选择DOM还是选择SAX？ 对于需要自己编写代码来处理XML文档的开发人员来说， 选择DOM还是SAX解析模型是一个非常重要的设计决策。 DOM采用建立树形结构的方式访问XML文档，而SAX采用的事件模型。

    DOM解析器把XML文档转化为一个包含其内容的树，并可以对树进行遍历。用DOM解析模型的优点是编程容易，开发人员只需要调用建树的指令，然后利用 navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用DOM解析器的时候需要处理整个XML文档，所以对性能和内存的要求比较高，尤其是遇到很大的XML文件的时候。由于它的遍历能力，DOM解析器常用于XML文档需要频繁的改变的服务中。

    SAX解析器采用了基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag.特别是当开发人员只需要处理文档中所包含的部分数据时，SAX这种扩展能力得到了更好的体现。但用SAX解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。

 

14.
在jbpm4中对客户端的接口统一为7个服务接口：RepositoryService、ExecutionService、CommandService 、TaskService 、ManagementService、HistoryService、IdentityService，这7个接口可以从ProcessEngine接口中获得，jbpm4在启动的过程中由JbpmConfiguration负责构建引擎。

?  RepositoryService-流程定义的服务接口，包括对流程定义的部署、查询、删除操作；

?  ExecutionService-执行服务接口，包括启动流程、实例推进、设置变量等操作；

?  CommandService-Command模式的服务接口，实际上就是将客户端的请求全部封装在一个调用接口中，然后由这个接口去调用Command接口的众多实现（StartExecutionCmd、SignalCmd、SetVariablesCmd、GetTimersCmd、DeployCmd、NewTaskCmd、SubmitTask、ExecuteJobCmd等等，具体可参加pvm/internal/cmd，task/internal/cmd包及其它包下实现Command接口的类），这是典型的Command模式的应用，感兴趣的读者可以去了解设计模式中的Command模式；

?  TaskService-人工活动的服务接口，包括对任务的创建、提交、查询、保存、删除等操作；

?  ManagementService-web管理控制台的服务接口，目前只有获得消息及计时器的接口实现；

?  HistoryService-目前有对历史库中的流程实例、活动实例进行查询、某个流程定义中的所有活动的平均持续时间、某个流程定义中的某个活动实例的转移的执行次数

?  IdentityService-用户、组、成员关系的相关操作方法

jbpm 配置jbpm.default.cfg.xml，流程引擎的默认配置文件。jbpm.identity.cfg.xml, jbpm.jboss.idm.cfg.xml身份验证配置文件。jbpm.jbossremote.cfg.xml远程调用jboss实现命令模式。 jbpm.jobexecutor.cfg.xml任务执行器的配置。

hibernate映射 jbpm.execution.hbm.xml, jbpm.history.hbm.xml, jbpm.identity.hbm.xml, jbpm.repository.hbm.xml, jbpm.task.hbm.xml这五个是hibernate映射文件。

任务生命周期jbpm.task.lifecycle.xml任务的生命周期，包括启动，暂停，继续，完成，取消之类。

事务配置jbpm.tx.hibernate.cfg.xml默认的hibernate事务配置。jbpm.tx.jta.cfg.xml使用jta的事务配置。

IoC配置jbpm.variable.types.xml变量类型映射。jbpm.wire.bindings.xml依赖绑定映射。

 

15.java中的反射机制
1）概念：
是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。


2）功能：
     在运行时判断任意一个对象所属的类；
     在运行时构造任意一个类的对象；
     在运行时判断任意一个类所具有的成员变量和方法；
     在运行时调用任意一个对象的方法；
     生成动态代理。

 

16.

 从JRE1.4开始, 虚拟机提供四种collector以供实际选用，除了Default Collector之外，还有throughput Collector, Concurrent Collector和Incremental Collector.
   
    分代复制算法
  
    从JRE1.3开始, GC都采用了分代复制算法，这个算法根据对象的生存期将对象分成两代，新创建的对象在年轻代(Young Generation)，当年轻代的内存分完的时候
    ，GC将年轻代中少数尚未死亡的对象复制到另一块年老代(Tenured Generation)，然后直接更新年轻代的指针，这个动作称为次要收集（minor collection），一次次要收集的时间取决于年轻代中存活的对象的数目，
    当年轻代中的对象绝大部分已经死亡的话，次要收集速度很快。当年老代的内存分完的时候，GC会进行一次主要收集（major collection），
    因为采用了标记收集, 这个动作很慢。所以我们Tuning的策略基本上来说就是尽量减少主要收集的次数。

 

可以看到，在使用了分代收集法以后，年轻一代的对象被收集的比例最高。并且在内存中的对象会按照不同的“年龄”来划分，当一个年龄段的对象满了以后，在这个年龄段上就会发生垃圾收集，从最年轻的一代开始，一直到“永生代”，
在内存中，所有的对象可以划分为很多代，最后的一代“永生代”就是“Permanent Generation”，这里就是直接引出“Permanent Generation”概念的地方。具体可以参考下图：

根据前面所说的情况，在分代垃圾收集的情况下会产生Permanent Generation的概念，而这个分代垃圾收集法是并行收集和并发收集的基础，所以Permanent Generation
会一直存在，那么这个Permanent Generation究竟是做什么用的呢？这里保存了JVM中所有对象的类信息，包括类的元数据，还有方法描述等等，所以这一代内存垃圾收集算法是不一样的，
在Java大程序的情况下，尤其是J2EE 或者说Java EE的大型应用程序上，Permanent Generation的大小会直接限定能载入类的数量和大小。

 

17.
TCP---传输控制协议,提供的是面向连接、可靠的字节流服务。当客户和服务器彼此交换数据前，必须先在双方之间建立一个TCP连接，之后才能传输数据。TCP提供超时重发，丢弃重复数据，检验数据，流量控制等功能，保证数据能从一端传到另一端。
UDP---用户数据报协议，是一个简单的面向数据报的运输层协议。UDP不提供可靠性，它只是把应用程序传给IP层的数据报发送出去，但是并不能保证它们能到达目的地。由于UDP在传输数据报前不用在客户和服务器之间建立一个连接，且没有超时重发等机制，故而传输速度很快

 

18.堆和栈是JVM中最重要的两个内存区域。每一个java 线程都拥有自己的内存栈，用来存放局部变量和返回值，这同传统的C语言十分类似。
 栈是在线程启动的时候分配的。而所有的线程都共享一个内存堆，所有运行时的内存分配都在堆上进行，换句话说，所有的对象都是在堆上创建的。
 堆是在JVM启动的时候分配的,它的空间由GC控制.
    Java的内存分配有三种：

    * 从静态存储区域分配。内存在程序编译时就分配好了，比如静态变量

    * 在栈上创建。各种原始数据类型的局部变量都是在栈上创建的，当程序退出该变量的作用范围的时候，这个变量的内存会被自动释放。

    * 在堆中创建。对象（包括数组）都是在堆中创建的。程序在运行的时候用new关键字来创建对象，对象创建时会在堆中为其分配内存。
 
 堆和栈的区别:
 1.栈是在线程启动的时候分配的,每个线程都拥有自己的内存栈,堆是在java进程启动时分配的
 2.各种原始数据类型变量和对象的引用变量都是在栈上创建的,对象是在堆中创建的
 3.栈的存取速度比堆要快

寄存器是CPU内部的元件，寄存器拥有非常高的读写速度，所以在寄存器之间的数据传送非常快。
    1.可将寄存器内的数据执行算术及逻辑运算；
　　2.存于寄存器内的地址可用来指向内存的某个位置，即寻址；
　　3.可以用来读写数据到电脑的周边设备。

 

19.
SoftReference 类

软引用 的原理是：在保持对对象的引用时保证在 JVM 报告内存不足情况之前将清除所有的软引用。关键之处在于，垃圾收集器在运行时可能会（也可能不会）释放软可及对象。对象是否被释放取决于垃圾收集器的算法以及垃圾收集器运行时可用的内存数量。

WeakReference 类

垃圾收集器运行时如果碰到了弱可及对象，将释放 WeakReference 引用的对象。然而，垃圾收集器可能要运行多次才能找到并释放弱可及对象。

 

20.java的内存管理实际上就是对象的管理，其中包括对象的分配和释放。

对于程序员来说，分配对象使用new关键字；释放对象时，只要将对象所有引用赋值为null，让程序不能够再访问到这个对象，我们称该对象为"不可达的".GC将负责回收所有"不可达"对象的内存空间。

对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、大小以及使用情况。通常，GC采用有向图的方式记录和管理堆（heap）中的所有对象（详见 参考资料1 ）。通过这种方式确定哪些对象是"可达的"，哪些对象是"不可达的".当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。



根据Java语言规范，JVM保证调用finalize函数之前，这个对象是不可达的，但是JVM不保证这个函数一定会被调用。另外，规范还保证finalize函数最多运行一次。

 

20.基本的单向加密算法：

    ●  BASE64 严格地说，属于编码格式，而非加密算法
    ●  MD5(Message Digest algorithm 5，信息摘要算法)
    ●  SHA(Secure Hash Algorithm，安全散列算法)
    ●  HMAC(Hash Message Authentication Code，散列消息鉴别码)

    复杂的对称加密（DES、PBE）、非对称加密算法：

    ●  DES(Data Encryption Standard，数据加密算法)
    ●  PBE(Password-based encryption，基于密码验证)
    ●  RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)
    ●  DH(Diffie-Hellman算法，密钥一致协议)
    ●  DSA(Digital Signature Algorithm，数字签名)
    ●  ECC(Elliptic Curves Cryptography，椭圆曲线密码编码学)

 

 

21.
    thread 状态(五种状态)
    1、新建状态（New）：新创建了一个线程对象。

    2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start（）方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

    3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。

    4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

    ①等待阻塞：运行的线程执行wait（）方法，JVM会把该线程放入等待池中。

    ②同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM把该线程放入锁池③其他阻塞：运行的线程执行sleep（）或 join（）方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep（）状态超时、join（）等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

    5、死亡状态（Dead）：线程执行完了或者因异常退出了run（）方法，该线程结束生命周期。
   
     Java中关于线程调度的API最主要的有下面几个：

    ①线程睡眠：Thread.sleep（long millis）方法

    ②线程等待：Object类中的wait（）方法

    ③线程让步：Thread.yield（） 方法

    ④线程加入：join（）方法

    ⑤线程唤醒：Object类中的notify（）方法

    关于这几个方法的详细应用，可以参考SUN的API，及《Java多线程编程总结》一文第七部分“线程的调度”。这里我重点总结一下这几个方法的区别和使用：

    备注：sleep方法与wait方法的区别：①sleep方法是静态方法，wait方法是非静态方法。

    ②sleep方法在时间到后会自己“醒来”，但wait不能，必须由其它线程通过notify（All）方法让它“醒来”

    ③sleep方法通常用在不需要等待资源情况下的阻塞，像等待线程、数据库连接的情况一般用wait

 

21.排序算法:冒泡 选择 插入 快速 基数 希尔 归并 堆排序
 (1)冒泡排序

        冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；
        如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

(2)选择排序

      选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，
      在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，
      那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。

(3)插入排序
     插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，
     如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，
     所以插入排序是稳定的。

(4)快速排序
    快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。而右边的j下标一直往左走，当a[j] > a[center_index]。如果i和j都走不动了，
    i <= j, 交换a[i]和a[j],重复上面的过程，直到i>j。交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为 5 3 3 4 3 8 9 10 11，现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱，
    所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j] 交换的时刻。

(5)归并排序
    归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。
    可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。

(6)基数排序
   基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，
   再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。

(7)希尔排序(shell)
    希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。
    所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

(8)堆排序
   我们知道堆的结构是节点i的孩子为2*i和2*i+1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n 的序列，堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。
   但当为n /2-1, n/2-2, ...1这些个父节点选择元素时，就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法

22.linux kill
ps -ef|grep activemq
kill [PID]
  where [PID] is the process id of the ActiveMQ process.

 

23.juery hover

$(".csstab tr").mouseover(function(){$(this).addClass("over");}).mouseout(function(){$(this).removeClass("over");})
$("tr").hover(
  function(){
    $(this).addClass("hover");    //鼠标经过添加hover样式
  },
  function(){
    $(this).removeClass("hover");   //鼠标离开移除hover样式
  }
);  

 

 

24.在JMS中，目的地有两种：主题(topic)和队列(queue)。两者的区别是：当一个主题目的地中被放入了一个消息后，所有的订阅者都会收到通知；
而对于队列，仅有一个“订阅者”会收到这个消息，队列中的消息一旦被处理，就不会存在于队列中。显然，对于邮件发送程序来说，使用队列才是正确的选择，
而使用主题时，可能会发送多封相同的邮件。
Topic和Queue只是JMS内部以及其处理方式的不同，对于消息发送方和接收方来说，完全没有代码上的区别。

 

25.String类有一个特殊的创建方法,就是使用""双引号来创建.例如new String("i am")实际创建了2个String对象,一个是"i am"通过""双引号创建的,另一个是通过new创建的.只不过他们创建的时期不同, 一个是编译期,一个是运行期!

 

26.AOP通知类型
前置通知 Before advice,返回后通知 after returning advice,抛出后通知 after throwing advice,后通知 after throwing advice,环绕通知 around advice

 

 

27.mina框架
//在服务器端创建一个接收器    
         IoAcceptor acceptor = new SocketAcceptor();    
         //创建一个日志过滤器进行日志处理，并添加到过滤器链的第一个位置    
         //过滤器的位置很重要，在这里因为放到了第一个位置，它会记录原始字节码数据    
         LoggingFilter lf = new LoggingFilter();     
         acceptor.getFilterChain().addLast("logger", lf);    
         //增加一个按行进行处理文本的编解码过滤器，并且指定按GBK的方法进行编解码    
         acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("GBK"))));
        
        
public class IoHandlerAdapter implements IoHandler {
    public void sessionCreated(IoSession session) throws Exception {
        SessionUtil.initialize(session);
    }

    public void sessionOpened(IoSession session) throws Exception {
    }

    public void sessionClosed(IoSession session) throws Exception {
    }

    public void sessionIdle(IoSession session, IdleStatus status)
            throws Exception {
    }

    public void exceptionCaught(IoSession session, Throwable cause)
            throws Exception {
        if (SessionLog.isWarnEnabled(session)) {
            SessionLog.warn(session, "EXCEPTION, please implement "
                    + getClass().getName()
                    + ".exceptionCaught() for proper handling:", cause);
        }
    }

    public void messageReceived(IoSession session, Object message)
            throws Exception {
    }

    public void messageSent(IoSession session, Object message) throws Exception {
    }
}

public class TimeServerHandler extends IoHandlerAdapter{    
      static Logger logger = LoggerFactory.getLogger(TimeServerHandler.class);    
     //static Logger logger = Logger.getLogger(TimeServerHandler.class);    
     //异常处理    
     public void exceptionCaught(IoSession session, Throwable cause) throws Exception {    
         cause.printStackTrace();    
     }    
     //对接收到的数据进行业务处理，在这里我们不管收到什么信息都返回一个当前的日期    
     public void messageReceived(IoSession session, Object message) throws Exception {    
         String str = message.toString();    
         if (str.trim().equalsIgnoreCase("quit")) {    
             session.close();    
             return;    
         }    
         logger.debug("Rec:" + str);  
         System.out.println("Rec:" + str);
         Date date = new Date();    
         session.write(date.toString());    
         logger.debug("Message written...");    
     }    
     //当连接空闲时的处理    
     public void sessionIdle(IoSession session, IdleStatus status) throws Exception {    
         logger.debug("IDLE " + session.getIdleCount(status));    
     }    
 }

 

28.Java　NIO非堵塞应用通常适用用在I/O读写等方面，我们知道，系统运行的性能瓶颈通常在I/O读写，包括对端口和文件的操作上，过去，在打开一个I/O通道后，read()将一直等待在端口一边读取字节内容，如果没有内容进来，read()也是傻傻的等，
这会影响我们程序继续做其他事情，那么改进做法就是开设线程，让线程去等待，但是这样做也是相当耗费资源的。

Java NIO非堵塞技术实际是采取Reactor模式，或者说是Observer模式为我们监察I/O端口，如果有内容进来，会自动通知我们，这样，我们就不必开启多个线程死等，从外界看，实现了流畅的I/O读写，不堵塞了

 

 

29.Oracle表分区
自从oracle8i 开始可以把一个表分割为多个小的部分,这样可以对oracle的性能优化带来很大的好处~
例如：改善表的查询性能,更加容易管理表数据,备份和恢复操作更方便

分区概述
    为了简化数据库大表的管理,例如在数据仓库中一般都是TB级的数量级.ORACLE8以后推出了分区选项.分区将表分离在若于不同的表空间上,用分而治之的方法来支撑元限膨胀的大表,组大表在物理一级的可管理性.
    将大表分割成较小的分区可以改善表的维护、备份、恢复、事务及查询性能。

分区的优点：

1、 增强可用性：如果表的一个分区由于系统故障而不能使用，表的其余好的分区仍可以使用；

2、 减少关闭时间：如果系统故障只影响表的一部份分区，那么只有这部份分区需要修复，矿能比整个大表修复花的时间更少；

3、 维护轻松：如果需要得建表，独产管理每个公区比管理单个大表要轻松得多；

4、 均衡I/O：可以把表的不同分区分配到不同的磁盘来平衡I/O改善性能；

5、 改善性能：对大表的查询、增加、修改等操作可以分解到表的不同分区来并行执行，可使运行速度更快，在数据仓库的TP查询特别有用。

6、 分区对用户透明，最终用户感觉不到分区的存在。

在oracle 中分区表 分为好几种的(范围分区,散列分区,子分区,列表分区,索引分区)

partition by rang(grade)
(
partition part1 values less then(50) tablespace Part1_tb,
partition part2 values less then(MAXVALUE) tablespace Part2_tb
);



/*有两种方式,1就是指定分区数目和所使用的表空间,2指定以命名的分区*/
partition by hash(grade)
partitions 10 -- 指定分区的数目
store in(Part1_tb,Part2_tb,Part3_tb) --如果指定的分区数目比表空间多,分区会以循环方式分配到表空间
/*------------------------------------*/
partition by hash(grade)--这种方式就是 指定以命名的分区
(
partition part1 tablespace Part1_tb,
partition part2 tablespace Part2_tb
);

[子分区]即是分区的分区
subpartition by hash(grade)

[列表分区]告诉oracle所有可能的值
partition by list(area)
(
partition part1 values('guangdong','beijing') tablespace Part1_tb,
partition part2 values('shanghai','nanjing') tablespace Part2_tb
);

[索引分区]索引也可以按照和表进行分区时使用的相同的值范围来分区
create index IndexTable_index
on IndexTable(name)
local
(
partition part1 tablespace Part1_tb,
partition part2 tablespace Part2_tb
)
--local 告诉oracle表 IndexTable的每一个分区建立一个独立的索引
create index IndexTable_index
on IndexTable(name)
global;
--global为全局索引 全局索引可以包含多个分区的值 局部索引比全局索引容易管理,而全局索引比较快
注意:不能为散列分区 或者 子分区创建全局索引


（1）、增加一个分区：分区范围只能往上增，不能增加一个少于原有的分区：

alter table niegc_part add partition part_03 values less than(maxvalue)

（2）、合并分区：（合并后的分区必须指下最后一个大value的分区）

alter table niegc_part merge partitions part_02,part_03 into partition part_03

（3）、删除一个分区：

alter table niegc_part drop partition part_01

 

30.表空间与数据文件
　　简单说，表空间就是一个或多个数据文件（物理文件）的集合（逻辑文件）。一般有下面的表空间：

　　1)系统表空间（System tablespace）
　　是各种不同版本的Oracle必备的部分，存放Oracle系统的一些信息，一般只有一个SYSTEM表空间。

　　2)临时表空间（Temporary  tablespace ）
　　由于Oracle工作时经常需要一些临时的磁盘空间，这些空间主要用作查询时带有排序（Group by，Order by等）等算法所用，当用完后就立即释放，对记录在磁盘区的信息不再使用，因此叫临时表空间。一般安装之后只有一个TEMP临时表空间。

　　3)工具表空间（Tools tablespace）
　　用于保存Oracle数据库工具所需的数据库对象，这些工具表空间存放在工作时所用的专用表。旧的Oracle版本无此表空间。安装之后的工具表空间是Tools。

　　4)用户表空间（Users tablespace）
　　用于存放一些实验例子用的空间，当然也可以用于存放应用系统的数据。旧版本无Users表空间。现在的用户表空间为 USERS 。

　　5)数据及索引表空间
　　存放数据及索引的表空间，Oracle7以后都提倡在应用系统中，特别是具有大量数据的系统，要把数据和索引分开存放在不同的分区中，以便提高查询速度。在安装后索引表空间可能是INDX。数据表空间就是USERS。

　　6)回滚段表空间（Rollback Segment）
　　Oracle数据库系统在运行Insert、Update、Delete 时都需要一个磁盘空间来存放恢复信息（Undo Information），以便在进行恢复时能将原来信息读出来。安装后的回滚段表空间是RBS表空间。数据库管理员也可根据应用的需要建立另外的回滚段表空间。

 

31.面向接口的好处:
在设计模式的原则里的开闭原则，其实就是要使用接口来实现对扩展开放，对修改关闭。在设计模式的其他原则里也有关于基于接口编程的原则，即依赖倒转的设计原则(DIP)----高层模块不应该依赖于底层模块。二者都应该依赖于抽象；抽象不应该依赖于细节，细节应该依赖于抽象,在使用面向接口的编程过程中，将具体逻辑与实现分开，减少了各个类之间的相互依赖，当各个类变化时，不需要对已经编写的系统进行改动，添加新的实现类就可以了，不在担心新改动的类对系统的其他模块造成影响。

 

 

32.
Oracle的结构是：数据块->区->段->表空间。以此为包含关系

§2.5  数据块、区间和段
　　§2.5.1  数据块（data block）
　　l Oracle的数据块也叫Oracle块；
　　l Oracle系统在创建表空间时将数据文件格式化成若干个Oracle块；
　　l 每个Oracle块是Oracle系统处理的最小单位；
　　l 块的大小在安装系统时确定，可以选择“自定义安装”来设置大小；
　　l 块的大小一旦确定下来就不能改动；
　　l 块的大小可以从2k至64k不等；
　　l 块的大小可以用下面命令查到：

　　select name,value from v$parameter where name like 'db_block_size';

　　§2.5.2  区间（extent）
　　l 分配给对象（如表）的任何连续块叫区间；
　　l 区间也叫扩展，因为当它用完已经分配的区间后，再有新的记录插入就必须在分配新的区间（即扩展一些块）；
　　l 区间的大小由　next 决定；
　　l 一旦区间分配给某个对象（表、索引及簇），则该区间就不能再分配给其它的对象；
　　l 一个对象所用去多少区间可用下命令查到：

　　select segment_name,tablespace_name,count(*) from dba_extents
　　having count(*)>1 group by segment_name,tablespace_name;

　　§2.5.3  段(segment)
　　l 段是指占用数据文件空间的通称，或数据库对象使用的空间的集合；
　　l 段可以有表段、索引段、回滚段、临时段和高速缓存段等；
　　l 段使用同表空间中的若干Oracle块（可以位于不同数据文件中）。

 

33.  Oracle数据库进程

Oracle 进程
　　Oracle有两种类型的进程： 服务器进程和后台进程

　　   一般情况，当数据库启动完成后（Instance 启动成功）就至少有六个后台进程在活动，这些进程根据数据库的需要而分工不同。他们分别是：

　　1)数据库写入器（DBWR）
　　数据库写入器（Database Writer）的任务是将修改后的(在内存)数据块写回数据库文件中。在某些操作系统中，Oracle可以有两个BDWR进程。

　　2)校验点（CKPT）
　　是一个可选进程。在系统运行中当出现查找数据请求时，系统从数据库中找出这些数据并存入内存区，这样用户就可以对这些内存区数据进行修改等。当需要对被修改的数据写回数据文件时就产生重做日志的交替写（Switch），这时就出现校验点。系统要把内存中灰数据（修改过）块中的信息写回磁盘的数据文件中，此外系统还将重做日志通知控制文件。DBA可以改变参数文件中CHECKPOINT_PROCESS TRUE来使能( 使有效或无效)该进程。

　　3)日志写入器（LGWR）
　　用于将SGA区中的日志信息写入日志文件的进程。一般是用户所作的修改值先记入日志文件。等到一定时才真正将修改结果写回数据文件。

　　4)系统监控器（SMON）
　　系统监控器（System monitor）是在数据库系统启动时执行恢复工作的强制性进程。比如在并行服务器模式下（两台服务器共用一磁盘组），SMON可以恢复另一台处于失败的数据库。使系统切换到另一台正常的服务器上。

　　5)进程监控器（PMON）
　　进程监控器（Process Monitor）用于终止那些失败的用户，释放该用户所占用的资源等。

　　6)归档器（ARCH）
　　可选进程，当数据库系统处于归档（ARCHIVELOG）模式时使用。

　　7)锁（LCKn）
　　可选进程，当在并行服务器模式可出现多个锁定进程以利于数据库通信。

　　8)恢复器（RDCO）
　　分布式数据库（不同地点有不同机器和不同的Oracle系统）模式下使用的可选进程，用于数据不一致时作的恢复工作。在RECO解决恢复前，所作的修改数据的标志均标为“可疑”。

　　9)调度（Dnnn）
　　可选进程，在多线程下使用，即对每个在用（D000，...，Dnnn）的通信协议至少创建一个调度进程，每个调度进程负责从所联接的用户进程到可用服务器进程的路由请求。把响应返回给合适的用户进程。

　　10)快照进程(SNPn)
　　快照进程处理数据库快照的自动刷新，并通过 DBMS_JOB 包运行预定的数据库过程. INITsid.ORA 参数 JOB_QUEUE_PROCESS 设置快照进程数， 参数 JOB_QUEUE_INTERVAL 决定快照进程在被唤醒以处理挂起的作业或事务之前休眠的秒数。

　　11）并行查询进程（Pnnn）
　　可根据数据库的活动并行查询选项的设置，ORACLE服务器起动或停止查询进程.这些进程涉及并行索引的创建，表的创建及查询。 启动的数量与参数 PARALLEL_MIN_SERVERS指定的数量相同，不能超出该参数指定的值。 

 

34.Java的ClassLoader就是用来动态装载class的，ClassLoader对一个class只会装载一次，JVM使用的ClassLoader一共有4种：

　　启动类装载器，标准扩展类装载器，类路径装载器和网络类装载器。

　　这4种ClassLoader的优先级依次从高到低，使用所谓的“双亲委派模型”。确切地说，如果一个网络类装载器被请求装载一个 java.lang.Integer，它会首先把请求发送给上一级的类路径装载器，如果返回已装载，则网络类装载器将不会装载这个 java.lang.Integer，如果上一级的类路径装载器返回未装载，它才会装载java.lang.Integer.

　　类似的，类路径装载器收到请求后（无论是直接请求装载还是下一级的ClassLoader上传的请求），它也会先把请求发送到上一级的标准扩展 类装载器，这样一层一层上传，于是启动类装载器优先级最高，如果它按照自己的方式找到了java.lang.Integer，则下面的 ClassLoader 都不能再装载java.lang.Integer，尽管你自己写了一个java.lang.Integer，试图取代核心库的 java.lang.Integer是不可能的，因为自己写的这个类根本无法被下层的ClassLoader装载。

　　再说说Package权限。Java语言规定，在同一个包中的class，如果没有修饰符，默认为Package权限，包内的class都可以 访问。但是这还不够准确。确切的说，只有由同一个ClassLoader装载的class才具有以上的Package权限。比如启动类装载器装载了 java.lang.String，类路径装载器装载了我们自己写的java.lang.Test，它们不能互相访问对方具有Package权限的方法。 这样就阻止了恶意代码访问核心类的Package权限方法。

 

当JVM（Java虚拟机）启动时，会形成由三个类加载器组成的初始类加载器层次结构：

bootstrap classloader
|
extension classloader
|
system classloader

bootstrap classloader －引导（也称为原始）类加载器，它负责加载Java的核心类。在Sun的JVM中，在执行java的命令中使用-Xbootclasspath选项或使用 - D选项指定sun.boot.class.path系统属性值可以指定附加的类。这个加载器的是非常特殊的，它实际上不是 java.lang.ClassLoader的子类，而是由JVM自身实现的。大家可以通过执行以下代码来获得bootstrap classloader加载了那些核心类库：
URL[] urls=sun.misc.Launcher.getBootstrapClassPath().getURLs();
for (int i = 0; i < urls.length; i++) {
System.out.println(urls.toExternalform());
}
在我的计算机上的结果为：
文件:/C:/j2sdk1.4.1_01/jre/lib/endorsed/dom.jar
文件:/C:/j2sdk1.4.1_01/jre/lib/endorsed/sax.jar
文件:/C:/j2sdk1.4.1_01/jre/lib/endorsed/xalan-2.3.1.jar
文件:/C:/j2sdk1.4.1_01/jre/lib/endorsed/xercesImpl-2.0.0.jar
文件:/C:/j2sdk1.4.1_01/jre/lib/endorsed/xml-apis.jar
文件:/C:/j2sdk1.4.1_01/jre/lib/endorsed/xsltc.jar
文件:/C:/j2sdk1.4.1_01/jre/lib/rt.jar
文件:/C:/j2sdk1.4.1_01/jre/lib/i18n.jar
文件:/C:/j2sdk1.4.1_01/jre/lib/sunrsasign.jar
文件:/C:/j2sdk1.4.1_01/jre/lib/jsse.jar
文件:/C:/j2sdk1.4.1_01/jre/lib/jce.jar
文件:/C:/j2sdk1.4.1_01/jre/lib/charsets.jar
文件:/C:/j2sdk1.4.1_01/jre/classes
这时大家知道了为什么我们不需要在系统属性CLASSPATH中指定这些类库了吧，因为JVM在启动的时候就自动加载它们了。

extension classloader －扩展类加载器，它负责加载JRE的扩展目录（JAVA_HOME/jre/lib/ext或者由java.ext.dirs系统属性指定的）中JAR的 类包。这为引入除Java核心类以外的新功能提供了一个标准机制。因为默认的扩展目录对所有从同一个JRE中启动的JVM都是通用的，所以放入这个目录的 JAR类包对所有的JVM和system classloader都是可见的。在这个实例上调用方法getParent()总是返回空值null，因为引导加载器bootstrap classloader不是一个真正的ClassLoader实例。所以当大家执行以下代码时：
System.out.println(System.getProperty("java.ext.dirs"));
ClassLoader extensionClassloader=ClassLoader.getSystemClassLoader().getParent();
System.out.println("the parent of extension classloader : "+extensionClassloader.getParent());
结果为：
C:/j2sdk1.4.1_01/jre/lib/ext
the parent of extension classloader : null
extension classloader是system classloader的parent，而bootstrap classloader是extension classloader的parent，但它不是一个实际的classloader，所以为null。

system classloader －系统（也称为应用）类加载器，它负责在JVM被启动时，加载来自在命令java中的-classpath或者java.class.path系统属性或 者 CLASSPATH操作系统属性所指定的JAR类包和类路径。总能通过静态方法ClassLoader.getSystemClassLoader()找 到该类加载器。如果没有特别指定，则用户自定义的任何类加载器都将该类加载器作为它的父加载器。执行以下代码即可获得：
System.out.println(System.getProperty("java.class.path"));
输出结果则为用户在系统属性里面设置的CLASSPATH。
classloader 加载类用的是全盘负责委托机制。所谓全盘负责，即是当一个classloader加载一个Class的时候，这个Class所依赖的和引用的所有 Class也由这个classloader负责载入，除非是显式的使用另外一个classloader载入；委托机制则是先让parent（父）类加载器 (而不是super，它与parent classloader类不是继承关系)寻找，只有在parent找不到的时候才从自己的类路径中去寻找。此外类加载还采用了cache机制，也就是如果 cache中保存了这个Class就直接返回它，如果没有才从文件中读取和转换成Class，并存入cache，这就是为什么我们修改了Class但是必 须重新启动JVM才能生效的原因。


每个ClassLoader加载Class的过程是：
1.检测此Class是否载入过（即在cache中是否有此Class），如果有到8,如果没有到2
2.如果parent classloader不存在（没有parent，那parent一定是bootstrap classloader了），到4
3.请求parent classloader载入，如果成功到8，不成功到5
4.请求jvm从bootstrap classloader中载入，如果成功到8
5.寻找Class文件（从与此classloader相关的类路径中寻找）。如果找不到则到7.
6.从文件中载入Class，到8.
7.抛出ClassNotFoundException.
8.返回Class.

 

好了，现在我们了解了 classloader的结构和工作原理，那么我们 如何实现在运行时的动态载入和更新呢？只要我们能够动态改变类搜索路径和清除classloader的cache中已经载入的Class就行了，有两个方 案，一是我们继承一个classloader，覆盖loadclass方法，动态的寻找Class文件并使用defineClass方法来；另一个则非常 简单实用，只要重新使用一个新的类搜索路径来new一个classloader就行了，这样即更新了类搜索路径以便来载入新的Class，也重新生成了一 个空白的cache(当然,类搜索路径不一定必须更改)。噢，太好了，我们几乎不用做什么工作，java.netURLClassLoader正是一个符 合我们要求的classloader！我们可以直接使用或者继承它就可以了！

 

35.java基础

NullPointerException ClassCastException IndexOutOfBoundsException IllegalArgumentException ClassNotFoundException NumberFormatException ArithmeticException

java集合类
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
   ├HashSet
   ├TreeSet
   ├LinkedHashSet
  
Map
├Hashtable
├HashMap
├Properties
├LinkedHashMap
├TreeMap
├ConcurrentHashMap
└WeakHashMap

Set(集)
    集合中的对象不按特定方式排列,并且没有重复对象,它的有些实现类能对集合中的对象按特定方式排列.set接口主要有两个实现类HashSet和 TreeSet,
    HashSet类按照哈希算法来存取集合中的对象,存取速度比较快,HashSet类还有一个子类LinkedHashSet类,不仅实现了哈希算法,而且实现了链表数据结构,TreeSet类实现了SortedSet接口,具有排序功能.
List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，
这类似于Java的数组,List允许有相同的元素。
Map存储键值对


java.io.* java.util.* java.lang.* java.math.* java.net.*

Map Cloneable Serializable Runnable List Comparable Set Collection

 

36.聚集索引决定数据的物理存储顺序,一个表只能有一个聚集索引
       
适合创建索引情况：

–该列频繁用于进行搜索。

–该列用于对数据进行排序。

?不适合创建索引情况：

–列中仅包含几个不同的值。

–表中仅包含几行。

聚集索引和非聚集索引可以创建为唯一索引或组合索引。

?唯一索引不允许索引列中存在重复的值。

?组合索引允许在创建索引时使用两列或更多的列

创建组合索引的指导原则

?当需要频繁地将两列或多列作为一个整体进行 搜索时，可以创建组合索引。

?创建组合索引时先列出唯一性最好的列。

?组合索引中列的顺序和数量会影响查询的性能。

 

37.可见,rownum由系统按照记录入库时的顺序排的号,不可以改变,rowid也是的,如果要重排rownum,需要这样...

--按zip和name排序后,显示前5条记录(对照上面的结果),外层的rownum重排了,是我们需要的顺序
select rownum, p.*
  from (select zip, name from phone order by zip, name) p
 where rownum <= 5;

 

 

38.Java IO 的一般使用原则 ： 

一、按数据来源（去向）分类：

1 、是文件： FileInputStream, FileOutputStream, ( 字节流 )FileReader, FileWriter( 字符 )

2 、是 byte[] ： ByteArrayInputStream, ByteArrayOutputStream( 字节流 )

3 、是 Char[]: CharArrayReader, CharArrayWriter( 字符流 )

4 、是 String: StringBufferInputStream, StringBufferOuputStream ( 字节流 )StringReader, StringWriter( 字符流 )

5 、网络数据流： InputStream, OutputStream,( 字节流 ) Reader, Writer( 字符流 )

二、按是否格式化输出分：

1 、要格式化输出： PrintStream, PrintWriter

三、按是否要缓冲分：

1 、要缓冲： BufferedInputStream, BufferedOutputStream,( 字节流 ) BufferedReader, BufferedWriter( 字符流 )

四、按数据格式分：

1 、二进制格式（只要不能确定是纯文本的） : InputStream, OutputStream 及其所有带 Stream 结束的子类

2 、纯文本格式（含纯英文与汉字或其他编码方式）； Reader, Writer 及其所有带 Reader, Writer 的子类

五、按输入输出分：

1 、输入： Reader, InputStream 类型的子类

2 、输出： Writer, OutputStream 类型的子类

六、特殊需要：

1 、从 Stream 到 Reader,Writer 的转换类： InputStreamReader, OutputStreamWriter

2 、对象输入输出： ObjectInputStream, ObjectOutputStream

3 、进程间通信： PipeInputStream, PipeOutputStream, PipeReader, PipeWriter

4 、合并输入： SequenceInputStream

5 、更特殊的需要： PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader

决定使用哪个类以及它的构造进程的一般准则如下（不考虑特殊需要）：

首先，考虑最原始的数据格式是什么： 原则四

第二，是输入还是输出：原则五

第三，是否需要转换流：原则六第 1 点

第四，数据来源（去向）是什么：原则一

第五，是否要缓冲：原则三 （特别注明：一定要注意的是 readLine() 是否有定义，有什么比 read, write 更特殊的输入或输出方法）

第六，是否要格式化输出：原则二

 

39.修改linux文件权限命令：chmod

　　用法：chmod XXX filename

　　×××（所有者/组用户/其他用户)

　　×=4 读的权限

　　×=2 写的权限

　　×=1 执行的权限

　　常用修改权限的命令：

　　sudo chmod 600 ×××（只有所有者有读和写的权限)

　　sudo chmod 644 ×××（所有者有读和写的权限，组用户只有读的权限)

　　sudo chmod 700 ×××（只有所有者有读和写以及执行的权限)

　　sudo chmod 666 ×××（每个人都有读和写的权限)

　　sudo chmod 777 ×××（每个人都有读和写以及执行的权限)

# chmod -R 777 /home/user 注：表示将整个/home/user目录与其中的文件和子目录的权限都设置为rwxrwxrwx
执行下面命令，把conkyrc.sample文件的所有权转移到用户user: [root@localhost ~]# chown user conkyrc.sample
要改变所属组，可使用下面命令：[root@localhost ~]# chown :users conkyrc.sample

 

40.
在TCP/IP协议中，TCP协议提供可靠的连接服务，采用三次握手建立一个连接。
　　第一次握手：建立连接时，客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状
态，等待服务器确认；
第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个
SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；
　　第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)
，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。

 

41.
JSP中九大内置对象为：
request            请求对象　                类型 javax.servlet.ServletRequest        作用域 Request
response          响应对象                   类型 javax.servlet.SrvletResponse       作用域 Page
pageContext    页面上下文对象       类型 javax.servlet.jsp.PageContext      作用域    Page
session            会话对象                   类型 javax.servlet.http.HttpSession       作用域    Session
application       应用程序对象          类型 javax.servlet.ServletContext          作用域    Application
out                   输出对象                   类型 javax.servlet.jsp.JspWriter             作用域    Page
config              配置对象                  类型 javax.servlet.ServletConfig            作用域    Page
page               页面对象                  类型 javax.lang.Object                            作用域    Page
exception        例外对象                 类型 javax.lang.Throwable                     作用域    page

JSP试题2.jsp有哪些动作?作用分别是什么?

答:JSP共有以下6种基本动作

jsp:include：在页面被请求的时候引入一个文件。

jsp:useBean：寻找或者实例化一个JavaBean。

jsp:setProperty：设置JavaBean的属性。

jsp:getProperty：输出某个JavaBean的属性。

jsp:forward：把请求转到一个新的页面。

jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记

JSP试题3.forward和redirect的区别

答：forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。
redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取。

JSP试题4.JSP中动态INCLUDE与静态INCLUDE的区别？

答：动态INCLUDE用jsp:include动作实现<jsp:includepage="included.jsp"flush="true"/>它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数静态INCLUDE用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面

42.J2ee

J2EE核心是一组技术规范与指南，其中所包含的各类组件、服务架构及技术层次，均有共通的标准及规格，让各种依循J2EE架构的不同平台之间，存在良好的兼容性，
解决过去企业后端使用的信息产品彼此之间无法兼容，导致企业内部或外部难以互通的窘境。

(一共13个:(JSP,Servlet,JDBC,XML,)(EJB,JMS,JNDI,RMI,JAVA IDL),JTA,JTS,JAVAMail,JAF)
　　J2EE平台由一整套服务（Services）、应用程序接口（APIs）和协议构成，它对开发基于Web的多层应用提供了功能支持，下面对J2EE中的13种技术规范进行简单的描述:
　　1. JDBC(Java Database Connectivity)：
　　JDBC API为访问不同的数据库提供了一种统一的途径，象ODBC一样，JDBC对开发者屏蔽了一些细节问题，另外，JDCB对数据库的访问也具有平台无关性。
　　2. JNDI(Java Name and Directory Interface)：
　　JNDI API被用于执行名字和目录服务。它提供了一致的模型来存取和操作企业级的资源如DNS和LDAP，本地文件系统，或应用服务器中的对象。
　　3. EJB(Enterprise JavaBean):
　　J2EE技术之所以赢得媒体广泛重视的原因之一就是EJB。它们提供了一个框架来开发和实
　　施分布式商务逻辑，由此很显著地简化了具有可伸缩性和高度复杂的企业级应用的开发。EJB规范定义了EJB组件在何时如何与它们的容器进行交互作用。容器负责提供公用的服务，例如目录服务、事务管理、安全性、资源缓冲池以及容错性。但这里值得注意的是，EJB并不是实现J2EE的唯一途径。正是由于J2EE的开放性，使得有的厂商能够以一种和EJB平行的方式来达到同样的目的。
　　4. RMI(Remote Method Invoke):
　　正如其名字所表示的那样，RMI协议调用远程对象上方法。它使用了序列化方式在客户端和服务器端传递数据。RMI是一种被EJB使用的更底层的协议。
　　5. Java IDL/CORBA:
　　在Java IDL的支持下，开发人员可以将Java和CORBA集成在一起。他们可以创建Java对象并使之可在CORBA ORB中展开, 或者他们还可以创建Java类并作为和其它ORB一起展开的CORBA对象的客户。后一种方法提供了另外一种途径，通过它Java可以被用于将你的新的
　　应用和旧的系统相集成。
　　6. JSP(Java Server Pages):
　　JSP页面由HTML代码和嵌入其中的Java代码所组成。服务器在页面被客户端所请求以后对这些Java代码进行处理，然后将生成的HTML页面返回给客户端的浏览器。
　　7. Java Servlet:
　　Servlet是一种小型的Java程序，它扩展了Web服务器的功能。作为一种服务器端的应用，当被请求时开始执行，这和CGI Perl脚本很相似。Servlet提供的功能大多与JSP类似，不过实现的方式不同。JSP通常是大多数HTML代码中嵌入少量的Java代码，而 servlets全部由Java写成并且生成HTML。
　　8. XML(Extensible Markup Language):
　　XML是一种可以用来定义其它标记语言的语言。它被用来在不同的商务过程中共享数据。
　　XML的发展和Java是相互独立的，但是，它和Java具有的相同目标正是平台独立性。通过将Java和XML的组合，您可以得到一个完美的具有平台独立性的解决方案。
　　9. JMS(Java Message Service):
　　MS是用于和面向消息的中间件相互通信的应用程序接口(API)。它既支持点对点的域，有支持发布/订阅(publish/subscribe)类型的域，并且提供对下列类型的支持：经认可的消息传递,事务型消息的传递，一致性消息和具有持久性的订阅者支持。JMS还提供了另
　　一种方式来对您的应用与旧的后台系统相集成。
　　10. JTA(Java Transaction Architecture):
　　JTA定义了一种标准的API，应用系统由此可以访问各种事务监控。
　　11. JTS(Java Transaction Service):
　　JTS是CORBA OTS事务监控的基本的实现。JTS规定了事务管理器的实现方式。该事务管理器是在高层支持Java Transaction API (JTA)规范，并且在较底层实现OMG OTS specification的Java映像。JTS事务管理器为应用服务器、资源管理器、独立的应用以及通信资源管理器提供了事务服务。
　　12. JavaMail:
　　JavaMail是用于存取邮件服务器的API，它提供了一套邮件服务器的抽象类。不仅支持SMTP服务器，也支持IMAP服务器。
　　13. JAF(JavaBeans Activation Framework):
　　JavaMail利用JAF来处理MIME编码的邮件附件。MIME的字节流可以被转换成Java对象，或者转换自Java对象。大多数应用都可以不需要直接使用JAF。

 

43.RC=Release Candidatem,含义是"发布候选版"，它不是最终的版本，而是最终版(RTM=Release To Manufacture)之前的最后一个版本。广义上对测试有三个传统的称呼：alpha、beta、gamma，
用来标识测试的阶段和范围。alpha 是指内测，即现在说的CB，指开发团队内部测试的版本或者有限用户体验测试版本。beta 是指公测，即针对所有用户公开的测试版本。然后做过一些修改，
成为正式发布的候选版本时叫做gamma，现在叫做RC（Release Candidate）。

 

44.
类图 案例图 序列图
接口的类图和类的类图几乎一样,唯一的区别是接口的名称有interface字样
序列图按照时间顺序从上往下显示每个使用案例
开闭原则 里氏代换原则 依赖倒装原则 接口隔离原则 合成/聚合复用原则

合成和聚合均是关联的特殊种类,聚合表示拥有关系或者整体与部分的关系,
而合成则用来表示一种强的多的拥有关系,合成关系的部分与整体的关系式一样的

继承有多个缺点:
1.继承破坏封装
2.如果超类的实现发生改变,那么子类的实现也不得不改变

UML依赖关系 关联关系 聚合关系 合成关系  实现关系 继承关系

-------->

________>

<>______>

<1>_____>

-------1>

_______1>

 

 

45.设计模式

常用的设计模式:模板方法 适配器 观察者 代理 单例 原型 装饰 建造模式

创建模式:简单工厂 工厂方法 抽象工厂 单例模式 多例模式 建造模式 原型模式
结构模式:适配器  合成 装饰 代理 享元 门面 桥梁
行为模式:不变 策略 模板方法 观察者 迭代子 责任链 命令 备忘录 状态 访问者 解释器 调停者

简单工厂:由一个工厂对象决定创建出哪一种产品类的实例
工厂方法:创建产品对象的工厂接口,将实际创建工作推迟到子类
抽象工厂:客户端在不必指定产品的具体类型的情况下,创建多个产品簇中的产品对象(平行等级,工厂的工厂)
单例模式:确保某个类只有一个实例
多例模式:某个类可以有多个实例,多例类必须自己创建管理自己的实例
建造模式builder:将一个产品的内部表象与产品的生成过程分割开来,从而使一个建造过程可以生成不同的内部表象的产品对象
原型模式protetype:复制这个原型对象创建出更多的同类型的对象
适配器模式adapter:把一个类的接口变成另外一个接口(适配器有对象的适配和类的适配两种不同的形式,MouseMoveAdapter是缺省适配器模式)
装饰模式Decorator:以对客户端透明的方式将一个对象的功能加以扩展(装饰模式与适配器模式都是包装模式,区别是适配器与被适配的类实现的是不同的接口和抽象类,而装饰模式与被装饰的类实现的是相同的接口和抽象类)
代理模式proxy:给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用
享元模式Flyweight:以共享的方式高效的支持大量的细粒度对象
门面(外观)模式facade:外部与一个子系统的通信必须通过一个统一的门面对象进行
桥梁模式:将抽象化与实现化脱耦,使得两者可以独立的变化
不变模式:一个对象的状态在对象被创建之后就不再变化
策略模式:准备一组算法,并将每一个算法封装到一个独立的具体类中
模板方法:将部分逻辑以具体方法以及具体构造子的形式实现,然后声明一些抽象的方法来迫使子类实现
观察者:让多个观察者对象同时监听某一主题对象,这个主题对象在状态上发生变化时会通知所有观察者对象,使他们能够自动更新自己
迭代子模式:可以顺序的访问一个聚集中的元素而不必暴露聚集的内部表象
责任链模式:很多对象由每一个对象对其下家的引用而连接起来形成一条链
命令模式:把一个请求或者操作封装到一个对象中
备忘录模式:在不破坏封装的条件下,把一个对象的状态捕捉住,并外部化存储起来,从而可以再合适的时候恢复
状态模式:允许一个对象在其内部状态改变的时候改变其行为
访问者模式:封装一些施加于某种数据结构元素之上的操作
解释器模式:解释器模式可以定义出其文法的一种表示,并同时提供一个解释器
调停者模式:包装了一系列对象相互作用的方式,使得这些对象不必互相明显的引用