//конструктор класса Pet
function Pet(name) {
    this.name = name;
    this.canWalk = true;
}
//несколько методов определенных в прототипе
Pet.prototype.getName = function () {
    return "|" +this.name.toUpperCase() + "|";
}
//....
//конструктор класса Cat
function Cat(name) {
    Pet.apply(this, arguments); //вызываем конструктор базового класса Pet, при инициализации Cat.
}
//конструктор класса Dog
function Dog(name) {
    Pet.apply(this, arguments); //вызываем конструктор базового класса Pet, при инициализации Dog.
}

//1. через new, говорят, что так лучше никогда не делать, почему(потому что якобы создается фиктивный родитель)?
Cat.prototype = new Pet(); //тут происходит наследование, как я понимаю на основе прототипов, но в прототип записывается целый объект Pet, что и является дурным тоном.
Cat.prototype.constructor = Cat; //явно объявляем конструктор Cat

var c = new Cat("Thomas"); //создаем объект класса Cat
console.log(c.getName()); // -> |THOMAS|
console.log(c instanceof Cat); //-> true
/*----------------------------------------------------------------------------------------------------------------------------------------------------*/
//2. через Object.create(), тут уже наследование происходит от прототипа родителя
Dog.prototype = Object.create(Pet.prototype); //наследование через прототип родителя
Dog.prototype.constructor = Dog; //явно объявляем конструктор Dog

var d = new Dog("Guffy"); //создаем объект класса Dog
console.log(d.getName()); // -> |GUFFY|
console.log(d instanceof Dog); //-> true

//3. пример с сайта "javascript.ru", через функцию extend()
//собственно определяем функцию
function extend(child, parent) {
    var f = function () { } //фиктивный конструктор
    f.prototype = parent.prototype; //наследуем прототип родительского класса
    child.prototype = new f(); //ребенок наследует объект f с прототипом родителя и пустым конструктором
    child.prototype.constructor = child; //явно объявляем конструктор ребенка
    child.superclass = parent.prototype; //ну тут определяем прототип родителя в свойстве ребенка
}

//определим класс Humster
function Humster(name) {
    Humster.superclass.constructor.apply(this, arguments); //теперь конструктор базового класса вызывается через переменную superclass
    //Pet.apply(this, arguments);
}
extend(Humster, Pet); //осуществляем наследование

var h = new Humster("Xoma"); //определяем объект класса Humster
console.log(h.getName()); // -> |XOMA|
console.log(h instanceof Humster); // -> true
/*----------------------------------------------------------------------------------------------------------------------------------------------------*/
//4. пример из книги Д. Фленагана, через функцию inherit()
//собственно определяем функцию
function inherit(p) {
    if (p == null) throw TypeError(); // p не может быть значением null
    if (Object.create) // Если Object.create() определена...
        return Object.create(p); // использовать ее.
    var t = typeof p; // Иначе выяснить тип и проверить его
    if (t !== "object" && t !== "function") throw TypeError();
    function f() { }; // Определить фиктивный конструктор.
    f.prototype = p; // Записать в его свойство prototype ссылку на объект p.
    return new f(); // Использовать f() для создания "наследника" объекта p.
};

//определим класс Fish
function Fish(name) {
    Pet.apply(this, arguments); //вызываем конструктор базового класса Pet, при инициализации Fish.
}
Fish.prototype = inherit(Pet.prototype); //производим наследование, через функцию inherit()
Fish.prototype.constructor = Fish; //явно объявляем конструктор Fish

//объявляем объект класса Fish
var fh = new Fish("Rodger");
console.log(fh.getName()); // -> |RODGER|
console.log(fh instanceof Pet); //-> true