Object Oriented approach in Java Script

Yes, you can emulate it using prototypical inheritance. The rules are quite different since the language is prototype driven and you'll need to do some research regarding prototype chains and such, but in the end it turns out quite useful.

Check out things in Node core which inherit from EventEmitter. They have a built in function called util.inherits, which has an implementation for later versions of ECMA. It looks like this:

/**
 * Inherit the prototype methods from one constructor into another.
 *
 * The Function.prototype.inherits from lang.js rewritten as a standalone
 * function (not on Function.prototype). NOTE: If this file is to be loaded
 * during bootstrapping this function needs to be rewritten using some native
 * functions as prototype setup using normal JavaScript does not work as
 * expected during bootstrapping (see mirror.js in r114903).
 *
 * @param {function} ctor Constructor function which needs to inherit the
 *     prototype.
 * @param {function} superCtor Constructor function to inherit prototype from.
 */
exports.inherits = function(ctor, superCtor) {
  ctor.super_ = superCtor;
  ctor.prototype = Object.create(superCtor.prototype, {
    constructor: {
      value: ctor,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });
};

An example use is the Stream class:

https://github.com/joyent/node/blob/master/lib/stream.js#L22-29

var events = require('events');
var util = require('util');

function Stream() {
  events.EventEmitter.call(this);
}
util.inherits(Stream, events.EventEmitter);

In coffeescript, classes compile to a slightly different set of code which boils down to this __extends function. I believe this is going to have more cross browser compatibility, but I don't specifically recall who doesn't support Object.create.

var __hasProp = Object.prototype.hasOwnProperty, __extends = 
function(child, parent) { 
    for (var key in parent) { if (__hasProp.call(parent, key)) 
child[key] = parent[key]; } 
    function ctor() { this.constructor = child; } 
    ctor.prototype = parent.prototype; 
    child.prototype = new ctor; 
    child.__super__ = parent.prototype; 
    return child; 
  };