Inheritance in Java​Script

Question

I have a class Person like this:

 class Person {
 constructor(name, age, gender, interests) {
 Object.assign(this, {name, age, gender, interests});
 }
}

And I can make sub-class like this:

class Teacher extends Person {
 constructor(name, age, gender, interests, subject, grade) {
 super(name, age, gender, interests);
 Object.assign(this, {subject, grade});
 }
}

But what if I want to make sub-class but I don't want to inherit all the properties from the Person class. For example I don't want to inherit the interests property. Do I just exclude it like this:

class Student extends Person {
 constructor(name, age, gender, height, weight) {
 super(name, age, gender); // I haven't included the interests property here
 Object.assign(this, {height, weight});
 }
}

I am still beginner so I am not sure if this is good practice or not. Have a nice day!

• Heretic Monkey: Good practice is kind of inherently opinion-based. For instance, in my opinion, you should not inherit from a class if you don't want everything from that class. In this case, Person should perhaps not include interests and another type InterestedPerson be created to have that property.
• Randy Casburn: If this is the case: But what if I want to make sub-class but I don't want to inherit all the properties from the Person class. - then your design is flawed.
• deceze: Inheritance always is an is-a relationship. Student is a Person. If a Person has interests, so does the Student. A child class can always be substituted anywhere the parent class could be used.
• VLAZ: @HereticMonkey just to build on top of your comment, the InterestedPerson need not even be a class you inherit, you could acquire it through object composition. Otherwise what happens if you do have a teacher who has an interest?
• Todd Chaffee: Look into favoring composition over inheritance. en.wikipedia.org/wiki/Composition_over_inheritance

Answer 1

 super(name, age, gender); // I haven't included the interests property here

By not adding an argument to a function call, the parameter will implicitly be undefined. The upper therefore equals:

 super(name, age, gender, undefined)

Therefore the interests property does still exist, it is just undefined. That is actually a good solution if all your code assumes that interests could not be defined. If not, e.g. if you are doing calculations with it without an explicit check, your calculations might suddenly be NaN, which gets you into some trouble:

 if(person.age > 18) {
 alert("adult");
 } else alert("child"); // or maybe the person is not a child, and it's age property was just not set?

Now instead of setting that existing property to a value that indicates that it is undefined, you could omit the interests property at all, by:

1) Moving it to a subclass:

 class Person {
 constructor(name, age, gender) {
 Object.assign(this, {name, age, gender });
 }
 }
 class PersonWithInterests extends Person {
 constructor(name, age, gender, interests) {
 super(name, age, gender);
 Object.assign(this, { interests });
 }
}

2) Create a Mixin:

A Mixin is a class, that can extend more than one class. If more than a Person has an interest, it might be benefitial to create a mixin for it:

 const Interested = Super => class InterestMixin extends Super {
 constructor(args) { // passing in an object here makes the Mixin more flexible, all superclasses have to deal with it though
 super(args);
 this.interests = args.interests;
 }
};
class Animal { }
const PersonWithInterest = Interested(Person);
const AnimalWithInterest = Interested(Animal);
new PersonWithInterest({ name: "Jonas", interests: 10 })
new AnimalWithInterest({ type: "bear", interests: 20 })

(If you end up creating a new Mixin for every single property, this solution is not really viable anymore. If you can't group multiple properties into a useful Mixin, go with the first way instead (having optional properties)).

• Jonas Wilms: I do have the feeling that my keyboard got some broken keys today ... thanks :)
• Happy Coconut: Thanks a lot for your detailed explanation. This helps me a lot!

Answer 2

Inheritance means what it means ... you inherit what the parent gives to you. So 'avoiding attributes' it not really recommended (and I'm not sure you can even do it).

Two solutions :

• Architecture wise (that I recommend): in your specific case, I would just put interests in the Teacher class. If other classes would have the interests too, I would create a sub-class like PersonInterest on which Teacher would inherit from.
• Code wise: you set interests to null or undefined in the class where you don't need it.

• Jonas Wilms: The second solution could be error prone, e.g. if a number is expected and suddenly undefined gets added through a Subclass.
• VLAZ: @JonasWilms honestly, both solutions are problematic. But I take it as these are direct solutions for the code OP already has.
• HRK44: @JonasWilms well he is the one designing it, so if he goes that way, he will have to check for null or undefined values in his code. This is JS code not Java or other strongly typed language
• Jonas Wilms: @vlaz no, the first advice is actually quite clean.
• VLAZ: @HappyCoconut the downside is that you now have an inheritance hierarchy for an optional attribute. The abstraction can very quickly break down. Let's assume that every Teacher is indeed a person with an interest and every Student isn't (that's a big assumption). But then you try to add another optional property - PersonWithFavouriteColor. You now have to inherit from two things to get the two optional properties. Add a couple more and a couple more actual classes (e.g., Accountant and Merchant) and try to give each a different set of the optional properties. It's not scalable.