JavaScript Class Interview Questions

Anatomy of a class

class BankAccount {
  // Public class field — own property, initialized before constructor body
  currency = 'INR'

  // Private field — only accessible inside this class body
  #balance = 0
  #transactionLog = []

  // Static field — on the class itself, not instances
  static defaultCurrency = 'INR'
  static #totalAccounts = 0

  constructor(owner, initialBalance = 0) {
    this.owner  = owner      // own property set in constructor
    this.#balance = initialBalance
    BankAccount.#totalAccounts++
  }

  // Public method — on BankAccount.prototype (shared by all instances)
  deposit(amount) {
    if (amount <= 0) throw new RangeError('Amount must be positive')
    this.#balance += amount
    this.#transactionLog.push({ type: 'deposit', amount, at: new Date() })
    return this
  }

  withdraw(amount) {
    if (amount > this.#balance) throw new Error('Insufficient funds')
    this.#balance -= amount
    this.#transactionLog.push({ type: 'withdraw', amount, at: new Date() })
    return this
  }

  // Getter — accessed as a property, not a method call
  get balance() { return this.#balance }

  get history() { return [...this.#transactionLog] }  // copy — don't expose internals

  // Private method
  #validate(amount) { return amount > 0 && amount <= this.#balance }

  // Static method — called on the class, not an instance
  static getTotalAccounts() { return BankAccount.#totalAccounts }

  toString() { return `${this.owner}: ${this.currency}${this.#balance}` }
}

const acc = new BankAccount('Alice', 1000)
acc.deposit(500).withdraw(200)  // method chaining via return this
acc.balance        // 1300 — getter
acc.#balance       // SyntaxError — private field inaccessible outside class
BankAccount.getTotalAccounts()  // 1

Inheritance — extends and super

class Animal {
  #name
  #sound

  constructor(name, sound) {
    this.#name  = name
    this.#sound = sound
  }

  speak()        { return `${this.#name} says ${this.#sound}` }
  get name()     { return this.#name }

  toString()     { return `[Animal: ${this.#name}]` }
}

class Dog extends Animal {
  #tricks = []

  constructor(name) {
    super(name, 'Woof')  // MUST call super() before using 'this'
  }

  learn(trick) {
    this.#tricks.push(trick)
    return this  // chaining
  }

  // Override parent method
  speak() {
    const base = super.speak()  // call the parent's version
    return `${base}! Knows: ${this.#tricks.join(', ') || 'nothing yet'}`
  }
}

const rex = new Dog('Rex')
rex.learn('sit').learn('shake')
rex.speak()  // 'Rex says Woof! Knows: sit, shake'

// Prototype chain:
// rex → Dog.prototype → Animal.prototype → Object.prototype → null
rex instanceof Dog     // true
rex instanceof Animal  // true — instanceof checks the whole chain

Public vs private — what private actually means

class Counter {
  #count = 0       // private field — hard privacy, enforced by the engine

  increment() { this.#count++ }
  get value()  { return this.#count }

  // Private fields are ONLY accessible within the class body
  // Not accessible from subclasses either
}

class LoggedCounter extends Counter {
  increment() {
    super.increment()
    // this.#count  // SyntaxError — # fields are NOT inherited
  }
}

const c = new Counter()
c.increment()
c.value    // 1
c.#count   // SyntaxError — you cannot access private fields from outside

// Before private fields (#), developers used _ convention (not enforced) or WeakMap:
// The _ prefix is a promise, not a lock. Anyone can still access _count.
// Private fields are a lock — the engine refuses access at the syntax level.

Static members — class-level, not instance-level

class MathUtils {
  // Static properties and methods belong to the CLASS, not instances
  static PI = 3.14159265358979

  static add(a, b)      { return a + b }
  static multiply(a, b) { return a * b }
  static square(n)      { return n * n }
}

MathUtils.PI          // 3.14159...
MathUtils.add(2, 3)   // 5

const m = new MathUtils()
m.PI                  // undefined — static is on the class, not the instance
m.add(2, 3)           // TypeError: m.add is not a function

// Static block — runs once when the class is defined
class Config {
  static env
  static apiUrl

  static {
    Config.env    = process.env.NODE_ENV ?? 'development'
    Config.apiUrl = Config.env === 'production'
      ? 'https://api.example.com'
      : 'http://localhost:3000'
  }
}
// Runs once at class definition time — like a static constructor

Class fields vs constructor assignment

class Example {
  // Class field — initialized BEFORE the constructor body runs
  // Each instance gets its OWN copy
  data = []        // each instance gets a fresh []
  count = 0

  // Arrow function class field — bound to the instance
  // Useful for event handlers that need 'this'
  handleClick = (event) => {
    console.log(this.count)  // 'this' is always the instance
  }

  constructor() {
    // Class fields are already set by here
    // this.data already exists and is []
  }
}

// Without class fields — the old way
class OldExample {
  constructor() {
    this.data  = []   // same effect as class field
    this.count = 0
    this.handleClick = (event) => {  // creates a new function PER INSTANCE
      console.log(this.count)        // vs prototype method — shared one function
    }
  }
}

// Key difference:
// Prototype method: ONE function shared by all instances (memory efficient)
// Arrow class field: NEW function per instance (but permanently bound 'this')

Abstract classes — the pattern, not a keyword

// JavaScript has no abstract keyword — simulate it
class Shape {
  constructor(color) {
    if (new.target === Shape) {
      throw new Error('Shape is abstract — instantiate a subclass')
    }
    this.color = color
  }

  // "Abstract" method — subclasses must implement
  area() {
    throw new Error(`${this.constructor.name} must implement area()`)
  }

  describe() {
    return `A ${this.color} ${this.constructor.name} with area ${this.area().toFixed(2)}`
  }
}

class Circle extends Shape {
  constructor(color, radius) {
    super(color)
    this.radius = radius
  }
  area() { return Math.PI * this.radius ** 2 }
}

new Shape('red')           // Error: Shape is abstract
new Circle('blue', 5).describe()  // 'A blue Circle with area 78.54'

Mixins — multiple inheritance workaround

// JavaScript classes can only extend ONE class
// Mixins compose behavior from multiple sources

const Serializable = (Base) => class extends Base {
  serialize()   { return JSON.stringify(this) }
  static deserialize(json) { return Object.assign(new this(), JSON.parse(json)) }
}

const Timestamped = (Base) => class extends Base {
  constructor(...args) {
    super(...args)
    this.createdAt = new Date()
    this.updatedAt = new Date()
  }
  touch() { this.updatedAt = new Date() }
}

const Validatable = (Base) => class extends Base {
  validate() { return Object.keys(this).every(k => this[k] !== null) }
}

// Compose mixins — order matters (right to left)
class User extends Serializable(Timestamped(Validatable(class {}))) {
  constructor(name, email) {
    super()
    this.name  = name
    this.email = email
  }
}

const u = new User('Alice', 'alice@example.com')
u.serialize()   // '{"name":"Alice","email":"...",...}'
u.createdAt     // Date object
u.validate()    // true