public ChildNode() 
{

}

Constructor for serialization.

 protected ChildNode(CoreDocumentImpl ownerDocument) 
{
    //
    // Constructors
    //
        super(ownerDocument);
}

No public constructor; only subclasses of Node should be instantiated, and those normally via a Document's factory methods

Every Node knows what Document it belongs to.

 public Node cloneNode(boolean deep) 
{
    	ChildNode newnode = (ChildNode) super.cloneNode(deep);
        // Need to break the association w/ original kids
    	newnode.previousSibling = null;
        newnode.nextSibling     = null;
        newnode.isFirstChild(false);
    	return newnode;
}

Returns a duplicate of a given node. You can consider this a generic "copy constructor" for nodes. The newly returned object should be completely independent of the source object's subtree, so changes in one after the clone has been made will not affect the other.

Note: since we never have any children deep is meaningless here, ParentNode overrides this behavior.

 public Node getNextSibling() 
{
        return nextSibling;
}

The next child of this node's parent, or null if none

 public Node getParentNode() 
{
        // if we have an owner, ownerNode is our parent, otherwise it's
        // our ownerDocument and we don't have a parent
        return isOwned() ? ownerNode : null;
}

Returns the parent node of this node

 public Node getPreviousSibling() 
{
        // if we are the firstChild, previousSibling actually refers to our
        // parent's lastChild, but we hide that
        return isFirstChild() ? null : previousSibling;
}

The previous child of this node's parent, or null if none

 final NodeImpl parentNode() 
{
        // if we have an owner, ownerNode is our parent, otherwise it's
        // our ownerDocument and we don't have a parent
        return isOwned() ? ownerNode : null;
}

 final ChildNode previousSibling() 
{
        // if we are the firstChild, previousSibling actually refers to our
        // parent's lastChild, but we hide that
        return isFirstChild() ? null : previousSibling;
}