Error when performing Inheritance in TypeScript

This feels like two separate questions, but I will answer them both here:

Here's how I'd alter your code:

// non-primitive types should start with a capital letter by convention
class User {
  name: string;
  email: string;

  constructor(name: string, email: string) {
    this.name = name;
    this.email = email;
  }

  // a method on the prototype, not an instance property
  checkUserData(id: number) {
    console.log(
      "This user name is" +
      this.name +
      "his email address is" +
      this.email +
      "and his ID is" +
      id
    );
  };
}


// non-primitive types should start with a capital letter by convention
class College extends User {
  id: number;

  // annotate types on function parameters
  constructor(name: string, email: string, id: number) {
    super(name, email);
    this.id = id;
  }

  // a method on the prototype, not function property
  checkUserData() {
    super.checkUserData(this.id);
  };
}

// do not widen to user type, let the compiler infer as college
let newUser = new College("Rohit Bhatia", "[email protected]", 4556);

console.log(newUser.checkUserData());

Note: By convention, non-primitive types start with an uppercase letter, so I've changed user to User and college to College. It's not invalid to have lowercase class names, but it violates expectations. Feel free to leave them lowercase if you want.

Question One: "why can't I call super?"

Answer One: you are using function properties instead of methods. Use methods instead.

Detail: I have changed checkUserData() in both User and College to be a prototype method. That means that they are added to User.prototype and College.prototype, and instances of User and College just inherit them via prototypical inheritance. Now you can use this and super inside College.prototype.checkUserData(). The way you defined the methods, as arrow functions, this wasn't possible. An arrow function does not have its own this or super context, and each instance of User and College would get its own copy of the arrow function, so you couldn't override it via prototypical inheritance. Arrow functions are (as it says in the MDN docs) ill-suited as methods.

Question Two: "why does newUser.checkUserData() give me an error?"

Answer Two: you have declared that newUser is of type User. Leave it unannotated, or declare it as type College instead.

Detail: When you say let newUser: User = ... you are telling the compiler that it is a User, and the compiler will not try to figure out if it is a more specific type like College, even though you know it is one. Since a User instance requires its checkUserData() method to take a single argument, you will get an error. The way to fix this is to let the compiler know that newUser is actually a College. You can do this explicitly by annotating it (let newUser: College = ...), or you can just leave out the annotation and let the compiler infer that it's a College instance by looking at the return type of new College(...).

Okay, hope that helps. Good luck!