久久精品蜜芽亚洲国产AV,亚洲妇女无套内射精,亚洲一欧洲中文字幕在线

JustinLei — Tue, 15 Nov 2005 06:25:00 GMT

描述�Q?br>
　　计数代理模式在客户对象调用服务提供者对象上�Ҏ��的前后执行诸如日志（logging�Q�和计数�Q�counting�Q�一�p�d��附加功能时很有用。计��C��理模式徏议把�q�些附加功能��装在一个单独的对象�Q�这个对象就是指计数代理对象�Q�而不是把�q�些附加的功能实现放到服务提供者的内部。良好的对象设计的一个特征就是对象要专注于提供特定的功能。换句话��_��理想的对象不应该做各�U�不相干的事情。把诸如日志�Q�logging�Q�和计数 �Q�counting�Q�等�c�M��的功能封装�ؓ一个单独的对象�Q�而让服务提供者对象仅提供它自��q��特定功能。也��是��_��只允许服务提供者对象执行定义良好、特�? 的�Q务�?br>
　　计数代理被设计成可以被客戯��问的与服务提供者具有相同接口的对象。客户对象不是直接访问服务提供者，而是调用计数代理对象上的�Ҏ��Q�计��C��理执行必要的�U�录日志�Q�logging�Q�和计数�Q�counting�Q�功能后�Q�再把方法调用传递给服务提供着对象。如�?

Figure1: Generic Class Association When the Counting Proxy Pattern Is Applied

　　下面的例子说明了如何在应用程序中利用计数代理�?br>
　　例子�Q?br>
　　让我们设计一个Order�c�，�c�d��ơ如�?�Q�OrderIF接口声明了getAllOrders��d��数据库中所有订单的��单方法�?br>

Figure2: Order Class Hierarchy

public interface OrderIF {
public Vector getAllOrders();
}

　　作�ؓgetAllOrders�Ҏ��实现的一部分�Q�Order�c�d��用了FileUtil工具�c�M��order.txt文�g中读取订单项�?br>

public class Order implements OrderIF {
　public Vector getAllOrders() {
　　FileUtil fileUtil = new FileUtil();
　　Vector v = fileUtil.fileToVector("orders.txt");
　　return v;
　}
}

　　让我们假定在调用getAllOrders()�Ӟ��需要把取数据文件所��p��的时间和记录条数要记录的log日志文�g中�?br>
　　�q�个附加的功能可以设计一个单独的OrderProxy�c�L��实现�Q�它与真实对象Order一样实现OrderIF接口。这样保证了OrderProxy对象提供�l�客户与真实对象Order一��L��接口。如�?

Figure3: Order Class Hierarchy with the Counting Proxy

