러닝 타입스크립트 CHAPTER 8 - 클래스

class Greeter {
  greet(name: string) {
    console.log(`${name}, do tour stuff!`)
  }
}

new Greeter().greet('Miss Frizzle') // OK

new Greeter().greet()
// Error: Expected 1 arguments, but got 0.

class Greeted {
  constructor(message: string) {
    console.log('As I always say: ${message}!')
  }
}

new Greeted('take chances, make mistakes, get messy')

new Greeted()
// Error: Expected 1 arguments, but got 0.

class FieldTrip {
  destination: string

  constructor(destination: string) {
    this.destination = destination // OK
    console.log(`We're going to ${this.destination}!`)

    this.nonexistent = destination
    // Error: Property 'nonexistent' does not exist on type 'FieldTrip'.
  }
}

const trip = new FieldTrip('planetarium')

trip.destination // OK

trip.nonexistent
// Error: Property 'nonexistent' does not exist on type 'FieldTrip'.

class WithMethod {
  myMethod() {}
}

new WithMethod().myMethod === new WithMethod().myMethod // true

class WithProperty {
  myProperty: = () => {}
}

new WithProperty().myProperty === new WithProperty().myProperty // false

class WithPropertyParameters {
  takesParameters = (input: boolean) => (input ? 'Yes' : 'No')
}

const instance = new WithPropertyParameters()

instance.takesParameters(true) // OK

instance.takesParameters(123)
// Error: Argument of type 'number' is not assignable to parameter of type 'boolean'.

class WithValue {
  immediate = 0 // OK
  later: number // OK (constructor에서 할당)
  mayBeUndefined: number | undefined // OK (undefined가 되는 것이 허용됨)
  unused: number
  // Error: Property 'unused' has no initializer
  // and is not definitely assigned in the constructor.

  constructor() {
    this.later = 1
  }
}

class ActivitiesQueue {
  pending!: string[] // OK

  initialize(pending: string[]) {
    this.pending = pending
  }

  next() {
    return this.pending.pop()
  }
}

const activities = new ActivitiesQueue()

activities.initialize(['eat', 'sleep', 'learn'])
activities.next()

class MissingInitializer {
  property?: string
}

new MissingInitializer().property?.length // OK

class Quote {
  readonly text: string

  constructor(text: string) {
    this.text = text
  }

  emphasize() {
    this.text += '!'
    // Error: Cannot assign to 'text' because it is a read-only property.
  }
}

const quote = new Quote('There is a briliant child locked inside every student.')
quote.text = 'Ha!'
// Error: Cannot assign to 'text' because it is a read-only property.

class Teacher {
  sayHello() {
    console.log('Take chances, make mistakes, get messy!')
  }
}

let teacher: Teacher

teacher = new Teacher() // OK

interface Learner {
  name: string
  study(hours: number): void
}

class Student implements Learner {
  name: string

  constructor(name: string) {
    this.name = name
  }

  study(hours: number) {
    for (let i = 0; i < hours; i += 1) {
      console.log('...studying...')
    }
  }
}

class Teacher {
  teach() {
    console.log('teach')
  }
}

class StudnetTeacher extends Teacher {
  learn() {
    console.log('learn')
  }
}

const teacher = new StudnetTeacher()

teacher.teach() // OK (기본 클래스에 정의됨)
teacher.learn() // OK (하위 클래스에 정의됨)

class Lesson {
  // ~~~
}

class OnlineLesson extends Lesson {
  // ~~~
}

let lesson: Lesson
lesson = new Lesson() // OK
lesson = new OnlineLesson() // OK

abstract class School {
  readonly name: string

  constructor(name: string) {
    this.name = name
  }

  abstract getStudentTypes(): string[]
}

class PreSchool extends School {
  getStudentTypes() {
    return ['preschooler']
  }
}

class Base {
  isPublicImplicit = 0
  public isPublicExplicit = 1
  protected isProtected = 2
  private isPrivate = 3
  #truePrivate = 4
}

class Subclass extends Base {
  examples() {
    this.isPublicImplicit // OK
    this.isPublicExplicit // OK
    this.isProtected // OK

    this.isPrivate
    // Error: Property 'isPrivate' is private and only accessible within class 'Base'.

    this.#truePrivate
    // Error: Property '#truePrivate' is not accessible outside
    // class 'Base' because it has a private identifier.
  }
}

new Subclass().isPublicImplicit // OK
new Subclass().isPublicExplicit // OK

new Subclass().isProtected
// Error: Property 'isProtected' is protected
// and only accessible within class 'Base' and its subclasses.

new Subclass().isPrivate
// Error: Property 'isPrivate' is private and only accessible within class 'Base'.