Skip to main content

클래스

typeScript 공식 핸드북을 참고하였습니다.

구조#

  • javascript 의 클래스 구조와 비슷합니다.
  • 프로퍼티의 타입을 반드시 표기해 주어야합니다.
  • 컴파일 옵션의 strictPropertyInitialization 가 true 상태면 constructor에서 반드시 초기화를 해주어야합니다. (strict 옵션 안에 포함)
class Greeter {
greeting: string;
constructor(message: string) {
this.greeting = message;
}
greet() {
return 'Hello, ' + this.greeting;
}
}
let greeter = new Greeter('world');

상속#

  • javascript 의 상속과 비슷합니다.
  • 단, constructor를 자식클래스에서도 선언해주었다면, 부모클래스의 constructor(super();)를 반드시 선언해주어야합니다.
  • 메소드 오버라이딩이 가능합니다.
class Person {
name: string;
constructor(name: string) {
this.name = name;
}
shout() {
console.log('Ah...Um..');
}
}
class Student extends Person {
shout() {
console.log('I AM FREE!');
}
}
class WorkingMan extends Person {
field: string;
constructor(name: string, field: string) {
super(name);
this.field = field;
}
mumble() {
console.log('br..hat...uk!');
}
}

Public, Private, and Protected#

  • 클래스의 멤버들은 public 이 디폴트로 되어있습니다.
  • public을 명시적으로 표기할 수 있습니다. ∴ name과 age, hello()와 hi()는 구조적으로 같습니다.
class Person {
public name: string;
age: number;
public constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
public hello(): void {
console.log(`hello, I'm ${this.name}`);
}
hi() {
console.log(`Hi, I'm ${this.name}`);
}
}

private#

  • private 멤버는 기본적으로 클래스 외부에서 접근할 수 없습니다.
  • javascript의 관습처럼 private 멤버들에겐 앞에 _를 붙입니다.
class SecretPerson {
private _name: string;
private _age: number;
constructor(name: string, age: number) {
this._name = name;
this._age = age;
}
private _monologue() {
console.log('I never said this...');
}
}
let sp = new SecretPerson('Jack', 20);
sp._name; // error : Property '_name' is private and only accessible within class 'SecretPerson'.

protected#

  • protected 멤버는 부모-자식 클래스 끼리만 접근할 수 있습니다. 컨스트럭터 또한 그렇습니다.
class Person {
protected name: string;
protected constructor(theName: string) {
this.name = theName;
}
}
// Employee can extend Person
class Employee extends Person {
private department: string;
constructor(name: string, department: string) {
super(name);
this.department = department;
}
public getElevatorPitch() {
return `Hello, my name is ${this.name} and I work in ${this.department}.`;
}
}
let howard = new Employee('Howard', 'Sales');
let john = new Person('John'); // Error: The 'Person' constructor is protected

ReadOnly Modifier#

class Octopus {
readonly name: string;
readonly numberOfLegs: number = 8;
constructor(theName: string) {
this.name = theName;
}
}
let dad = new Octopus('Man with the 8 strong legs');
dad.name = 'Man with the 3-piece suit'; // error! name is readonly.

매개 변수 프로퍼티#

  • 매개 변수에 private, public, protected, readOnly를 덧붙이면 클래스 멤버로 자동으로 선언과 할당을 해줍니다.
class Person {
constructor(private name: string) {}
}

접근자#

  • getter setter 를 제공합니다.
  • ECMAScript 5 이상만 지원합니다.
  • getter 만 사용하면 자동으로 readOnly로 추론됩니다.
const fullNameMaxLength = 10;
class Employee {
private _fullName: string;
get fullName(): string {
return this._fullName;
}
set fullName(newName: string) {
if (newName && newName.length > fullNameMaxLength) {
throw new Error('fullName has a max length of ' + fullNameMaxLength);
}
this._fullName = newName;
}
}
let employee = new Employee();
employee.fullName = 'Bob Smith';
if (employee.fullName) {
console.log(employee.fullName);
}

Static#

class Grid {
static origin = { x: 0, y: 0 };
calculateDistanceFromOrigin(point: { x: number; y: number }) {
let xDist = point.x - Grid.origin.x;
let yDist = point.y - Grid.origin.y;
return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
}
constructor(public scale: number) {}
}
let grid1 = new Grid(1.0); // 1x scale
let grid2 = new Grid(5.0); // 5x scale
console.log(grid1.calculateDistanceFromOrigin({ x: 10, y: 10 }));
console.log(grid2.calculateDistanceFromOrigin({ x: 10, y: 10 }));

추상 클래스 (abstract)#

  • 추상 클래스는 인스턴스를 만들 수 없습니다.
abstract class Department {
constructor(public name: string) {}
printName(): void {
console.log('Department name: ' + this.name);
}
abstract printMeeting(): void; // must be implemented in derived classes
}
class AccountingDepartment extends Department {
constructor() {
super('Accounting and Auditing'); // constructors in derived classes must call super()
}
printMeeting(): void {
console.log('The Accounting Department meets each Monday at 10am.');
}
generateReports(): void {
console.log('Generating accounting reports...');
}
}
let department: Department; // ok to create a reference to an abstract type
department = new Department(); // error: cannot create an instance of an abstract class
department = new AccountingDepartment(); // ok to create and assign a non-abstract subclass
department.printName();
department.printMeeting();
department.generateReports(); // error: method doesn't exist on declared abstract type