My take at OOP module/prototyping JavaScript
&lt;!DOCTYPE html&gt;
&lt;html charset="utf-8"&gt;

    &lt;head&gt;
    &lt;/head&gt;

    &lt;body&gt;

        &lt;ul id=people&gt;&lt;/ul&gt;

        &lt;script&gt;

            (function () { // create a new scope

                'use strict';
                /*jslint browser: true*/

                /*
                    My main advice is this: don't over-engineer. Even
                    something as basic as a class in Java is often an
                    unnecessary complication in JavaScript. Trying to
                    emulate the Java style can end up messy and
                    contrived.

                    Modern JavaScript is more likely to have leanings
                    towards a functional style, so you should be
                    comfortable with that.

                    This and both the expressive syntax for object
                    literals and their malleability during run-time get
                    you most of what you need.

                    Inheritance hierarchies can be used for the
                    specialised parts of programs that require them, but
                    they are often not needed and certainly do not form
                    the basic architecture of a JavaScript program.

                    And if you do need an inheritance hierarchy keep it
                    shallow.

                    But you probably don't need one.
                */

                // Table of Contents
                var makeperson,
                    people,
                    listitems,
                    list;

                /*
                    Here I'm just returning an object constructed using
                    literal notation.
                */

                makeperson = function (title, name, gender, maritalstatus) {
                    return {
                        title: title,
                        name: name,
                        gender: gender,
                        maritalstatus: maritalstatus,
                        toString: function () {
                            return this.title + ' ' + this.name +
                                    ' (' + this.gender + ')';
                        }
                    };
                };

                /*
                    However in this case you only actually need

                    makeperson = function (title, name, gender) {
                        return this.title + ' ' + this.name +
                                ' (' + this.gender + ')';
                    };

                    but I thought I'd throw an object with a few
                    properties your way, just for illustration.

                    There's also no need to create a type to represent
                    a list of people. Variables are untyped in
                    JavaScript, so a plain array will do nicely. Array
                    instances come with lots of useful methods, e.g.
                    map, reduce, filter.
                */

                people = [
                    makeperson('Mr', 'Victor', 'm'),
                    makeperson('Mr', 'Joakim', 'm'),
                    makeperson('Mrs', 'Mattias', 'f', 'married')
                ];

                /*
                    And there's no need for a big library for a few
                    simple DOM manipulations.
                */

                listitems = people.map(function (person) {
                    var item = document.createElement('li');
                    item.appendChild(document.createTextNode(person));
                    return item;
                });

                list = document.getElementById('people');

                listitems.forEach(function (item) {
                    list.appendChild(item);
                });

            }());

            /*
                P.S.

                And make sure you use a linter and get into good habits
                early on.
            */

        &lt;/script&gt;
    &lt;/body&gt;
&lt;/html&gt;