The pet class will have a name for the pet and a species for the pet. Pets will be able to greet their owner, and make a noise. First, lets take a look at the more modern ECMAScript 6 way of doing this. This is set up just like any normal class that we would have created in the previous section.
class E6Pet {
constructor(name, species) {
this.name = name;
this.species = species
}
greet() {
printTestLine(this.name + ", the " + this.species + ", comes to greet you");
}
makeNoise() {
printTestLine(this.name + " makes a noise");
}
}
var fish = new E6Pet("Nemo", "Fish")
fish.greet();
fish.makeNoise();
The old way of creating the base class is also the same way you would create a class using older versions of ECMAScript.
function Pet(name, species) {
this.name = name;
this.species = species;
this.greet = function() {
printTestLine(this.name + ", the " + this.species + ", comes to greet you");
}
this.makeNoise = function() {
printTestLine(this.name + " makes a noise");
}
}
var oldfish = new Pet("Dora", "Fish")
oldfish.greet();
oldfish.makeNoise();
Once you have a class that can be used as a base-class, you can create a new class that inherits the methods and variables of it's parent. This effectively gives you all the code that you have written in the base class. You can then add additional methods and variables allowing the new class to have the functionality of the base class while adding new features to the class. This alone would make inheritance worth doing, but it gets even more powerful. It is possible to override an existing method and replace it with another method that is more appropriate for the class you are creating.
In our example, different pets make different sounds so by overriding the makeNoise method, we can create species specific noises. We will create a dog and a cat, with each of them having a unique noise and the dog being able to wag it's tail.
ECMAScript 6 makes inheritance very easy as you just use the extends keyword when you are creating a class. Sub-classes can have a different number of parameters, with the super method used to call the original code. Overriding the method is simply the matter of using a method with the same "signature." A method's signature is simply the method name and the particular parameters that make up the method. finally creating a new method is done by having a new method in the class.
class E6Cat extends E6Pet{
constructor(name) {
super(name, "Cat")
}
makeNoise() {
printTestLine(this.name + " Meows!");
}
}
class E6Dog extends E6Pet {
constructor(name) {
super(name, "Dog")
}
makeNoise() {
printTestLine(this.name + " Barks!");
}
wag() {
printTestLine(this.name + " wags his tail!");
}
}
var cat = new E6Cat("Lexi")
var dog = new E6Dog("Scruffy")
cat.greet();
cat.makeNoise();
dog.greet();
dog.makeNoise();
dog.wag();
The old way of inheritance is a bit more confusing as older versions of ECMAScript does not have a way of directly indicating inheritance so the programmer must manually set this up. JavaScript use prototype based inheritance where every class has a prototype that determines which methods it has. This prototype is used by the new operator to set up the class, but the prototype can be modified manually. The result is that there are many ways of setting up inheritance in JavaScript. The most common way is simply assigning the prototype of the class to the prototype of it's parent by using the new function.
function Cat(name) {
this.name = name;
this.species = "Cat";
this.makeNoise = function() {
printTestLine(this.name + " Meows!");
}
}
Cat.prototype = new Pet();
(Dog = function(name) {
this.name = name;
this.species = "Dog";
this.makeNoise = function() {
printTestLine(this.name + " Barks!");
}
this.wag = function() {
printTestLine(this.name + " wags his tail!");
}
} ).prototype = new Pet();
var oldcat = new Cat("Abby")
var olddog = new Dog("Smokie")
oldcat.greet();
oldcat.makeNoise();
olddog.greet();
olddog.makeNoise();
olddog.wag();
You will notice two slightly different styles for doing this. The cat way is the textbook way while the dog way is the way JavaScript code generated by Animate CC does things. You could also manually copy just the methods you are interested in, which can be a handy way of inheriting functionality from multiple different classes.
Inheritance is not just for reducing code duplication, but allows for a powerful technique known as polymorphism which we will be covering next.
No comments:
Post a Comment