public class OrderProxy implements OrderIF {
　private int counter = 0;
　public Vector getAllOrders() {
　　Order order = new Order();
　　counter++;
　　long t1 = System.currentTimeMillis ();
　　Vector v = order.getAllOrders();
　　long t2 = System.currentTimeMillis();
　　long timeDiff = t2 ? t1;
　　String msg = "Iteration=" + counter + "::Time=" + timeDiff + "ms";
　　//log the message
　　FileUtil fileUtil = new FileUtil();
　　fileUtil.writeToFile("log.txt�?msg, true, true);
　　return v;
　}
}

　　客户对象MainApp��想调用真实对象Order一栯��用OrderProxy对象上的getAllOrders()�Ҏ��Q�OrderProxy对象传递这个调用给真实对象Order,计算��d��所有订单所��p��的时间�ƈ使用FileUtil帮助�c�d��其纪录的log日志文�g中。在�q�个�q�程中， OrderProxy扮演者计��C��理的角色�?br>
public class MainApp {
　public static void main(String[] args) {
　　OrderIF order = new OrderProxy();
　　Vector v = order.getAllOrders();
　　v = order.getAllOrders();
　　v = order.getAllOrders();
　　v = order.getAllOrders();
　}
}

JustinLei 2005-11-15 14:25 发表评论

JAVA的类反射

JustinLei — Tue, 15 Nov 2005 06:24:00 GMT

/**
* �c�d��实现动态类调用
* @param instance 一个信息获取类的实�?br> * @param methodName �Ҏ��名称
* @param classes 参数�c�d��数组
* @param objects 参数数组
* @return Object �q�回了方法执行后的结�?br> */
private Object invokeInstanceMethod(
            final Object instance, final String methodName,
   final Class[] classes, final Object[] objects) {
        try {
            Method method;
            try {
                method = instance.getClass().getDeclaredMethod(methodName, classes);
            }
            catch (NoSuchMethodException e) {
                method = instance.getClass().getMethod(methodName, classes);
            }
            method.setAccessible(true);
            return method.invoke(instance, objects);
        }
        catch (NoSuchMethodException e) {
            throw new RuntimeException(e.getMessage());
        }
        catch (IllegalAccessException e) {
            throw new RuntimeException(e.getMessage());
        }
        catch (InvocationTargetException e) {
            throw new RuntimeException(e.getTargetException().getMessage());
        }
    }

/* �Q�非 Javadoc�Q?br> * @see com.eware.dataBaseOperation.dataOperateToolKit
* .dataBaseOperate.InterFaceGetOwnerDataInfo#getOwnerTables()
*/
/**
* 实现了接口方法获取当前用��h��有表的信�?br> */
public ResultSet getOwnerTables() {
  // TODO 自动生成�Ҏ��存根
  return (ResultSet)invokeInstanceMethod(goic, "getOwnerTables",
    new Class[]{}, new Object[]{});
}

JustinLei 2005-11-15 14:24 发表评论

JAVA内部�cȝ��基本特征

JustinLei — Tue, 15 Nov 2005 06:23:00 GMT

内部�c�L��Java语言一个重要的基本�Ҏ��，�?/span>Java开发的许多领域都会�l�常用到。内部类的定义说��单一点就是将一个类定义在另外一个类的内部。内部类允许你把一些逻辑相关的类�l�织在一��P��控制内部�c�M��码的可视性，它和�cȝ��l�合是完全不同的概念。内部类主要有以下比较关键的�Ҏ��：

1. 普通的非内部类不能被声明�ؓprivate�?/span>protected�Q�否则就失去了创��cȝ��意义。但是内部类通常可以被声明�ؓprivate�?/span>protected�c�d��Q�因��样可以防止他人对该内部类实现的功能进行修改，辑ֈ�隐藏实现�l�节的目的。例如：

class Fruit {

private class Weight {

private String i;

private Weight(String j) {

i = j;

}

public String read() {

return i;

}

class test {

public static void main(String[] args) {

Fruit f = new Fruit();

f.Weight w = f.new Weight(); //不能讉K��private�c�，如果Weight�?/span>protected�c�d��则可�?/span>

}

2. 在方法或某控制语�?/span>(if/for/while�{?/span>)的作用域内定义内部类�Q�将只能在该范围内调用内部类的方法和成员变量�?/span>

3. 匿名内部�c�L��一�U�特�D�的内部�c�，如果希望它��用一个在其外部定义的对象�Q�那么编译器会要求其参数引用�?/span>final的�?/span>

public class Fruit {

public Tea cont(final int j) {

return new Tea() {

private int i = j;

public int read() {

return i;

}

}; //注意�q�里的分�?/span>

}

public static void main(String[] args) {

Fruit f = new Fruit();

Tea t = f.cont;

}

而当�Ҏ��cont(final int j)中的参数j只是被传递到匿名�c�M��的构造器�Ӟ��可以不用被声明�ؓfinal�c�d��Q�如return new Tea(j)。这里提��C��匿名内部�cȝ��构造器�Q�那么它是怎么被初始化的呢�Q?/span>

public class Fruit {

public Tea cont(int j) {

return new Tea(j) {

System.out.println(j);

};

}

�q�可以这样初始化匿名内部�c�：

public class Fruit {

public Tea cont(final int j) {

return new Tea(j) {

int i;

// 初始化匿名内部类

{

i = j;

System.out.print(i);

}

};

}

�Ҏ��cont()可以被称为实例初始化�Ҏ��Q��得匿名内部类通过构造器而被初始化，在实际应用中�Q�我们不能重载实例初始化�Ҏ��Q�因为匿名内部类只能有一个构造方法�?/span>

JustinLei 2005-11-15 14:23 发表评论

JustinLei — Tue, 15 Nov 2005 06:21:00 GMT

JAVA中的�c�d��存在于一个体�pȝ��构中.在JAVA中，一个类可以通过使用extends关键字声明�ؓ另一个类的子�c?subclass)。子�c�d�� 以从其超�c�（superclass�Q��承（inherit�Q�变量和�Ҏ��Q��ƈ加以使用�Q�就如同�q�些变量和方法由该子�c�L��w�所声明的一��P��

class Animal {
    float weight;
    ...
    void eat() {
...
    }
    ...
}

class Mammal extends Animal {
    int heartRate;
    //�l�承weight
    ...
    void breathe() {
...
    }
    //�l�承eat
}

�c�d��能扩展另外的一个类。只支持单��承（single inheritance�Q��?/p>

子类可以�q�一步派生子�c�R�?/p>

JustinLei 2005-11-15 14:21 发表评论

JustinLei — Tue, 15 Nov 2005 06:21:00 GMT

虚拟代理模式(Virtual Proxy)是一�U�节省内存的技术，它徏议创建那些占用大量内存或处理复杂的对象时�Q�把创徏�q�类对象推迟��C��用它的时候。在特定的应用中�Q�不同部分的功能 �׃��同的对象�l�成�Q�应用启动的时候，不会立即使用所有的对象。在�q�种情况下，虚拟代理模式��推迟对象的创建直到应用程序需要它为止。对象被应用�W�一�ơ引用时创徏�q�且同一个实例可以被重用。这�U�方法优�~�点�q�存�?

　　优点�Q?br>
　　�q�种�Ҏ��的优�Ҏ��Q�在应用�E�序启动�Ӟ��׃��不需要创建和装蝲所有的对象�Q�因此加速了应用�E�序的启动�?br>
　　�~�点:

　　因�ؓ不能保证特定的应用程序对象被创徏�Q�在讉K��q�个对象的�Q何地方，都需要检��确认它不是�I?null)。也��是�Q�这�U�检��的旉��消耗是最大的�~�点�?br>
　　应用虚拟代理模式�Q�需要设计一个与真实对象��h��相同接口的单独对象（指虚拟代理）。不同的客户对象可以在创建和使用真实对象地方用相应的虚拟对象来代 �ѝ��虚拟对象把真实对象的引用作为它的实例变量维护。代理对象不要自动创建真实对象，当客户需要真实对象的服务�Ӟ��调用虚拟代理对象上的�Ҏ��Q��ƈ且检��真实对象是否被创徏�?br>
　　如果真实对象已经创徏�Q�代理把调用转发�l�真实对象，如果真实对象没有被创建：

　　1�Q?代理对象创徏真实对象

　　2�Q?代理对象把这个对象分配给引用变量�?br>
　　3�Q?代理把调用�{发给真实对象

　　按照�q�种安排�Q�验证对象存在和转发�Ҏ��调用�q�些�l�节对于客户是不可见的。客户对象就像和真实对象一样与代理对象�q�行交互。因此客户从��真实对象是否�ؓ null中解脱出来，另外�Q�由于创��Z��理对象在旉��和处理复杂度上要��于创徏真实对象。因此，在应用程序启动的时候，用代理对象代替真实对象初始化�?br>
　　例子�Q?br>
　　假设我们建立一个JAVA�E�序的集成开发环境（Integrated Development Environment�Q?�q�个环境包括三个功能�Q�编译、运行、生成JavaDoc文��。在新徏和编辑Java�E�序�Ӟ��最为常用的是编译和�q�行。至于生�? JavaDoc文��对于每一个Java�E�序不是必需的。因此，在Java开发环境启动时�Q�不要创建和装蝲实现集成开发环境全部功能的所有对象，仅创建那�? 在编辑、编译、运行时用到的对象，保留提供生成JavaDoc文档的对象，�q�是一个好的设计思想。这�U�对象创建策略能够高效地利用内存�I�间�q�且加快了集�? 开发环境的启动速度�?br>
　　假设�~�译、运行、生成JavaDoc文��q�些功能分别�׃��个工��L��提供??Compiler、Runtime和JavaDoc。客户对象可以访问的不同IDE操作的接口以抽象�c�IDEOperation的�Ş式定义�?br>

public abstract class IDEOperation {
　private Compiler cmp;
　private Runtime rtime;
　public void compile(String javaFile) {
　　cmp.compile(javaFile);
　}
　public void run(String classFile) {
　　rtime.run (classFile);
　}
　//to be delayed until needed.
　public abstract void generateDocs(String javaFile);
　public IDEOperation() {
　　cmp = new Compiler();
　　rtime = new Runtime();
　}
}

　　�c�IDEOperation提供了编译、运行java�E�序�Ҏ��的实玎ͼ�作�ؓ它构造函数的一部分�Q�IDEOperation创徏和装载了�q�行�~�译和执行操作的Compiler和Runtime对象。生成JavaDoc文档的方法generateDocs�Ҏ��被设计成抽象的方法，由它的子�c�L��实现�?br>
　　让我们定义抽象类IDEOperation的一个具体子�c�RealProcessor。作为RealProcessor构造函数的一部分�Q�创建JavaDoc对象来提供生成JavaDoc文档的服务，通过使用JavaDoc对象功能实现generateDocs�Ҏ��?br>

public class RealProcessor extends IDEOperation {
　JavaDoc jdoc;
　public RealProcessor() {
　　super();
　　jdoc = new JavaDoc();
　}
　public void generateDocs(String javaFile) {
　　jdoc.generateDocs(javaFile);
　}
}

　　通过上面的实玎ͼ�RealProcessor�c�d��含了�~�译、运行和生成JavaDoc文��的所有功能。像我们原来讨论的，生成JavaDoc文档的功�? 不是每一个Java�E�序所必须的，当RealProcessor实例化的时候，包括负责生成JavaDoc文档的JavaDoc对象的一�p�d��对象被创建�? 推迟创徏JavaDoc对象有以下优点：

　　1�Q?加速了RealProcessor对象的创建时��_��因�ؓ它的构造函数创建的很少的对象�?br>
　　2�Q?高效地利用内存，因�ؓ在不需要对象服务的时候，不需要把对象保持在内存中�?br>
　　在不改变RealProcessor实现的前提下�Q�可以通过定义IDEOperation的另外一个子�c�ProxyProcessor来实现虚拟代理�? 因�ؓRealProcessor和ProxyProcessor�׃�n相同的接口，客户对象可以用ProxyProcessor代替 RealProcessor。图25.1展示了类层次�Q?br>

Figure 25.1: IDEOperation Class Hierarchy

public class ProxyProcessor extends IDEOperation {
　private RealProcessor realProcessor;
　public void generateDocs(String javaFile) {
　　/*
　　In order to generate javadocs
　　the proxy loads the actual object and
　　invokes its methods.
　　*/
　　if (realProcessor == null) {
　　　realProcessor = new RealProcessor();
　　}
　　realProcessor.generateDocs(javaFile);
　}
}

　　作�ؓ自己的实例变量，ProxyProcessor�l�护了RealProcessor对象的一个引用。作为generateDocs�Ҏ��的一部分�Q? ProxyProcessor��引用变量是否被初始化�ؓRealProcessor对象。如果没有被初始化，它创��Z��个RealProcessor对象 �q�把�q�个对象分配�l�它的实例变量。一旦RealProcessor对象已经被创建，��p��用其上的generateDocs�Ҏ��?br>
　　实际上，也就是当客户对象�W�一�ơ请求��生javadoc文��Ӟ��RealProcessor才被初始化装入内存中。反�q�来�Q�直到客户需要�ؓJava�E�序生成javadocs�Ӟ��JavaDoc对象才会被创建和装入内存中�?br>
　　客户对象像调用真实处理对象一栯��用ProxyProcessor上的�Ҏ��Q��ƈ不需要关心（知道�Q�RealProcessor对象是否存在�?至于验证、检��和ProxyProcessor和RealProcessor之间的交互、这��L��l�节对于客户对象是透明的�?br>

public class Client {
　public static void main(String[] args) {
　　/*
　　At this point objects required for
　　the compile and run operations are
　　created, but not the objects that provide the
　　generate Javadoc functionality.
　　*/
　　IDEOperation IDE = new ProxyProcessor();
　　IDE.compile("test.java");
　　IDE.run("test.class");
　　/*
　　The Javadoc functionality is accessed
　　For the first time and hence the
　　Object offering the Javadoc generation
　　Functionality is loaded at this point.
　　*/
　　IDE.generateDocs("test.java");
　}
}

JustinLei 2005-11-15 14:21 发表评论

Eclipse家族法则(扩展�?

JustinLei — Tue, 15 Nov 2005 06:20:00 GMT

扩展�?/strong>

1. 贡献法则(Contributin Rule):一切皆是�A�?/font>

2.遵��@法则(Conformance Rule):插�g必须遵��@预期的接�?/font>

3.�׃�n法则(sharing Rule):增加,不要取代

4.有样学样法则(Monkey See/Monkey Do Rule):遇到问题�?首先复制�c�M��插�g的结�?/font>

5.相关性法�?Relevance Rule):只有在操作有可能成功时才昄��你所贡献的操�?/font>

6.整合法则(Integration Rule):要整合不要分�?/font>

7.责�Q法则(Responsibility Rule):明确指出你开发的插�g旉��题的源头

8.针对API契约�~�程法则(Program To API Contract Rule):首先��查Eclipse API契约,然后后针对契�U�编�E?/font>

9."其他"法则(Other Rule):让用户可以选择所有东�?但把那些通常不用于当前视角的选项攑֜�Other...对话框中

10.IResource适配法则(Adapt To IResource Rule):应该��量为领域对象定义IResource适配�?/font>

11.分层法则(Strata Rule):��语�a�无关的功能与特定于具体语�a�的功能分开,��核心功能与UI功能分开

12.使用�q�诏性法�?User Continuity Rule):在多�ơ回话期�?应该保持用户界面状态一�?/font>

JustinLei 2005-11-15 14:20 发表评论

JustinLei — Tue, 15 Nov 2005 06:15:00 GMT

��句柄传递进入一个方法时�Q�指向的仍然是相同的对象�?/p>
public class PassHandles {
          static void f(PassHandles h) {
          System.out.println("h inside f(): " + h);
}
          public static void main(String[] args) {
                    PassHandles p = new PassHandles();
                    System.out.println("p inside main(): " + p);
          f(p);
         }
}

toString �Ҏ��会在打印语句里自动调用，而PassHandles 直接从Object �l�承�Q�没有toString 的重新定义�?br>因此�Q�这里会采用toString 的Object 版本�Q�打印出对象的类�Q�接着是那个对象所在的位置�Q�不是句柄，�?br>是对象的实际存储位置�Q�。输出结果如下：
p inside main(): PassHandles@1653748
h inside f() : PassHandles@1653748
可以看到�Q�无论p �q�是h 引用的都是同一个对象。这比复制一个新的PassHandles 对象有效多了�Q��我们�?br>��一个参数发�l�一个方法。但�q�样做也带来了另一个重要的问题�Q�别名问�?/p>

JustinLei 2005-11-15 14:15 发表评论

Eclipse家族法则(促成�?

JustinLei — Tue, 15 Nov 2005 06:15:00 GMT

促成�?

1.邀��h��?Invitation Rule):��可能的邀请别��Zؓ你的作品做出贡献

2.懒加载法�?Lazy Loading Rule):只有在真正需要的时候才加蝲插�g

3.安全�q�_��法则(Safe Platform Rule):作�ؓ扩展点的提供�?你必��M��护好自己,不要让扩展者的误操作给你造成损失

4.公��^竞赛法则(Fair Play Rule):所有��用者遵守同��L��游戏规则,包括我自�?/p>
5.明确扩展法则(Explicit Extension Rule):明确说明�q�_��的什么地方可供扩�?/p>
6.发散性法�?Diversity Rule):一个扩展点接纳多个扩展

7.良好防�M法则(Good Fences Rule):如果要交出程序的控制�?首先保护好你自己

8.用户军_��法则(User Arbitration Rule):如果有多个选择,��q��户决定��用哪�?/p>
9.明确API法则(Explicit API Rule):��API与插件内部��用的�c�d��开

10.�E�_��性法�?Stability Rule):如果你已�l�开始邀请其他�h作出贡献,��׃��要再改变规则

11.保守API法则(Defensive API Rule):只暴露你有信心的API,但同时也要做好准备暴露更多的API,因�ؓ使用者会邀请你�q�样�?/p>

JustinLei 2005-11-15 14:15 发表评论

Thread�c�d��Runnable接口

JustinLei — Tue, 15 Nov 2005 06:14:00 GMT
在创建java.lang.Thread�cȝ��一个实例时��׃��"诞生"一个新�U�程。Thread对象表示Java
解释器中一个实际的�U�程�Q��ƈ作�ؓ控制和协调其执行的一个句柄。利用Thread对象�Q�可以启动线�E��?br> �{�待其完成、要求它睡眠一�D�|��_��或者时中断其活动。Thread�cȝ��构造函数可接受�U�程应当在哪�?br> 开始执行等�{�有关的信息。从概念上说�Q�我们只希望告诉它所要运行的�Ҏ��Q�但是由于Java中不存在
�Ҏ��指针�Q�至��没有这�U�意义的�Ҏ��指针�Q�，因此我们�q�不能直接指定方法。与此不同，必须采取一�U?br> �q�回�U��\�Q�即使用java.lang.Runnable接口来创��Z��个对象，此对象中包含一个“可�q�行”的斏V�?br> Runnable接口只定义了唯一的一个通用�Ҏ��?br> public interface Runnable {
abstract public void run();
}
每个�U�程的生命周期都始于执行Runnable对象中的run()�Ҏ��。此对象是传递给�U�程构造函
数的“目标对象”。run()�Ҏ��可以包含��M��代码、但它必��L��公共的，不仅没有��M��实参�Q�而且也没
有返回��|��另外不会抛出��M��受查异常�?br> ��M��包含有合适的run()�Ҏ��的类都可以声明它实现了Runnable接口。此�cȝ��实例��是一�?br> 可运行的对象�Q�它可以作�ؓ一个线�E�的目标。如果不希望��run()直接攑֜�对象中（而且通常不会�q�样
做）�Q�则可以建立一个适配器类�Q�由它作��Z��个Runnable�c�R��适配器的run()�Ҏ��则能够在�U�程启动

后调用�Q何需要的�Ҏ��

JustinLei 2005-11-15 14:14 发表评论

ANT

JustinLei — Tue, 15 Nov 2005 06:12:00 GMT
Ant的构建文件是用XML�~�写的与大多数实际应用中的构建文件相比，它要��单一些，但确实能够说明几乎每个Java 工程所需的一些核心概��c�?br>

description="Compiles all source code.">

description="Generates test.jar in the 'dist' directory.">

basedir="${build.classes}"
excludes="**/*Test.class"/>

description="Cleans, compiles, then builds the JAR file."/>

JustinLei 2005-11-15 14:12 发表评论