这样的数据到了Browser，会先被转成一个对象数组。

 1// Tree Node object
 2// This function creates a node in the tree with the following arguments:
 3//    sId         - The node's index within the global nodes_array
 4//    iIndent    - The level within the tree hierarchy (0 = top)
 5//    sText      - The text displayed in the tree for this node
 6//    sTooltip     - the tool tip
 7//    oAction   - For a document, the address it will display when clicked
 8//    sIcon        - the node's icon 
 9//    sIconOpen    - the node's icon state
10//      bOpen - true  false
11function GMTreeNode(sId,iIndent,sText,sTooltip,sAction,sIcon,sIconOpen,bOpen,sTarget)
12{
13    if (sId) this.id = sId;
14    if (iIndent) this.indent = iIndent;
15    if (sText) this.text = sText;
16    if (sAction) this.action = sAction;
17    if (sTooltip) this.tooltip = sTooltip;
18    if (sIcon) this.icon = sIcon;
19    if (sIconOpen) this.iconopen = sIconOpen;
20    if (bOpen) this.open = bOpen;
21    if (sTarget) this.target = sTarget;
22    
23//    //alert(this.id + "  " + this.indent + "  " + this.text + "  " + this.action + "  " + 
24//    this.tooltip + "  " + this.icon + "  " + this.iconopen + "  " + this.open);
25}

 1/////////////////////////////////
 2//    >>>Compare 
 3//    compare maintree with maintree. and copy maintree to maintree
 4/////////////////////////////////
 5function compareTreeModel()
 6{
 7    //alert("I am here in compareTreeModel");
 8    if (ajaxtree.length <= 0){
 9        alert("ajaxtree is null");//TODO
10        return;
11    }
12    
13    if (maintree.length <= 0){
14        //alert("maintree is null");
15        maintree = ajaxtree;
16        return;
17    }
18    //compare start
19    //var maxlen = Math.max(ajaxtree.length,maintree.length);
20    for(var i=0;i<ajaxtree.length;i++)
21    {
22        for(var j=0;j<maintree.length;j++)
23        {
24            if (ajaxtree[i].id == maintree[j].id)
25            {
26                ajaxtree[i].open = maintree[j].open;
27                break;
28            }
29        }    
30    }
31    
32    maintree = ajaxtree;
33    
34}

1class CSharpClass ：CSharpBaseClass
2{
3   //成员
4}

这个是Java了，熟悉吧。

public Class JavaClass extends JavaBaseClass
{
  //成员
}

C++的定义如下：

class CPlusPlusClass: public CPlusPlusBaseClass
{
   //成员
}

1.2虚函数

把一个基类函数声明为virtual，该函数就可以在任何派生类中重写了。
Java的语法中没有virtual这个词，但是Java却彻彻底底的贯彻着这个概念，Java的所有函数都是虚拟的。
C++的朋友可能比较熟悉这个词吧。对于这一点C#和C++是相同的。但是语法稍微有点不同，C#需要使用override类显示声明重写函数。如下例

class BaseClass
{
         public virtual string VirtualMethod()
        {
                   return "The virtual method in defined in Base class";
        }
}

class ChildClass : BaseClass
{
            public override string VirtualMethod()
        {
                   return "The override method in defined in child class";
        }
}

1.3隐藏方法
相同签名的方法在基类和子类都声明了，但方法不是vitrual。那么实际中到底哪个方法被执行，取决于引用实例的变量类型，而不是实力本身的类型。
我们也不用太担心这个问题，因为C#会在编译期给出警告。

1.4调用积累函数的方法
java中我们使用super，C#中使用base。

1.5抽象类和抽象函数
和java一样使用abstract声明。
和C++相比，C++的抽象函数被声明为纯虚函数。

1.6密封类和密封方法
在Java中我们把它叫做final。也就是不能继承的类或不能重载的方法。

1.7构造函数的调用层次
和Java一样，我就不多说了。这里强调一个特殊的语法格式：

public class BaseClass
{
  private temp = "Default Construct";

  public string _flag
  {
     get{ return temp;}
     set{ temp = value;}
  }


  //Constructor with one Parameter
  public BaseClass(string f)
  {
      flag = f;
  }
}

public class ChildClass : BaseClass
{
   public ChildClass():base("Customized Construct"){}

   public Second(string f):base("BPara:CPara = 1:1"){}

   public Second(string f,string g):base("BPara:CPara = 1:2"){}

