<html>
<script>
function Person(name)
{
this.name = name;
}
Person.prototype.getName = function() {
return this.name;
}
function Author(name, book)
{
Person.call(this, name);
this.book = book;
}
Author.prototype = new Person();
Author.prototype.getBook = function() {
return this.book;
}
var simpson = new Author("Simpson", "The Big Fat Book");
alert(simpson.getName());
alert(simpson.getBook());
function Me()
{
Author.call(this, "Vinuth", "GentleMenz Arena");
}
Me.prototype = new Author();
Me.prototype.getBook = function() {
return "MyBreadBasket";
}
var me = new Me();
alert(me.getName() + " - " + me.getBook());
</script>
</html>
How of Classical Inheritance
1) Define a function as a constructor,
for e.g., Person, Author and Me shown above.
2) Constructors initializes the member variables and methods using the "this" keyword as shown in Person and Author constructors.
3) Define the complete structure by adding methods.
In the above example Person is defined as having a method called getName.
In javascript prototype keyword is used extensively for this as shown below.
Person.prototype.getName = function() {
return this.name;
}
4) Extend Author from Person and this is done using two steps.
a) In the constructor of Author call the Person's constructor like Person.call(this,...);
"this" as the parameter to the call method says that you are invoking Person in the Author's context,
i.e., "this" here refers to Author's Object.
b) Prototype chaining:
It is a way to define the hierarchy of objects.
Here Author's prototype is linked to Person meaning Author is an extension of Person or Author is of type Person.
This is done using Author.prototype = new Person();
5) Creating the objects is as simple as "var author = new Author();" and calling a method of its super class will be like "author.getName();"
Prototypal Inheritance
<html>
<script>
var Person = {
name: "Vinuth",
getName: function() {
return this.name;
}
};
alert(Person.getName());
function clone(obj)
{
function F(){}
F.prototype = obj;
return new F();
}
var Author = clone(Person);
Author.setName = function(name) {
this.name = name;
}
alert(Author.getName());
Author.setName("Chet");
alert(Author.getName());
</script>
</html>
All about Prototypal Inheritance
1) Most importantly there is no use of keyword "function" for defining the classes.
There is no concept of classes.
The beauty of Prototypal language is that everything is an object and there is no class concept at all.
As you can see in the above example Person is not a class but its an object and it is defined using the configuration object.
Configuration objects are defined as {...} within the flower brackets "{}".
2) Since there is no concept of classes and everything in Prototypal language is object, we do not use the keyword "new" at all.
3) extends is achieved by using prototype keyword as shown in the clone() method above.
4) Any objects can be extended as easily as just defining a method or property on the object directly as follows
Author.setName = function(name) {
this.name = name;
}
No comments:
Post a Comment