精品亚洲永久免费精品,久久精品国产亚洲av高清漫画,亚洲va中文字幕无码久久

Observer模式在J2EE中的实现 [http://35java.com/zhibo/forum.php?mod=viewthread&tid=108&extra=page%3D3]

Sun, 13 Feb 2011 11:24:00 GMT

引言�Q?/span>
         设计模式是经验的文档化。它是对被用来在特定场景下解决一般设计问题的�c�d��怺�通信的对象的描述。更通俗的来��_��它是一个问�?解决�Ҏ(gu��)��寏V��一旦我们掌握了设计模式�Q�就�{�于拥有了一支强有力的专安��伍。它甚至能够佉K��向对象的新手利用前�h的经验找��责明��的�c�d��对象�Q�从而获得优雅的解决�Ҏ(gu��)��。由于设计模式也是重构的目标�Q�如果在设计的初期适当地引入设计模式，可以减少重构的工作量�?/span>
   但是�Q�我们也不能陷入模式的陷阱，��Z��使用模式而去套模式，那样会陷入�Ş式主义。我们在使用模式的时候，一定要注意模式的意图（intent�Q�，而不要过多的��d��注模式的实现�l�节�Q�因��些实现细节在特定情况下，可能会发生一些改变。不要顽固地认�ؓ设计模式一书中的类图或实现代码��׃��表了模式本��n�?/span>
   下面�Q�我们来讨论一下�ؓ什么要在分布式、多层系�l�中使用Observer模式�?/span>

多层体系�l�构�Q�multi-tier architecture�Q�：
三层体系�l�构是多层体�pȝ��构中最��单的一�U�，它一般包括：

表示�?presentation)�Q�窗口、报�?
业务逻辑�?business logic)�Q�管理业务过�E�的��d��和规则。它又可以细分�ؓ领域对象层（代表领域概念�Q�和服务层（提供数据库交互、安全性、打印报表）�?/li>
存储�?storage)�Q�持久化存储机制。如数据库服务器�{��?br style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; word-wrap: break-word; " />

图一�Q�三层体�pȝ��?/strong>

   而Java 2�q�_��企业版（J2EE�Q�是一�U�利用Java 2�q�_��来简化诸多与多��企业解决�Ҏ(gu��)��的开发、部�|�和��理相关的复杂问题的体系�l�构。它是开攄��、基于标准的�q�_��Q�用以开发、部�|�和��理N层结构、面向Web的，以服务器��Z��心的企业�U�应用�?/span>
   ��Z��支持领域对象的复用，�q�且佉K��域对象的接口变更所带来的媄响最��化。我们将领域层（模型�Q�和表示层（视图�Q�相分离�?/span>
   采用模型�Q�视图模式的意义在于�Q?/span>


支持聚合度更高的模型定义�Q��模型的定义可以集中在领域�q�程的定义，而不是图形界面上�?/li>
允许��模型和用户界面�q�行开发�?/li>
使用��L��面的需求变化对领域层所造成的媄响最��化�?/li>
允许建立与一个现有的领域层对象相�q�接的新视图�Q�同时不影响领域层�?/li>
允许一个模型同时有多个视图�Q�例如��用SVG和表根{�?/li>
允许模型层独立于用户界面层执行�?br style="margin-top: 0px; margin-right: 0px; margin-bottom: 0px; margin-left: 0px; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; word-wrap: break-word; " />

   而这恰恰与Observer模式的意囄��d��。因此我们有必要跨层来实现Observer模式�?/span>
   其实�Q�在应用中更多的是采用MVC框架来架构整个企业应用的。在MVC框架中，Model和View之间存在着依赖关系�Q�是Observer模式的典型应用。当然MVC框架�q�包括其它模式如Composite模式和Strategy模式。在J2EE�q�_��中，我们可以把Web Tier�Q�包括Jsp和servelet和JavaBean�Q�看作是表示层，EJB Tier看作是领域层。而controller可能跨距Web Tier�?EJB Tier�?/span>
   在Java�c�d��中采用Java.util.Observable�c�d��Java.util.Observer接口来实现Observer模式�Q�它们在单个的Java VM.中运行的很好�Q�但如果惛_��EJB中��用它们就会有一些问题。这正如我们引言中提到的�Q�模式的具体实现在特定情况下�Q�可能会发生一些改变�?/span>


��g��递还是远�E�引用传递？
                  ��g��递：
在Java RMI中要求所有的参数和返回类型是JAVA的基本类型或实现Java.io.Serilizable的对象。串行化对象通过��g��递（又名拯��传递）�Q�而不是引用传递，�q�意味着在某一层中串行化对象的更�ƈ不自动媄响到其它的对象�?nbsp;
            �q�程引用传递：
对于EJB对象而言�Q�它�׃��个接口（home接口和remote接口�Q�和一个类�l�成。容器会�Ҏ(gu��)��ejb规范来生成实��C��面两个接口的�c�（我们分别�U�CؓxxxEJBHome对象和xxxEjbObject对象�Q�。在较多的容器的实现�Ҏ(gu��)��中，xxxEJBHome对象使用了factory模式来创建xxxEjbObject对象�Q�xxxEjbObject对象则采用proxy模式�Q�作为xxxBean的代理类。在生成以上两个对象的同�Ӟ��容器会从部��v文�g中读取关于安全、事务、持久性等服务�q�在xxxEjbObject对象和xxxEJBHome对象中添加以上服务的代码。而且xxxEJBHome对象和xxxEjbObject对象都是分布式对象，我们在此只讨论xxxEjbObject对象。所谓分布式对象�Q�从本质上来�Ԍ��分�ؓ3个部分：object server、skeleton、stub。其中object server和skeleton位于服务器端�Q�而stub位于客户端。Object server负责实现业务逻辑�Q�skeleton负责marshal和unmarshal�Ҏ(gu��)��{�֐��?nbsp;

图二�Q�分布式对象

   昄��Q�EJB的客��P��调用EJB的对象）可以是�Q何对象，包括EJB和一般的Java�cȝ��x��用�Q何语�a�写的corba客户端�?/span>
   从EJB的客戯��角来看的话，我们只能看到一个home接口、一个remote接口�Q�对于实体bean的话�Q�还可以看见一个主键类�Q�而bean�c�d��客户是不可见的）。但我们从上面的��Q�我们可以知道，对于remote接口中地�Ҏ(gu��)��调用�Q�实际上是多态地调用XXX_Stub�c�R��即XXX_Stub对象对客户具有可见性（但这�U�可见性是透明的，卛_��户不知道�q�种可见性的存在�Q�。由于，XXX_Stub对象和Object Server实现了相同的接口�Q��ƈ且Object server真正实现了业务逻辑。所以，当在客户端调用XXX_Stub对象的方法时候，XXX_Stub对象通过socket通信机制��方法签名传�l�XXX_Skeleton对象�Q�XXX_Skeleton对象在去委托Object Server完成业务处理逻辑。因此，Object Server本��n发生了改变。我们称XXX_Stub对象是Object Server对象的远�E�引用，�q�认为当分布式对象作为参��C��递的时候，是通过引用传递的�Q�会产生副作�?/span>

�?ji��)�?/a> 2011-02-13 19:24 发表评论

JavaBean PropertyChange 之设计模式Observer(�?

Sun, 13 Feb 2011 10:26:00 GMT
     摘要: java语言里包含了许多对设计模式的直接支持�Q�如command模式�Q�agent模式�Q�observer模式�{�。虽然java提供的对�q�些模式的支持很��单，不能满��比较复杂的应用。但在简单的场景下，使用�q�些�c�d��往能够得到立杆见媄的效果。所以，如果没有什么特�D�需求，�q�是最好利用java的这些类�?        Observ...  阅读全文

�?ji��)�?/a> 2011-02-13 18:26 发表评论

Sat, 12 Feb 2011 05:02:00 GMT
接口�Q�空心圆+直线�Q�唐老鸭�c�d��C��‘讲�h�?#8217;�Q�；
依赖�Q�虚�U?��头�Q�动物和�I�气的关�p�）�Q?br style="line-height: 22px; " /> 兌��Q�实�U?��头�Q�企鹅需要知道气候才�q�移�Q�；
聚合�Q�空心四边�Ş+实线+��头�Q�雁��和大雁的关�p�）�Q?br style="line-height: 22px; " /> 合成/�l�合�Q�实心四边�Ş+实线+��头�Q�鸟和翅膀的关�p�）�Q?br style="line-height: 22px; " /> 泛化/�l�承�Q�空心三角�Ş+实线�Q�动物和鸟的�l�承关系�Q�；
实现�Q�空心三角�Ş+虚线�Q�实现大雁飞��的接口�Q�；

UML�c�d��

解释UML�c�d��Q?/span>

1.       首先�?#8220;动物”矩�Ş框，它代表一个类。该�c�d��分�ؓ三层�Q�第一层显�C�类的名�U�ͼ�如果是抽象类��p��用斜体显�C�。第二层是类的特性，通常��是字段和属性。第三层是类的操作，通常是方法和行�ؓ�?/span>

   注意前面的符��P��‘+’表示public, ‘�?/span>’ 表示private, ‘#’表示protected.



2.       “飞翔”矩�Ş框表�C�Z��个接口图�Q�它与类囄��区别主要是顶端有�?/span>interface》显�C�，�W�一行是接口名称�Q�第二行是接口方法。接口还有另一�U�表�C�方法，俗称��棒�p�表�C�法�Q�就是唐老鸭�c�d��C��“讲�h�?#8221;的接口�?/span>



interface IFly                              interface Ilanguage
{                                              {
   void Fly();                                    void Speak();
}                                             }

3.       动物�Q�鸟�Q�鸭�Q�唐老鸭他们之间都是�l�承的关�p�，�l�承关系用空心三角�Ş+实现来表�C?/span>�?/span>



4.“大雁”实现�?#8220;飞翔”接口�?span style="line-height: 22px; color: red; ">实现接口�?/span>�I�心三角�?/span>+虚线来表�C?/span>。（注：下面的图中应为空心三角�Ş�Q?/span>

class Bird:Animal                      class WideGoose:IFly
{                                        {
   //�l�承动物�c?nbsp;                                //实现飞翔接口
}                                        }

5.       企鹅与气候有很大的关�p�，企鹅需�?#8220;知道”气候的变化�Q�需�?#8220;了解”气候规律。当一个类“知道”另一个类�Ӟ��可以用关�?/span>(association)关系�?span style="line-height: 22px; color: red; ">兌��关系用实�U�箭头来表示�?/span>



class Penguin :Bird
{
   private Climate climate;//在企鹅Penguin中，引用到气候Climate对象
}

6.       “大雁”�?#8220;雁群”�q�两个类。大雁是��居动物�Q�每只大雁都属于一个雁��，一个雁��可以有多只大雁。所以它们之间就满��聚合(Aggregation)关系�?span style="line-height: 22px; color: red; ">聚合表示一�U�弱�?#8220;拥有”关系�Q�体现的�?/span>A对象可以包含B对象�Q�但B对象不是A对象的一部分�?/span>聚合关系用空心的菱�Ş+ 实线��头表示�?/span>



class WideGooseAggregate
{
   private WideGoose[] arrayWideGoose;
   //在雁��WideGooseAggregate�c�M��Q�有大雁数组对象arrayWideGoose
}

7.       “�?#8221;�?#8220;��膀”�q�两个类。鸟和翅膀似整体和部分的关�p�，�q�且��膀和鸟的生命周期是相同的，在这里鸟和其��膀��是合成关系�?span style="line-height: 22px; background-color: yellow; ">合成(composition)是一�U�强�?#8220;拥有”关系�Q�体��C��严格的部分和整体的关�p�，部分和整体的生命周期一�?/span>�?span style="line-height: 22px; color: red; ">合成关系用实心的的菱�?/span>+实线��头来表�C?/span>。另外，合成关系的连�U�两端还有一个数�?#8220;1”和数�?#8220;2”�Q�，�q�被�U�Cؓ基数。表明这一端的�c�d��以有几个实例�Q�很昄��Q�一个鸟应该有两支翅膀。如果一个类可能有无��C��实例�Q�则��q��“n”来表�C�。关联关�p�，聚合关系也可以有基数的�?/span>

class Bird
{
  private Wing wing;
  public Bird()
   {
      wing=new Wing();
    //在鸟Bird�c�M��Q�初始化�Ӟ��实例化翅膀Wing,它们之间同时生成
   }
}

8.       “动物”�?#8220;氧气”�?#8220;�?#8221;之间。动物有几大特征�Q�比如有新陈代谢�Q�能�J�殖。而动物要有生命，需要氧气，水以及食物等。也��是说动物依赖于氧气和水。它们之间是依赖关系(Dependency),用虚�U�箭头来表示�?/span>

abstract class Animal
{
   public bolism(Oxygen oxygen,Water water)
    {
    }
}

�?ji��)�?/a> 2011-02-12 13:02 发表评论

Bitwise operators and Shift operators

Tue, 20 May 2008 05:22:00 GMT
位运��符与逻辑�q�算�W�基本相��|��不过后者的对象只是表示真和假的二��D��，位运��符的对象则是二�q�制数。Java语言中字节、字�W�和整数�{�都可以转换��Z��q�制�Q�所以位�q�算�W�的对象也可以是它们。常见位�q�算�W�有�Q?
按位�q�行与运��?�Q?&
按位�q�行或运��?�Q?|
按位�q�行位异�q�算�Q?^
按位�q�行取反�q�算�Q?~
按位�q�行循环左移�Q?lt;<�Q�运��符左侧对象左移由右侧指定的位数�Q�低位补0�Q�最高位抛弃。带�W�号的左�U�M��q�算相当于对左操作数�q�行�?�q�算�?
按位�q�行循环右移�Q?gt;>�Q�运��符左侧对象右移由右侧指定的位数�Q�若��gؓ正，在最高位插入0�Q�若��gؓ负，在最高位插入1�Q�即�U�d��的最高位和原最高符号位相同。带�W�号的右�U�M��q�算相当于对左边的运��对象进行除2�q�算�?
按位�q�行无符号右�U�：>>>�Q�无��符左边的运��对象取值正负，都在高位插入0�Q�即�U�d��位始�l�补0.
要注意是没有按位�q�行无符号左�Uȝ��。位�q�算�W�的操作数只能是整数�Q�char,byte,short,
int和long,�q�行位运��时�Q��L��先将字符型倹{��字节型值和短整型��D�{换�ؓ整型再进行位�q�算。位�q�算�W�游标的操作数用于指定移动的位数�Q�按规定其不应超�q�左侧数的进制表�C�Z��数�?
The bitwise operators allow you to manipulate individual bits in an integral primitive data type.Bitwise operators perform Boolean algebra on the corresponding bits in the two arguments to produce the result. The bitwise operators come from C’s low-level orientation, where you often manipulate hardware
directly and must set the bits in hardware registers. Java was originally designed to be embedded in TV set-top boxes, so this low-level orientation still made sense. However, you probably won’t use the bitwise operators much.
The bitwise AND operator (&) produces a one in the output bit if both input bits are one; otherwise, it produces a zero.
The bitwise OR operator (|) produces a one in the output bit if either input bit is a one and produces a zero only if both input bits are zero.
The bitwise EXCLUSIVE OR, or XOR (^), produces a one in the output bit if one or the other input bit is a one, but not both.
The bitwise NOT (~, also called the ones complement operator) is a unary operator; it takes only one argument. (All other bitwise operators are binary operators.) Bitwise NOT produces the opposite of the input bit—a one if the input bit is zero, a zero if the input bit is one.

�?ji��)�?/a> 2008-05-20 13:22 发表评论

Special case: primitive types

Tue, 20 May 2008 05:12:00 GMT

Special case: primitive types

Java determines the size of each primitive type. These sizes don’t change from one machine

architecture to another as they do in most languages. This size invariance is one reason Java

programs are more portable than programs in most other languages.

All numeric types are signed, so don’t look for unsigned types.

The size of the boolean type is not explicitly specified; it is only defined to be able to take the literal values true or false.

The “wrapper” classes for the primitive data types allow you to make a non-primitive object on the heap to represent that primitive type. For example:

char c = 'x';

Character ch = new Character(c);

Or you could also use:

Character ch = new Character('x');

Java SE5 autoboxing will automatically convert from a primitive to a wrapper type:

Character ch = 'x';

and back:

char c = ch;

The reasons for wrapping primitives will be shown in a later chapter.

High-precision numbers

Java includes two classes for performing high-precision arithmetic: BigInteger and

BigDecimal. Although these approximately fit into the same category as the “wrapper” classes, neither one has a primitive analogue.

Both classes have methods that provide analogues for the operations that you perform on

primitive types. That is, you can do anything with a BigInteger or BigDecimal that you can with an int or float, it’s just that you must use method calls instead of operators. Also, since there’s more involved, the operations will be slower. You’re exchanging speed for accuracy.

BigInteger supports arbitrary-precision integers. This means that you can accurately represent integral values of any size without losing any information during operations.

BigDecimal is for arbitrary-precision fixed-point numbers; you can use these for accurate

monetary calculations, for example.

OX123�Q?/span>1×16²�Q?/span>2×16¹�Q?/span>3×16⁰

�?ji��)�?/a> 2008-05-20 13:12 发表评论

整型数据

Tue, 20 May 2008 05:10:00 GMT
三种形式的整型常量数据：
1.十进�?br /> 2.八进�Ӟ��以o开头O123�Q?×8²�Q?×8¹�Q?×8⁰�Q�十�q�制�?3
3.十六�q�制 �Q�以ox开�?nbsp; OX123�Q?/span>1×16²�Q?/span>2×16¹�Q?/span>3×16⁰

�?ji��)�?/a> 2008-05-20 13:10 发表评论

Introduction to Objects

Tue, 20 May 2008 05:10:00 GMT

1.The hidden implementation
The goal of the class creator is to build a class that exposes only what is necessary to the client programmer and keeps everything else hidden. Why?
(1)Becuase if it is hidden, the client programmer can't access it, which means that the class creator can change the hidden portion at will withou worring about the impact on anyone else.
(2)The hidden portion usually reprsents the tender insides of an object that could easily be corrupted by a careless or uninformed client programmer, so hiding the implementation reduces program bugs.

2.Reusing the implementation
The simplest way to reuse a class is to just use an object of that class directly, but you can also place an object of that class inside a new class. We call this "creating a member object." Your new class can be made up of any mumber and type of other objectss, in any combination that you need to achieve the fuctionality desired in your new class. Because you are composing a new class from existing classes, this conception is called composition. Compositon is often referred to as a "has-a" relationship, as "A car has an engine."
Because inheritance is so important in OOP, it is often highly emphasized, and the new programmer can get the idea that inheritance should be used everywhere. This can result in awkward and overly complicated designs. Instead, you should first look to composition when creating new classes, since it is simpler and more flexible. If you take this approach,your designer will be cleaner. Once you have had some experience, it will be reasonably obvious when you need inheritance.

3.Inheritance
You have two ways to differentiate your new derived class from the original base class.
The first is quite straightforward: You simply add brand new methods to the derived class. This means that the base class simply didn't as much as you wanted it to, so you added more methods. This simple and primitive use for inheritance is, at times, the perfect solution to your problem. However, you should look closely for the posiblilty that your base class might also need these additional methods. This process of discovery and iteration of your design happens regularly in OOP.
The second and more important way to differentiate your new class is to change the behavior of an existing base-class method. This is referred to as overriding that method. To override a method, you simply create a new definition for the method in the derived class. You are saying, "I am using the same interface method here, but I want it to do something different for my new type."

4.Is-a vs. is-like-a relationships

5.Interchangeable objects with polymorphism

6The single rooted hierarchy
All objects have a single rooted hierarchy can be guaranteed to have certain functionality. You know you can perform certain basic operations on every object in your system. All objects can easy be created on the heap, and argument passing is greatly simplified.
A single rooted hierarchy makes it much easier to implement a garbage collector, which is one of the fundamental improvements of Java over C++. And since information about the type of an object is guaranteed to be in all objects, you'll never end up with an object whose type you cannot determine. This is especially important with system-level operations, such as exception handling, and to allow greater flexibility in programming.

7.Containers

8.Parameterized types(generics)
One of the big changes in Java SE5 is the addition of parameterized types, called generics in java. you will recongize the use of generics by angle brackets with types inside.

9.Object creation & lifetime
How can you possibly know when to destroy the objects?
(1).C++ takes the approach that control of efficiency is the most important issue, so it give the programmer a choice.
(2).Java, in heap

10 Exception handling: dealing with errors

�?ji��)�?/a> 2008-05-20 13:10 发表评论

Tue, 20 May 2008 04:48:00 GMT
所有的整数�c�d��Q�除了char �c�d��之外�Q�都是有�W�号的整�?br />
因�ؓ�Q?java的byte�?bit�Q�位�Q�，��是8�?/1 来表�C��?br /> 但是�W�一位是�W�号位，表示正数�q�是负数。所以：
0000 0001表示1�Q?nbsp;    �Q?× 2⁰�Q?br /> 0000 0000表示0�Q?nbsp;    �Q?× 2⁰�Q?br />
计算��Z��负数的二�q�制码是是负数的�l�对值取反，然后�?.
例如�Q?的二�q�制�Q?br /> �Q?的绝对值是1�Q?000 0001�Q?
取反是（1111 1110�Q?
再加 1�Q?000 0001 �Q�；
�l�果是（1111 1111�Q?br />
要对一个负数的二进制进行解码，首先对其所有的位取反，然后�?�?br /> 例如�Q?�?nbsp;二进�?nbsp; �Q?111 1111�Q?br /> 取反�Q?nbsp; 0000 0000 �?
再加1�Q�（0�Q?�Q?�Q?br /> �W�号位是1�Q�是负数�Q�所以是�Q?

1000 0000 表示�Q?28�Q?nbsp; �Q�解码过�E�：位取反是0111 1111�Q�＝�?27�Q�然后加1�Q�＝�?28�Q�符号位�?,是负敎ͼ�表示�Q?28�Q?br />

�?ji��)�?/a> 2008-05-20 12:48 发表评论