Java面向对象设计-内置类设计-控件新闻-慧都网

Java面向对象设计-内置类设计

转帖|其它|编辑：郝浩|2010-05-12 12:06:06.000|阅读 606 次

概述：从这篇文章开始进入Java面向对象设计的实战阶段，本文介绍Java内置类设计的最佳实践。

　　从这篇文章开始进入实战阶段的设计阶段，本文介绍内置类设计的最佳实践。

　　回顾一下，类(Class)作为Java编程语言中的基本单元模块，提供了面向对象的四种基本性质：抽象性、封装性、继承性和多态性。

　　在面向对象设计原则中，尽可能偏好方法，而非字段(或属性)。简单的说，方法更好的表达语义。因此，在方法实现过程中，经常会遇到类似的情景，接口方法method1 调用其他方法来完成功能需要。无非有三种情况，利用本类的(静态或者实例的)方法，调用某个类的静态可访问的方法和某个实例可访问的实例方法。但是，良好类设计是尽量的隐藏实现细节，简单清晰地表达语义。

　　客户端程序只关心输入和输出，没有必要去关心中间的细节。回到上述的三情况，尽可能隐藏本类和他类的细节。如果本类和他类相互耦合，那么扩张性和易用性受到一定程度的影响。但是设计人员想让本类和他类相互知晓，或者范围限制(主要是指类之间的访问限制)尽可能小，那么内置类是一个很好的办法。

　　笔者把内置类分为三类：类内置类(Nested Class)，实例内置类(Inner Class)和布局内置类(Local Class)。下面分别介绍这三种类的使用场景和设计方法。

　　类内置类(Nested Class)，在内置类中使用得最多的一类。其作为类的一部分，随外层类(Enclosing Class)顺序地被加载。它的好处是，定义的类内置类仅此一次被创建并加载，可视外层类的类成员。那么使用场景不难得出，对于实例成员不感冒，只关心类成员，并且减少没有必要重复类的创建和加载。在大多数实际情况中，这个模式已经足够了。举一个的JDK里面的例子，迭代Map的时候，键值对实体接口java.util.Map.Entry，其定义在java.util.Map接口中，自然其修饰符是public static final。

　　为了客户端程序能够利用java.util.Map.Entry，JDK暴露了它。一般来说，private final static是通用的设计。外层类对其是完全可视的，因此private 是没有问题的。至于final的修饰，要谈到笔者设计经验中的一个原则，尽量使用final修饰可修饰的。其中有几个好处，比如线程安全、拒绝子类、标准化(在后面的设计文章中会详细说明)等。在内置类设计中，不应该期望其他类继承这个类，更不要期望其他人会使用的内置类了。又回到JDK，大家会发现java.util.HashMap内部定义不少的类内置类。

　　使用下了代码实例补充说明上述：

package org.mercy.design;
/**
* OuterClass 是外层类，NestedClass 类内置类
* @author mercyblitz
*/
public class OuterClass {
/**
* private final static 是类内置类的通用设计技巧
*/
private final static class NestedClass {
}
}

　　代码-1

　　如果OuterClass类中有实例变量的话，显然NestedClass是不可见的，也是不适用的(因为它是类的一部分)。

　　这个时候，利用实例内置类可以解决这类问题。

　　示例代码如下：

package org.mercy.design;
/**
* OuterClass2 是外层类，InnerClass 实例内置类
*
* @author mercyblitz
*/
public class OuterClass2 {
private String message;
/**
* 使用private final 是一种好习惯。:D
*/
private final class InnerClass {
/**
* 输出OuterClass2消息
*/
private void outputMessageFromOuterClass2() {
// 注意，this的命名空间
System.out.println(OuterClass2.this.message);
}
}
}

代码-2

　　在“代码-2”中，InnerClass利用OuterClass2的message字段作为输出。

　　可能有人会说，InnerClass这种实例内，为了得到这个类，不得不创建一个实例，太浪费资源了，为什么不直接把OuterClass实例作为参数，直接传入到InnerClass的方法呢?

　　没错，可以那么做。不过单从访问外层类的实例变量而言，利用实例内置类是有点显得浪费。如果客户端利用了泛型编程的话，情况就会不同。

　　总所周知，泛型设计能够提高灵活性，可是也有很多限制。模版参数类型是跟随其寄主类的，模板参数类型是不会写入class文件中的，这就是为什么反射(Reflection)不能解析出类的模板参数类型。但是，模板参数类型在实例(对象)范围是可用的(或可视的)。如果内置类中想要利用外层类的模板参数类型的话，那么实例内置类就有很大用处。

　　例子如下：

package org.mercy.design;
/**
* OuterClass3 是外层类，InnerClass 实例内置类
*
* @author mercyblitz
* @param
* 模板参数类型，实例内置类可以利用
*/
public class OuterClass3 {
private T data;
/**
* 使用private final 是一种好习惯。:D
*/
private final class InnerClass {
public void setData(T newData) {
OuterClass3.this.data = newData;
// DOES Other things
}
}
}

　　代码-3

　　“代码-3”中的实例内置类利用外层类OuterClass3中的模板参数T，作为setData参数的类型。

　　看似类内置类和实例内置类已经足够使用了。考虑这么一个场景，一个方法利用了内置类来实现功能，这个方法中的变量需要被内置类来利用，通常可以把变量作为参数，传入内置类构造器或者其方法中，这也是通常的方法。不过利用布局内置类(Local Class)更为方便，因为局部内置类是在块中(方法也是一种特殊的块)定义的，这样就很好的解决了上下文的参数传递问题。

　　参看代码：

package org.mercy.design;
/**
* OuterClass4 是外层类，Printer 局部内置类
*
* @author mercyblitz
*/
public class OuterClass4 {
public void print(byte[] bytes) {
final String message = new String(bytes);
/**
* 名为Printer LocalClass，不必把message作为参数传递。
*/
class Printer {
private void doPrint() {
System.out.println(message);
}
}
new Printer().doPrint();
}
public static void main(String[] args) {
new OuterClass4().print("AAAAAAA".getBytes());
}
}

　　代码-4

　　在“代码-4”的示例中，有人可能会说，这看不出什么好处呀?!如果内置类依赖的变量超过4个(Effective Java书中提到超过四个参数的话,不利于维护)，那么局部内置类是不是方便维护呢?

　　顺便提到，匿名内置类是局部内置类的一种。

　　不难发现，局部内置类的缺点是代码混杂(方法和类混在一起)，如果依赖局部变量不多的情况下，在一定程度上面，增加了维护成本。

　　最后的篇幅来总结一下这几种内置类的特点，以及使用场景和设计技巧。

　　共同特点，不想暴露并且不期望被外部使用或者扩张(强调一下，一般类中私有和包内私用都是好的设计技巧)，通过类的四大特性提供更优于方法的方法和外部内实现交互，从而达到良好设计目的。

　　对于类内置类(Nested Class)，适合的绝大多数内置类场景，利于维护。但不适合利用外层类模板参数类型和实例变量。

　　就实例内置类(Inner Class)，适合利用外层类模板参数类型和实例变量，更好的弹性设计。可是加载其类时，必须实例化外部类，造成不必要开销，因此不是必须，尽量使用类内置类。

　　局部内置类(Local Class)，适合多局部变量依赖的场景，提高可维护性，相反就不适合。

　　因此，内置类的设计和其他面向对象设计类似，根据适合的场景来合理设计。

标签：

本站文章除注明转载外，均为本站原创或翻译。欢迎任何形式的转载，但请务必注明出处、不得修改原文相关链接，如果存在内容上的异议请邮件反馈至chenjj@pclwef.cn