Skynet

1. HttpUnit



Jetty

airlines 航空公司
XX is one of the most well-known airlines in the world.

square 广场
the are 4 statues,and fuontains,in the middle of Trafalgar square in Londen.

understand 理解
I wish he'd speak slower,I don't understand him.

参考：http://caterpillar.onlyfun.net/GossipCN/JUnit/JUnitGossip.htm

1. TestSuite
  public static Test suite() {
     TestSuite suite = new TestSuite(MathTool.class);
     suite.addTest(new MathToolTest("testGcd"));
  }

2.全局属性
    protected void setUp() throws Exception {
        super.setUp();
        arr = new ............;
    }

    protected void tearDown() throws Exception {
        super.tearDown();
        arr = null;
    }

3. Cactus
web设置 

http://caterpillar.onlyfun.net/GossipCN/JUnit/FirstCactusWithTomcat.htm
http://caterpillar.onlyfun.net/GossipCN/JUnit/FirstCactusWithJetty.htm

                我的编码标准。（随时间完善）
1. 建立工作区
       -bin 编译地点,-lib 包，-javadoc doc,
       -src 源码区
          |-设计功能包
             |-interface 功能描述接口
             |+com 功能实现包
             |-test 测试区
                 |-support  功能可行分析
                 |-unit     单元测试
                 |-api      使用文档
             |+设计代码区
          |+设计功能包
          |+设计功能包
             .....
初建立
测试先行（迭带开发）。原则上不手动建立类、接口。可以先命名后通过eclipes工具建立。
（1）test.api 测试。也叫主功能测试。该测试主要目的是：
        1>（接口级）功能描述，为再次使用提供帮助。
            结合javadoc和代码本身描述 javadoc 使用       
        2>建立功能接口。
            在次步骤是:先Ctrl+C命名,再shift+ctrl+N选择interface在package中去掉前面的test.api.
（2）test.support 测试。也叫可行分析测试。该测试目的是（接口级）功能分为（方法级）功能并为各实现一个测试方法。
（3）test.unit 测试。也叫单元测试。该测试目的是：
        1>方法级功能设计提升为类级、抽象类级（设计实现类）。
           在次步骤是:先Ctrl+C命名,再shift+ctrl+N选择class在package中换test.unit.为com
        2>方法依赖描述，为再次使用提供帮助。     
（4）重构。重构 eclips 快键

建立中
1.接口级功能添加。和初建立相同。
2.抽象类、类级功能添加。从 test.support 测试开始。

开发包对应
test.api <-> interface
test.support 无
test.unit <-> com

   在写大量代码时发现没有个限定的标准是见可怕的事情。但我的动态面向对象数据库操作这个我自己的小东西时在编码很好用。不管是再次修改，直接copy到另个项目改改。都能很好的工作。而其他的小东西却不行。这仔细的总结下。

eclipse中如何写一个测试私有方法的junit？
假设类Summer定义如下：
public class Summer{
   private int methodone(String argsone){
      //method code
      .......
      return 4;
   }
}

测试如下：
public class SummerTest extends TestCase {
   public void testMethodone(){
      Object rightResult = xxxxx;
      Summer example = new Summer.newInstance();
      Method m = example .getClass().getDeclaredMethod("methodone",new Class[]{String.class});
      m.setAccessible(true);
      Object result = m.invoke(example ,new Object[] {new String(xxxx)});
      m.setAccessible(false);
      if (result.equals(rightResult)){
         //your code
         ......
      }
   }
}

1.CollectionHelper 对List,Set,Map 包装出不可修改的
    1.1 在Collections.unmodifiableList(...)是静态内部类个构造方法
       悟： 从上面看出是一个非常好的  适配器  
2.大量使用内部类枚矩 ?如：

1. 接口里面的属性在默认状态下面都是public static

2.     被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。


3.   匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。


4.  静态内部类（Inner Class）写成这样才可以 在内部 new 出 ： static final public class XXXxx
            1.创建一个static内部类的对象，不需要一个外部类对象
           2不能从一个static内部类的一个对象访问一个外部类对象

5.

        HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。

　　Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。

6. GC

        System.gc()

        Runtime.getRuntime().gc()

7.重写Overriding和重载Overloading
    如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。

    如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

8.抽象类是否可继承实体类(concrete class)

          抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数

9.try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

　　会执行，在return前执行。

      

10.switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。