   private static void showConstructFlag()
   {
      new Second();
      Console.WriteLine("Show ConstructFlag:\n ChildClass():base(\"Customized Construct\")="+_Flag);

      new Second("test1");
      Console.WriteLine("Show ConstructFlag:\n Second(string f,string g):base(\"BPara:CPara = 1:1\")="+_Flag);

      new Second("test2","no use");
      Console.WriteLine("Show ConstructFlag:\n Second(string f,string g):base(\"BPara:CPara = 1:2\")="+_Flag);
    }
   
    public static void Main()
    {
        showConstructFlag();
    }
}

结果如预计那样 ：
如果基类含有带参数的构造函数，派生类不能调用默认基类构造函数。
多参数派生类构造函数，可以调用参数数目不同的基类构造函数。

我们一起来看看为什么这2个结论可以成立：
首先，对于带参数的基类构造函数在初始化的时候会试图去调用基类默认构造函数，但在上边的基类程序里，因为只声明了带一个参数的构造函数，所以public Second(string f):base()或者public Second(string f)就不会通过编译，因为他找不到基类的默认构造函数，只能追加public BaseClass()才会通过。这一点和JAVA是不同的，java的默认构造函数默认是不出现在代码里的。C#却一定要写出来。

<<<== 有错误。C#的默认构造函数体制和Java是一样的。具体如下：
1。父类没有自定义构造函数的情况下，使用默认构造函数。用户可以不写出来。
2。一旦父类有了自定义的构造函数，那么如果要使用无参的默认构造函数就必须要显示定义。




其次，下边派生类1个参数、2个参数甚至多个参数的构造函数为什么能访问只有一个参数的基类构造函数呢？原因是，关键字this，上边的程序改写如下我想大家就明白了。

public Second(string f):base("BPara:CPara = 1:1"){}

public Second(string f,string g):this(string f,"<None"){}

2.1修饰符
C#支持下边的集中修饰符：
public ，   protected ， internal  ，private ， protected internal
同Java。internal和protected internal是.net framework新增的一个内容。根据定义。
internal在同一个程序集内和public类似，不同的程序集间，public声明的类或方法仍然可用，但是internal的方法或类则被隐藏。
protected internal合并了protected 和internal，但这是一种or关系，而不是and关系。protected internal成员在同一个程序集的任何代码都可见，在派生类可见。

2.3接口
接口公约：
不能实例化接口。
接口不能有构造函数或字段。
接口定义也不允许包含运算符重载。
接口定义中还不允许声明成员上的修饰符。接口成员都是public的，不需要static也不需要virtual。

同Java
接口可以彼此继承，其方式和类继承相同。如下：

namespace my.test
{
  public interface IBase
  {
      void setName();
      bool isMe(string name);
      string name
      {
         get;
      }
   }
}

namespace my.test
{
    public interface IChild:IBase
    {
       bool isOK();
    }
}

告一段落吧。                                 (つづく)
请多提意见，如果有什么不清楚的地方也请你写下来，一起调查咯。  

Java异常处理机制

 
keywords:

Exception,Method Inovation Stack,

难度：初学，易

 
异常类的继承
Java异常是java程序运行时遇到非正常情况而创建的一种对象，她包装了异常的信息。
Java异常的顶级类就是java.lang.Throwable。其结构如下：


其中 

Error ---- JVM的错误，也就是程序本身无法恢复的严重错误。

Exception--被程序捕获并处理的异常。



JVM的方法调用堆栈
大家对于Debug都很喜欢，因为每当有异常出现的时候，她会告诉你哪里出了异常调用到底是什么。这又是如何实现的？

在JVM中使用了Method Inovation Stack机制来跟踪每一个线程中一系列的方法调用过程。并保存在Stack里边。
Stack的顶端也就是当前正在处理的方法。在Debug的时候，JVM会暂停被debug的线程，克隆她的Stack，然后显示出来供

developer操作，这一点用Eclipse的人很有体验吧。



一旦异常发生，JVM首先从当前的方法开始寻找处理的try/Catch，找不到，就回朔到stack的下一个，也就是parent调用

方法。举例如下：

public void child(int a)throws UserException{
  if (a < 0) 
     throw new UserException();
}

父方法如下：

public void parent(int a){
  try{
      a = 1;
      method(a);//throw Exception
  }catch(UserException ue){
      System.out.println("I get it from Child")!
      ue.printExceptionStack();
  }
}

就这样，异常被抓住了。当然，如果在child方法里边就捕获，parent就不用这么“累”了。

其实最累的还是JVM，她要对异常捕获进行查找，如果一直都找不到，就把异常直接抛给用户，那么在终端上就能看

到了。如果是抛出异常的程序是主程，还没有被捕获，那就“死翘翘”了。要注意！



异常处理对性能的影响

从上边的原理就能知道，不捕捉异常、捕捉异常的位置不合适、都会导致JVM性能降低。



(PS:先记到这里，继续上班。)