ready

// 定义一个动物类
function Animal (name) {
  // 属性
  this.name = name || 'Animal';
  // 实例方法
  this.sleep = function(){
    console.log(this.name + '正在睡觉！');
  }
}
// 原型方法
Animal.prototype.eat = function(food) {
  console.log(this.name + '正在吃：' + food);
};

function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}
(function(){
  // 创建一个没有实例方法的类
  var Super = function(){};
  Super.prototype = Animal.prototype;
  //将实例作为子类的原型
  Cat.prototype = new Super();
})();

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); //true

public class MyStack<T> : IEnumerable<T>, IDisposable
    {
        private int _top = ;
        private int _size = ;
        private T[] _stack = null;

        public int Top
        {
            get
            {
                return _top;
            }
        }

        public int Size
        {
            get
            {
                return _size;
            }
        }

        public int Length
        {
            get
            {
                return _top;
            }
        }

        public T this[int index]
        {
            get
            {
                return _stack[index];
            }
        }

        public MyStack(int size)
        {
            _size = size;
            _top = ;
            _stack = new T[size];
        }

        public bool IsEmpty()
        {
            return _top == ;
        }

        public bool IsFull()
        {
            return _top == _size;
        }

        public void Clear()
        {
            _top = ;
        }

        /// <summary>
        /// 入栈
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public bool Push(T node)
        {
            if (!IsFull())
            {
                _stack[_top] = node;
                _top++;
                return true;
            }
            return false;
        }

        /// <summary>
        /// 出栈
        /// </summary>
        /// <returns></returns>
        public T Pop()
        {
            T node = default(T);
            if (!IsEmpty())
            {
                _top--;
                node = _stack[_top];
            }
            return node;
        }

        public void Traverse()
        {
            for (int i = ; i < _top; i++)
            {
                Console.WriteLine(_stack[i]);
            }
        }

        public IEnumerator<T> GetEnumerator()
        {
            for (int i = ; i < _stack.Length; i++)
            {
                if (_stack[i] != null)
                {
                    yield return _stack[i];
                }
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public void Dispose()
        {
            _stack = null;
        }
    }