I somewhat understand the difference between Javascript and Java when it comes to OOP. I read the bottom paragraph in the Javascript book that I have but I don't fully understand what it mean, can you further explain and provide examples to show the difference between the two languages?
"In many object-oriented programming languages, it is possible to define a class of objects and then create individual objects that are instances of that class."
Thanks!
What most people do is use constructor functions, like so:
function MyClass(a, b) {
// Private instance properties
var x = "secret";
var y = "also secret";
// Public instance properties
this.a = a;
this.b = b;
// "Privileged" methods; can access private and public properties
this.foo = function () {
return x + " " + this.a;
};
}
// "Public" methods; cannot access private properties
MyClass.prototype.bar = function () {
return this.a + " " + this.b;
};
// Public shared properties; not recommended:
MyClass.prototype.w = "stuff";
// Static methods
MyClass.baz = function () {
return "i am useless";
};
You would then use this constructor function like so:
var instance = new MyClass("hi", "Meen");
asssert.equal(instance.foo(), "secret hi");
assert.equal(instance.bar(), "hi Meen");
assert.equal(MyClass.baz(), "i am useless");
var also = new MyClass("hi", "Raynos");
instance.w = "more stuff";
assert.equal(also.w, "more stuff");
If you wanted to do inheritance, you would do something like:
function Inherited(a) {
// apply parent constructor function
MyClass.call(this, a, "Domenic");
}
Inherited.prototype = Object.create(MyClass.prototype);
var inherited = new Inherited("hello there good chap");
assert.equal(inherited.a, "hello there good chap");
assert.equal(inherited.foo(), "secret hello there good chap");
assert.equal(inherited.bar(), "hello there good chap Domenic");
this. Also note "encapsulation" is met by the second definition on wikipedia.._internalName is internal, undocumented and likely to change or blow up if touched by code that uses a "class". This gives you encapsulation and prototypical OO.Object oriented javascript is very simple.
You create an object.
var Klass = {
method: function () {
},
constructor: function() {
},
...
};
And then you create an instance of that object through prototypical inheritance
// instantiate
var o = Object.create(Klass);
// initialize
o.constructor();
This is different from classical OO because any object can be a "class" in javascript. and there is only one inheritance chain, the chain of prototypes.
Normally in classical OO languages the classes would inherit from each other and the instances would have a seperate chain of inheritance.
Also in classical OO you have two objects, the actual class object and the blueprint for the instance (i.e. static). This doesn't exist in javascript because there is only one object, the blueprint.
Disclaimer: Object.create is ES5, so you need an es5-shim for legacy platforms.
Klass.constructor.prototype === Klass && Constructor.prototype.constructor === Constructor. It's a matter of personal style, and I find this a lot more readable and elegant then faffing around with constructors, .prototype and new. And actually what I'm doing mirrors es.next Object exemplars and es.next classes, the ES community will move away from constructors. And besides apart from "It's not my style choice" is there anything wrong with the constructs I'm showing?var KlassConstructor = Klass.constructor; var instance = new KlassConstructor(...);. They are the same. And initialization and construction has always been seperate, new just happens to do both. Personally I'd say if someone can't read the code then need to learn ES5.In Java you can create a class using the class keyword. A class is the blueprint for its instances (objects).
e.g.
class AClass { // AClass is a class
AClass() { } //this is the constructor which will be used to create instances of this class
}
And then create and instance of the class:
AClass obj1 = new AClass(); // an instance of the class AClass
AClass obj2 = new AClasss(); //another instance of the class AClass
So, every object in Java is an instance of some class. And you can have many different instances of a class, but you can't have any object without class which acts as their blueprint.
And, in the class you can define member variables and methods which can either belong to the class itself, which will be shared by all of it's instances, or belong to the instance in which case every instance will have their own copy.
In Javascript I mostly create objects as follows:
var obj = { };
So, I don't need to create any class to actually create an object.
