BlogJava--随笔分类-Java Study(JavaThinking4)

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

九宝 — Sun, 13 Feb 2011 11:24:00 GMT

引言：
         设计模式是经验的文档化。它是对被用来在特定场景下解决一般设计问题的类和相互通信的对象的描述。更通俗的来说，它是一个问题/解决方案对。一旦我们掌握了设计模式，就等于拥有了一支强有力的专家队伍。它甚至能够使面向对象的新手利用前人的经验找出职责明确的类和对象，从而获得优雅的解决方案。由于设计模式也是重构的目标，如果在设计的初期适当地引入设计模式，可以减少重构的工作量。
   但是，我们也不能陷入模式的陷阱，为了使用模式而去套模式，那样会陷入形式主义。我们在使用模式的时候，一定要注意模式的意图（intent），而不要过多的去关注模式的实现细节，因为这些实现细节在特定情况下，可能会发生一些改变。不要顽固地认为设计模式一书中的类图或实现代码就代表了模式本身。
   下面，我们来讨论一下为什么要在分布式、多层系统中使用Observer模式。

多层体系结构（multi-tier architecture）：
三层体系结构是多层体系结构中最简单的一种，它一般包括：

表示层(presentation)－窗口、报表-
业务逻辑层(business logic)－管理业务过程的任务和规则。它又可以细分为领域对象层（代表领域概念）和服务层（提供数据库交互、安全性、打印报表）。
存储层(storage)－持久化存储机制。如数据库服务器等。

图一：三层体系结构

   而Java 2平台企业版（J2EE）是一种利用Java 2平台来简化诸多与多级企业解决方案的开发、部署和管理相关的复杂问题的体系结构。它是开放的、基于标准的平台，用以开发、部署和管理N层结构、面向Web的，以服务器为中心的企业级应用。
   为了支持领域对象的复用，并且使领域对象的接口变更所带来的影响最小化。我们将领域层（模型）和表示层（视图）相分离。
   采用模型－视图模式的意义在于：

支持聚合度更高的模型定义，使模型的定义可以集中在领域过程的定义，而不是图形界面上。
允许将模型和用户界面并行开发。
使用户界面的需求变化对领域层所造成的影响最小化。
允许建立与一个现有的领域层对象相连接的新视图，同时不影响领域层。
允许一个模型同时有多个视图，例如使用SVG和表格。
允许模型层独立于用户界面层执行。

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

值传递还是远程引用传递？
                  值传递：
在Java RMI中要求所有的参数和返回类型是JAVA的基本类型或实现Java.io.Serilizable的对象。串行化对象通过值传递（又名拷贝传递），而不是引用传递，这意味着在某一层中串行化对象的更并不自动影响到其它的对象。
            远程引用传递：
对于EJB对象而言，它由两个接口（home接口和remote接口）和一个类组成。容器会根据ejb规范来生成实现上面两个接口的类（我们分别称为xxxEJBHome对象和xxxEjbObject对象）。在较多的容器的实现方案中，xxxEJBHome对象使用了factory模式来创建xxxEjbObject对象；xxxEjbObject对象则采用proxy模式，作为xxxBean的代理类。在生成以上两个对象的同时，容器会从部署文件中读取关于安全、事务、持久性等服务并在xxxEjbObject对象和xxxEJBHome对象中添加以上服务的代码。而且xxxEJBHome对象和xxxEjbObject对象都是分布式对象，我们在此只讨论xxxEjbObject对象。所谓分布式对象，从本质上来讲，分为3个部分：object server、skeleton、stub。其中object server和skeleton位于服务器端，而stub位于客户端。Object server负责实现业务逻辑，skeleton负责marshal和unmarshal方法签名。

图二：分布式对象

   显然，EJB的客户（调用EJB的对象）可以是任何对象，包括EJB和一般的Java类甚至是用任何语言写的corba客户端。
   从EJB的客户视角来看的话，我们只能看到一个home接口、一个remote接口（对于实体bean的话，还可以看见一个主键类，而bean类对客户是不可见的）。但我们从上面的论述，我们可以知道，对于remote接口中地方法调用，实际上是多态地调用XXX_Stub类。即XXX_Stub对象对客户具有可见性（但这种可见性是透明的，即客户不知道这种可见性的存在）。由于，XXX_Stub对象和Object Server实现了相同的接口，并且Object server真正实现了业务逻辑。所以，当在客户端调用XXX_Stub对象的方法时候，XXX_Stub对象通过socket通信机制将方法签名传给XXX_Skeleton对象，XXX_Skeleton对象在去委托Object Server完成业务处理逻辑。因此，Object Server本身发生了改变。我们称XXX_Stub对象是Object Server对象的远程引用，并认为当分布式对象作为参数传递的时候，是通过引用传递的（会产生副作用

九宝 2011-02-13 19:24 发表评论

JavaBean PropertyChange 之设计模式Observer(转)

九宝 — Sun, 13 Feb 2011 10:26:00 GMT

摘要: java语言里包含了许多对设计模式的直接支持，如command模式，agent模式，observer模式等。虽然java提供的对这些模式的支持很简单，不能满足比较复杂的应用。但在简单的场景下，使用这些类往往能够得到立杆见影的效果。所以，如果没有什么特殊需求，还是最好利用java的这些类。 Observ... 阅读全文

九宝 2011-02-13 18:26 发表评论

(转)UML中类图实例

九宝 — Sat, 12 Feb 2011 05:02:00 GMT

接口：空心圆+直线（唐老鸭类实现了‘讲人话’）；
依赖：虚线+箭头（动物和空气的关系）；
关联：实线+箭头（企鹅需要知道气候才迁移）；
聚合：空心四边形+实线+箭头（雁群和大雁的关系）；
合成/组合：实心四边形+实线+箭头（鸟和翅膀的关系）；
泛化/继承：空心三角形+实线（动物和鸟的继承关系）；
实现：空心三角形+虚线（实现大雁飞翔的接口）；

