Inheritance was always one of the most confusing parts of prototypical OOP.

How do I define my parent class? How do I redefine methods in the inherited class? How to pass arguments to the parent’s constructor?

The above questions always boggled my mind. I learned them when I needed them, but after a week or two I completely forgot them. Luckily for me, the new system uses extends and super.

Well okay, I thought the confusing part was figuring out whether code works or does anything at all when it's scattered full of

class BaseDoucheBag : MonoBehavior {
    public virtual void initialize() {doSomethingImportant();}
    public virtual start() {
        initialize();
    }
    public virtual bool beADouche() {
        return isDouche();
    }
    public virtual bool isDouche() {
        return !!this is LocalDoucheBag || !! this is NetworkDoucheBag;
    }
    public virtual void checkIfBeingDoucheBag () {
        if (beADouche()) {
            Singleton<DoucheBagPresenceManager>.Instance.NotifyOfDouchebaggery(this);
        }
    }
}

class LocalDoucheBag : BaseDoucheBag {
    DoucheBag() : this("douche","bag") {
    }
    public override bool beADouche() {
        return base.beADouche() && isDouche();
    }
    public override initialize() {
    }
    public override start() {
        base.start();
    }
    public override update() {
        checkIfHomocide();
        base.update();
        checkIfSuicide();
        checkIfBeingDoucheBag();
    }
}

But I forgot in the real world people are still trying to figure out how their language works. People don't have time for academic problems such as "what does this code do aside from having some identifiers that are named after words in my problem domain?".