11장 DIP:의존성 역전 원칙

자유롭게 작성 해 주세요.

재영

DIP

• 추상적인 선언만을 참조해야 하고, 구체적인 대상에 의존하지 않는다.
• 하지만, 안정성이 보장된 환경에 대해서는 의존성을 용납한다.
• 즉, 변동성이 큰 구체적인 요소에 의존을 피해야 한다.

class Tool:
    def harvest(self):
        pass


class Hand(Tool):
    def harvest(self):
        grap()
        pull_out()


class Machine(Tool):
    def harvest(self):
        cut()
        stack()


# Bad
class Farmer:
    # 구현 클래스를 직접 의존하였다.
    tool = Hand()

    def harvest(self):
        # 구현 클래스 내부의 로직에 의존성이 쉽게 생길 수 있다.
        self.tool.grap()
        self.tool.pull_out()


class Farmer:
    tool = Machine()


# Good
class ToolFactory():
    def choose_tool():
        # 적절한 툴을 쥐어준다.
        # 툴의 내부 구현에 의존하지 않도록 한다.
        return Hand or Machine


class Farmer:
    def __init__(self):
        tool = ToolFactory().choose_tool()

    def harvest(self):
        # 인터페이스에 의존하여, 구현 클래스의 특정 로직에 대한 의존 가능성을 줄일 수 있다.
        self.tool.harvest()
		

학진

급 디자인패턴에 의문이 생겨서 논의해보고 싶었습니다. 왜 추상 팩토리 패턴이어야 하는가?

CharacterFactory {
	Character create(type) {
		if type == "human" {
			return Human()
		} else if type == "dog" {
			return Dog()
		}
	}
}
Character interface {
	do()
}

main() {
	Character ch = CharacterFactory.create(config.CharacterType)
	ch.do()
}
==============================
Factory interface {
	Character create()
}
Character interface {
	do()
}
HumanFactory {
	Character create() {
		return Human()		
	}
}
DogFactory {
	Character create() {
		return Dog()		
	}
}

Factory FactoryMaker(type) {	
	if type == "human" {
		return HumanFactory()
	} else if type == "dog" {
		return DogFactory()
	}
}

main() {
	Factory factory = FactoryMaker(config.FactoryType)
	Character ch = factory.create()
	ch.do()
}