클래스의 실체

class Dog {
  constructor(name) {
    this.name = name;
  }
  bark() {
    return this.name + " barks!";
  }
}

typeof Dog; // "function"

// class 문법
class Dog {
  constructor(name) { this.name = name; }
  bark() { return this.name + " barks!"; }
}

// 동등한 생성자 함수 패턴
function Dog(name) { this.name = name; }
Dog.prototype.bark = function() {
  return this.name + " barks!";
};

function OldDog() {}
OldDog(); // 동작함 (좋지 않지만)

class NewDog {}
NewDog(); // TypeError: Class constructor NewDog
          // cannot be invoked without 'new'

class Dog {
  bark() {
    // 여기는 자동으로 strict mode
    undeclaredVar = 1; // ReferenceError
  }
}

class Dog {
  bark() {}
}

// class 메서드는 열거되지 않음
Object.keys(Dog.prototype); // [], bark가 안 보임

// 생성자 함수 방식은 열거됨
function OldDog() {}
OldDog.prototype.bark = function() {};
Object.keys(OldDog.prototype); // ["bark"]

// 함수 선언, 호이스팅됨
const dog = new OldDog(); // 동작함
function OldDog() {}

// class 선언, TDZ
const dog2 = new NewDog(); // ReferenceError!
class NewDog {}

class Animal {
  constructor(name) {
    this.name = name;
  }
  speak() {
    return this.name + " speaks";
  }
}

class Dog extends Animal {
  bark() {
    return this.name + " barks";
  }
}

const d = new Dog("Rex");
d.bark();  // "Rex barks" , Dog.prototype
d.speak(); // "Rex speaks", Animal.prototype

// 1. 인스턴스 메서드 상속
Object.getPrototypeOf(Dog.prototype) === Animal.prototype; // true
// d.speak()를 찾을 때: d → Dog.prototype → Animal.prototype

// 2. 정적 메서드 상속
Object.getPrototypeOf(Dog) === Animal; // true
// Dog.create()를 찾을 때: Dog → Animal

function Animal(name) { this.name = name; }
Animal.prototype.speak = function() {
  return this.name + " speaks";
};

function Dog(name) { Animal.call(this, name); }

// extends가 하는 일
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;
Object.setPrototypeOf(Dog, Animal);

Dog.prototype.bark = function() {
  return this.name + " barks";
};

class Dog extends Animal {
  constructor(name, breed) {
    super(name);     // Animal의 constructor 호출
    this.breed = breed;
  }
}

class Dog extends Animal {
  constructor(name) {
    this.breed = "unknown"; // ReferenceError!
    super(name);            // super() 전에 this 사용 불가
  }
}

class Dog extends Animal {
  speak() {
    const parentResult = super.speak();
    return parentResult + " and barks";
  }
}

const d = new Dog("Rex");
d.speak(); // "Rex speaks and barks"

class Dog {
  constructor(name) {
    this.name = name;
  }

  // 인스턴스 메서드, Dog.prototype에 저장
  bark() {
    return this.name + " barks";
  }

  // 정적 메서드, Dog 자체에 저장
  static create(name) {
    return new Dog(name);
  }
}

const d = Dog.create("Rex"); // Dog.create(), OK
d.bark();                     // d.bark(), OK
d.create("Buddy");            // TypeError, 인스턴스에서는 접근 불가

class Dog {
  #name; // private 필드

  constructor(name) {
    this.#name = name;
  }

  get name() {
    return this.#name;
  }
}

const d = new Dog("Rex");
d.name;   // "Rex" (getter)
d.#name;  // SyntaxError, 외부 접근 불가