클래스

단일 책임 원칙(SRP) 지키기

하나의 클래스는 하나의 책임만 가지도록 합니다.

• as-is

#Store가 많은 역할을 혼자서 수행합니다.
class Store{
		// 유저랑 커미니케이션 하는 메서드
    communicate_user(self){
        ...
		}
		// 상품 재고 관리
    manage_products(self){
        ...
		}
		// 돈을 관리하는 메서드
    manage_money(self){
        ...
		}
}

• to-be

# 책임을 나눠서 Manger 클래스에게 책임을 전가합니다.
class CounterManager{
    communicate_user(){
			console.log(1)
	}
}

class ProductManager{
    manage_products(){
        ...
	}
}

class Owner{
    manage_money(){
        ...
	}
}

class Store{
    constructor(counter_manager: CounterManager, product_manager: ProductManager, owner: Owner){
        this.counter_manager = counter_manager
        this.product_manager = product_manager
        this.owner = owner
		}
    sell_product(){
        this.counter_manager.communicate_user()
        ...
		}
    manage_products(){
        ...
		}
}

interface Manager{ 
    communicate_user(name:string): void
}

class CounterManager implements Manager{
    private manager: string
    constructor(manager:string){
        this.manager = manager
    }
    communicate_user(){
        console.log(this.manager)
    }
}

class Store{
    private counter_manager: Manager
    constructor(counter_manager: Manager){
        this.counter_manager = counter_manager
		}
    sell_product(name:string){
        this.counter_manager.communicate_user(name)
		}
}
const manager:CounterManager = new CounterManager('seungbin')
const market = new Store(manager)

응집도를 높이자

• 응집도는 클래스의 변수와 메서드들이 얼마나 유기적으로 엮여있냐를 나타내는
  • 응집도가 높을수록 클래스의 메서드들은 인스턴스 변수들을 많이 사용합니다.
  • 응집도가 낮을수록 클래스의 메서드들은 인스턴스 변수들을 적게 혹은 사용하지 않습니다.
• as-js
• class LowCohesion{ private a private b private c constructor(){ this.a = ... this.b = ... this.b = ... } process_a(){ console.log(this.a) } process_b(){ console.log(this.b) } process_c(){ console.log(this.c) } }
• to-be

변경하기 쉽게 만들자

새 기능을 수정하거나 기존 기능을 변경할 때, 코드의 변경을 최소화하는 게 중요합니다.

일반적으로 클래스(객체)는 구현(Concrete)와 추상(Abstract)으로 나뉘게 됩니다. 구현에는 실제 동작하는 구체적인 코드가, 추상은 인터페이스나 추상 클래스처럼 기능을 개념화한 코드가 들어갑니다.

일반적으로 변경하기 쉽게 설계하기 위해선 추상화를 해두고 구체 클래스에 의존하지 않고 추상 클래스(인터페이스)에 의존하도록 코드를 짜는 것이 중요합니다.

class Developer{
	coding(){
		console.log('코딩을 합니다.')
	}
}

class Designer{
	design(){
		console.log('디자인을 합니다.')
	}
}

class Analyst{
	analyze(){
		console.log('분석을 합니다.')
	}
}

type job = Analyst | Designer | Developer

class Company{
	private employees: job
	constructor(employees: job){
		this.employees = employees

	}

	makeWork(){
		if(this.employees instanceof Developer){
			this.employees.coding()
		} else if(this.employees instanceof Analyst){
			this.employees.analyze()
		} else if(this.employees instanceof Designer){
			this.employees.design()
		}
	}
}

const dev = new Developer()
const google = new Company(dev)
google.makeWork()

class Employee{
	work(){
		console.log('일을 합니다.')
	}
}

class Developer implements Employee{
	work(){
		console.log('코딩을 합니다.')
	}
}

class Designer implements Employee{
	work(){
		console.log('디자인을 합니다.')
	}
}

class Analyst implements Employee{
	work(){
		console.log('분석을 합니다.')
	}
}

type job = Analyst | Designer | Developer

class Company{
	private employees: job
	constructor(employees: job){
		this.employees = employees

	}

	makeWork(){
		this.employees.work()
	}
}

const dev = new Developer()
const google = new Company(dev)
google.makeWork() // 코딩을 합니다.