1。项目中 ->Exprot.. -> @javadoc 就可以了
2。javadoc 命令学习
    @author 作者
    @see 另请参见
        （1）、@see "string" 为"string"添加文本项，不产生链接。
        （2）、@see <a href="URL#Value">Label</a> 使用HTML标记产生链接
        （3）、@see package.class#member Label 使用Java语言的名字package.class #member产生链接。

@version 版
    @since 从以下版本开
    @param 参数说明

/** */中的开头是注解

   /**
   */  的就近原则 在那个上面就为那个注解

参照：http://java.ccidnet.com/art/3743/20031203/519697_1.html

/** class description
*/

3、Variable Description:描述变量的意义和取值含义。
/** var variable description
*/

4、Method Description:标明每个方法的输入、输出参数和返回值类型，说明特殊变量取值的含义。相关类文档链接。

/** method description
* @param var signification 方法参数说明
* @exception exception class name throws 说明
* @return return_value return signification return 说明
*/

5、Association Description:关联类文档描述，在注释当中需要参引其它文档描述的地方，可在相应的注释当中如下插入：
/** method description

* @param var signification
* @exception exception class name
* @return return_value return signification
* @see package.class#member label
*/

6、包描述文件：概括描述包的功能和设计概要。为每个包创建一个描述文件，命名为package.html，与包的java文件放在一起。

   

如有错误大家多指教

1.call(* *(..)) 和 execution(* *(..)) 区别
  call 和 execution 都为切面限定
  execution 进行切面添加只能在方法定义的开始和结束。如：
   >>>AOP 添加
      public String getName(){
          System.out.println("G_G");
        return this.name ;
    }
   >>>AOP 添加
  call进行切面添加没有限定。如：
    >>>AOP 添加
      public String getName(){
          >>>AOP 添加
          System.out.println("G_G");
          >>>AOP 添加
        return this.name ;
    }
   >>>AOP 添加

     2.this 和within的区别
   都为范围限定作用，如： within(Demo) && execution( * *(..)) 在类Demo中的所有..
   区别是：this不能切静态,within没有

 3.cflow的作用
  我们从 1>cflow( within(DD+) && execution( * *(..)) ) 和
         2>within(DD+) && execution( * *(..)) 的区别来看
  1与2的对比是在2的切入点下再加 aj 文件的方法 进行添加切入点。

4.方法添加
  如：Introduction Example例中的 CloneablePoint.aj
     Point类继承Clonable 添加 clone() 方法

   declare parents: Point implements Cloneable;

   public Object Point.clone() throws CloneNotSupportedException {
      return super.clone();
   }

   point.clone()....

  

学习拥有连贯
在我刚认识 让 java 动态 这种动态编译动态加载的几天后
对我一向不懂的 AOP 特别是 AspectJ 开窍了 （哈哈 那感觉好啊^_^）
下面我写出我刚对AOP的一些小练

1。目的
DAO中大量的 session的开和闭 不紧使代码成倍加，还及容易出错
用 设计模式 hibernate 包装 下大家好象有点接受不了（@_@!）
AOP就进入我的视线 但总没个切入点

2。原理
其实 让 java 动态 就是那点东西 但IBM 包出个好用的框架 来 。

3。代码说明

//*******************Dao.java ****************************
package tt;
//为了简单 session 看成是 真的session 哈 ^_^
public class Dao {
    public String session = "close" ; 
    
    public void testDao(){
        System.out.println( "testDao in function : "+ session);
    }
    
    static public void main(String[]args){
        Dao dao = new Dao() ;
        dao.testDao();
        System.out.println("main in function : " +  dao.session);
    }
}

//*****************List.aj ****************************
package tt;

public aspect List {
    //切点  范围声明  （Dao.testDao 归 readOnly切点管  ）
    pointcut readOnly(Dao dao):execution(* *Dao.testDao*(..))&&this(dao);

    //挂载 readOnly 开始方法
     before(Dao dao) :  readOnly(dao) {         
             openSession(dao);
      }
     //挂载 readOnly 结束方法
     after(Dao dao) returning()  :  readOnly(dao) {
          close(dao);
     }
    
     // readOnly 方法 运行代码 （到这可以大胆的写 java 代码了 ） 。。。。
     private void openSession(Dao dao) {
         if(dao.session.equals("close"))
             dao.session = "Session Open";
     }
     private void close(Dao dao) {
         dao.session = "close" ;
     }
}

4。结果：
testDao in function : Session Open
main in function : close


4。后续
AspectJ 使 AOP 简单
可能还会统一标准
能为我们的java 框架灵活 更上一层 （期待）