UML类图

解释UML类图：
1. 首先看“动物”矩形框，它代表一个类。该类图分为三层，第一层显示类的名称，如果是抽象类就要用斜体显示。第二层是类的特性，通常就是字段和属性。第三层是类的操作，通常是方法和行为。
注意前面的符号，‘+’表示public, ‘—’ 表示private, ‘#’表示protected.
2. “飞翔”矩形框表示一个接口图，它与类图的区别主要是顶端有《interface》显示，第一行是接口名称，第二行是接口方法。接口还有另一种表示方法，俗称棒棒糖表示法，就是唐老鸭类实现了“讲人话”的接口。

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

3. 动物，鸟，鸭，唐老鸭他们之间都是继承的关系，继承关系用空心三角形+实现来表示。


4.“大雁”实现了“飞翔”接口。实现接口用空心三角形+虚线来表示。（注：下面的图中应为空心三角形）


class Bird:Animal                      class WideGoose:IFly {                                        { //继承动物类                                 //实现飞翔接口 }                                        }

5. 企鹅与气候有很大的关系，企鹅需要“知道”气候的变化，需要“了解”气候规律。当一个类“知道”另一个类时，可以用关联(association)关系。关联关系用实线箭头来表示。


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

6. “大雁”和“雁群”这两个类。大雁是群居动物，每只大雁都属于一个雁群，一个雁群可以有多只大雁。所以它们之间就满足聚合(Aggregation)关系。聚合表示一种弱的“拥有”关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分。聚合关系用空心的菱形+ 实线箭头表示。


class WideGooseAggregate { private WideGoose[] arrayWideGoose; //在雁群WideGooseAggregate类中，有大雁数组对象arrayWideGoose }

7. “鸟”和“翅膀”这两个类。鸟和翅膀似整体和部分的关系，并且翅膀和鸟的生命周期是相同的，在这里鸟和其翅膀就是合成关系。合成(composition)是一种强的“拥有”关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样。合成关系用实心的的菱形+实线箭头来表示。另外，合成关系的连线两端还有一个数字“1”和数字“2”，，这被称为基数。表明这一端的类可以有几个实例，很显然，一个鸟应该有两支翅膀。如果一个类可能有无数个实例，则就用“n”来表示。关联关系，聚合关系也可以有基数的。

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

8. “动物”、“氧气”与“水”之间。动物有几大特征，比如有新陈代谢，能繁殖。而动物要有生命，需要氧气，水以及食物等。也就是说动物依赖于氧气和水。它们之间是依赖关系(Dependency),用虚线箭头来表示。



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

九宝 2011-02-12 13:02 发表评论

Bitwise operators and Shift operators

九宝 — Tue, 20 May 2008 05:22:00 GMT

位运算符与逻辑运算符基本相似，不过后者的对象只是表示真和假的二值运算，位运算符的对象则是二进制数。Java语言中字节、字符和整数等都可以转换为二进制，所以位运算符的对象也可以是它们。常见位运算符有：
按位进行与运算： &
按位进行或运算： |
按位进行位异运算： ^
按位进行取反运算： ~
按位进行循环左移：<<，运算符左侧对象左移由右侧指定的位数，低位补0，最高位抛弃。带符号的左移位运算相当于对左操作数进行乘2运算。
按位进行循环右移：>>，运算符左侧对象右移由右侧指定的位数，若值为正，在最高位插入0，若值为负，在最高位插入1，即移入的最高位和原最高符号位相同。带符号的右移位运算相当于对左边的运算对象进行除2运算。
按位进行无符号右移：>>>，无论运算符左边的运算对象取值正负，都在高位插入0，即移入位始终补0.
要注意是没有按位进行无符号左移的。位运算符的操作数只能是整数，char,byte,short,
int和long,进行位运算时，总是先将字符型值、字节型值和短整型值转换为整型再进行位运算。位运算符游标的操作数用于指定移动的位数，按规定其不应超过左侧数的进制表示位数。
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.

九宝 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＝1×16²＋2×16¹＋3×16⁰

九宝 2008-05-20 13:12 发表评论

整型数据

九宝 — Tue, 20 May 2008 05:10:00 GMT

三种形式的整型常量数据：
1.十进制
2.八进制，以o开头O123＝1×8²＋1×8¹＋3×8⁰＝十进制的83
3.十六进制，以ox开头 OX123＝1×16²＋2×16¹＋3×16⁰

九宝 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

九宝 2008-05-20 13:10 发表评论

java byte类型为什么是（127—— －128）

九宝 — Tue, 20 May 2008 04:48:00 GMT

所有的整数类型（除了char 类型之外）都是有符号的整数

因为， java的byte是8bit（位），就是8个0/1 来表示。
但是第一位是符号位，表示正数还是负数。所以：
0000 0001表示1，     （1× 2⁰）
0000 0000表示0，     （0× 2⁰）

计算机中负数的二进制码是是负数的绝对值取反，然后加1.
例如－1的二进制：
－1的绝对值是1（0000 0001）;
取反是（1111 1110）;
再加 1（0000 0001 ）；
结果是（1111 1111）

要对一个负数的二进制进行解码，首先对其所有的位取反，然后加1。
例如－1的二进制   （1111 1111）
取反： 0000 0000 是0
再加1：（0＋1＝1）
符号位是1，是负数，所以是－1

1000 0000 表示－128，   （解码过程：位取反是0111 1111＝＝》127，然后加1＝＝》128，符号位为1,是负数，表示－128）

九宝 2008-05-20 12:48 发表评论