Object can be created by the statement
	
		var ob = new Func( args );

	We will call this way of creating objects "pseudoclassical OOP model".
	Pseudo because it pretends there are features usually promised for "classical" OOP.
 
	"new" is a language keyword.
	`Func` is a function.
	Function is called a "constructor" if used with "new".
	Convention: first letter is capital. To avoid mistake of using function as
	a "procedural" function if function intended as constructor.
	

	Compare functional and pseudoclassical models:

	1. Functional OOP model. Returns object which can be prepared using args in function body.
	1'. Pseudo. The same.

	2'. Pseudo. After constructor is declared. It gets a `prototype` property available for use.
		Any function gets this property and can be used as a constructor.

		For example: 

			Func( settings ) { var obj = { mySpecialValue : settings }; return obj; };		//c
			Func.prototype = { publicProperty : 'at the mercy of constructor' }				//p

			var ob1 = new Func( 'I am obj 1' );
			// check this in your browser:
			console.log( ob1 );	// { publickProperty :  'at the mercy of constructor', mySpecialValue : 'I am obj 1' };
			var ob2 = new Func( 'I am obj 2' );
			console.log( ob2 );	// guess what? ...

			Yes, different arguments made up different properites.

			If prototype of the constructor has not be explicitly set, the prototype is set to Object.prototype.

			Every object created by constructor receives link to prototype from the constructor.
			In plain, prototype is a "repository" of properties.
			If object is assigned property obj.myPro explicitly in constructor's body,
			then this value "overrides" property from object's prototype if any.

			In fact, every object has a link to own prototype, no matter which way object has been created.

	2. Functional. When //p is not set, in both models object's prototype is the same: Object.prototype.

			When //p is assigned explicitly, the similar effect may be clumsy to achive by pure functional means,
			but after all does it worth to emulate prototypial inheritance by them?
			The functional approach seems much more rich then prototypial inheritance.
			
	
	Exercise: rewrite the IAmExist2() Class Example in pseodoclassical form: