• 컴퓨터/IT > 컴퓨터공학 > UML/객체지향

2019/7 컴퓨터/IT 27위 | 현재 컴퓨터/IT 638위 |

• [시리즈] 위키북스 IT Leaders 시리즈 [27]

출판사 리뷰

▣ 들어가며: 프로그래밍 패러다임
01 패러다임의 시대\t
02 프로그래밍 패러다임\t

▣ 1장: 객체, 설계
01. 티켓 판매 애플리케이션 구현하기\t
02. 무엇이 문제인가\t
___예상을 빗나가는 코드\t
___변경에 취약한 코드\t
03. 설계 개선하기\t
___자율성을 높이자\t
___무엇이 개선됐는가\t
___어떻게 한 것인가\t
___캡슐화와 응집도\t
___절차지향과 객체지향\t
___책임의 이동\t
___더 개선할 수 있다\t
___그래, 거짓말이다!\t
04. 객체지향 설계\t
___설계가 왜 필요한가\t
___객체지향 설계\t

▣ 2장: 객체지향 프로그래밍
01. 영화 예매 시스템\t
___ 요구사항 살펴보기\t
02. 객체지향 프로그래밍을 향해\t
___ 협력, 객체, 클래스\t
___ 도메인의 구조를 따르는 프로그램 구조\t
___ 클래스 구현하기\t
___ 협력하는 객체들의 공동체\t
___ 협력에 관한 짧은 이야기\t
03. 할인 요금 구하기\t
___ 할인 요금 계산을 위한 협력 시작하기\t
___ 할인 정책과 할인 조건\t
___ 할인 정책 구성하기\t
04. 상속과 다형성\t
___ 컴파일 시간 의존성과 실행 시간 의존성\t
___ 차이에 의한 프로그래밍\t
___ 상속과 인터페이스\t
___ 다형성\t
___ 인터페이스와 다형성\t
05. 추상화와 유연성\t
___ 추상화의 힘\t
___ 유연한 설계\t
___ 추상 클래스와 인터페이스 트레이드오프\t
___ 코드 재사용\t
___ 상속\t
___ 합성\t

▣ 3장: 역할, 책임, 협력
01. 협력\t
___ 영화 예매 시스템 돌아보기\t
___ 협력\t
___ 협력이 설계를 위한 문맥을 결정한다\t
02. 책임\t
___ 책임이란 무엇인가\t
___ 책임 할당\t
___ 책임 주도 설계\t
___ 메시지가 객체를 결정한다\t
___ 행동이 상태를 결정한다\t
03. 역할\t
___ 역할과 협력\t
___ 유연하고 재사용 가능한 협력\t
___ 객체 대 역할\t
___ 역할과 추상화\t
___ 배우와 배역\t

▣ 4장: 설계 품질과 트레이드오프
01. 데이터 중심의 영화 예매 시스템\t
___ 데이터를 준비하자\t
___ 영화를 예매하자\t
02. 설계 트레이드오프\t
___ 캡슐화\t
___ 응집도와 결합도\t
03. 데이터 중심의 영화 예매 시스템의 문제점\t
___ 캡슐화 위반\t
___ 높은 결합도\t
___ 낮은 응집도\t
___ 캡슐화를 지켜라\t
04. 자율적인 객체를 향해\t
___ 스스로 자신의 데이터를 책임지는 객체\t
___ 캡슐화 위반\t
05. 하지만 여전히 부족하다\t
___ 높은 결합도\t
___ 낮은 응집도\t
___ 데이터 중심 설계는 객체의 행동보다는 상태에 초점을 맞춘다\t
06. 데이터 중심 설계의 문제점\t
___ 데이터 중심 설계는 객체를 고립시킨 채 오퍼레이션을 정의하도록 만든다\t

▣ 5장: 책임 할당하기
01. 책임 주도 설계를 향해\t
___ 데이터보다 행동을 먼저 결정하라\t
___ 협력이라는 문맥 안에서 책임을 결정하라\t
___ 책임 주도 설계\t
02. 책임 할당을 위한 GRASP 패턴\t
___ 도메인 개념에서 출발하기\t
___ 정보 전문가에게 책임을 할당하라\t
___ 높은 응집도와 낮은 결합도\t
___ 창조자에게 객체 생성 책임을 할당하라\t
03. 구현을 통한 검증\t
___ DiscountCondition 개선하기\t
___ 타입 분리하기\t
___ 다형성을 통해 분리하기\t
___변경으로부터 보호하기\t
___ Movie 클래스 개선하기\t
___ 변경과 유연성\t
04. 책임 주도 설계의 대안\t
___ 메서드 응집도\t
___ 객체를 자율적으로 만들자\t

▣ 6장: 메시지와 인터페이스
01. 협력과 메시지\t
___ 클라이언트-서버 모델\t
___ 메시지와 메시지 전송\t
___ 메시지와 메서드\t
___ 퍼블릭 인터페이스와 오퍼레이션\t
___ 시그니처\t
02. 인터페이스와 설계 품질\t
___ 묻지 말고 시켜라\t
___ 의도를 드러내는 인터페이스\t
___ 함께 모으기\t
03. 원칙의 함정\t
___ 디미터 법칙은 하나의 도트(.)를 강제하는 규칙이 아니다\t
___ 결합도와 응집도의 충돌\t
04. 명령-쿼리 분리 원칙\t
___ 반복 일정의 명령과 쿼리 분리하기
___ 명령-쿼리 분리와 참조 투명성\t
___ 책임에 초점을 맞춰라\t

▣ 7장: 객체 분해
01. 프로시저 추상화와 데이터 추상화\t
02. 프로시저 추상화와 기능 분해\t
___ 메인 함수로서의 시스템\t
___ 급여 관리 시스템\t
___ 급여 관리 시스템 구현\t
___ 하향식 기능 분해의 문제점\t
___ 언제 하향식 분해가 유용한가?\t
03. 모듈\t
___ 정보 은닉과 모듈\t
___ 모듈의 장점과 한계\t
04. 데이터 추상화와 추상 데이터 타입\t
___ 추상 데이터 타입\t
05. 클래스\t
___ 클래스는 추상 데이터 타입인가?
___ 추상 데이터 타입에서 클래스로 변경하기\t
___ 변경을 기준으로 선택하라\t
___ 협력이 중요하다\t

▣ 8장: 의존성 관리하기
01. 의존성 이해하기\t
___ 변경과 의존성\t
___ 의존성 전이\t
___ 런타임 의존성과 컴파일타임 의존성\t
___ 컨텍스트 독립성\t
___ 의존성 해결하기\t
02. 유연한 설계\t
___ 의존성과 결합도\t
___ 지식이 결합을 낳는다\t
___ 추상화에 의존하라\t
___ 명시적인 의존성\t
___ new는 해롭다\t
___ 가끔은 생성해도 무방하다\t
___ 표준 클래스에 대한 의존은 해롭지 않다\t
___ 컨텍스트 확장하기\t
___ 조합 가능한 행동\t

▣ 9장: 유연한 설계
01. 개방-폐쇄 원칙\t
___ 컴파일타임 의존성을 고정시키고 런타임 의존성을 변경하라\t
___ 추상화가 핵심이다\t
02. 생성 사용 분리\t
___ FACTORY 추가하기\t
___ 순수한 가공물에게 책임 할당하기\t
03. 의존성 주입\t
___ 숨겨진 의존성은 나쁘다\t
04. 의존성 역전 원칙\t
___ 추상화와 의존성 역전\t
___ 의존성 역전 원칙과 패키지\t
05. 유연성에 대한 조언\t
___ 유연한 설계는 유연성이 필요할 때만 옳다\t
___ 협력과 책임이 중요하다\t

▣ 10장: 상속과 코드 재사용
01. 상속과 중복 코드\t
___ DRY 원칙\t
___ 중복과 변경\t
___ 상속을 이용해서 중복 코드 제거하기\t
___ 강하게 결합된 Phone과 NightlyDiscountPhone\t
02. 취약한 기반 클래스 문제\t
___ 불필요한 인터페이스 상속 문제\t
___ 메서드 오버라이딩의 오작용 문제\t
___ 부모 클래스와 자식 클래스의 동시 수정 문제\t
03. Phone 다시 살펴보기\t
___ 추상화에 의존하자\t
___ 차이를 메서드로 추출하라\t
___ 중복 코드를 부모 클래스로 올려라\t
___ 추상화가 핵심이다\t
___ 의도를 드러내는 이름 선택하기\t
___ 세금 추가하기\t
04. 차이에 의한 프로그래밍\t

▣ 11장: 합성과 유연한 설계
01. 상속을 합성으로 변경하기\t
___ 불필요한 인터페이스 상속 문제: java.util.Properties와 java.util.Stack\t
___ 메서드 오버라이딩의 오작용 문제: InstrumentedHashSet\t
___ 부모 클래스와 자식 클래스의 동시 수정 문제: PersonalPlaylist\t
02. 상속으로 인한 조합의 폭발적인 증가\t
___ 기본 정책과 부가 정책 조합하기\t
___ 상속을 이용해서 기본 정책 구현하기\t
___ 기본 정책에 세금 정책 조합하기\t
___ 기본 정책에 기본 요금 할인 정책 조합하기\t
___ 중복 코드의 덫에 걸리다\t
03. 합성 관계로 변경하기\t
___ 기본 정책 합성하기\t
___ 부가 정책 적용하기\t
___ 기본 정책과 부가 정책 합성하기\t
___ 새로운 정책 추가하기\t
___ 객체 합성이 클래스 상속보다 더 좋은 방법이다\t
04. 믹스인\t
___ 기본 정책 구현하기\t
___ 트레이트로 부가 정책 구현하기\t
___ 부가 정책 트레이트 믹스인하기\t
___ 쌓을 수 있는 변경\t

▣ 12장: 다형성
01. 다형성\t
02. 상속의 양면성\t
___ 상속을 사용한 강의 평가\t
___ 데이터 관점의 상속\t
___ 행동 관점의 상속\t
03. 업캐스팅과 동적 바인딩\t
___ 같은 메시지, 다른 메서드\t
___ 업캐스팅\t
___ 동적 바인딩\t
04. 동적 메서드 탐색과 다형성\t
___ 자동적인 메시지 위임\t
___ 동적인 문맥\t
___ 이해할 수 없는 메시지\t
___ self 대 super\t
05. 상속 대 위임\t
___ 위임과 self 참조\t
___ 프로토타입 기반의 객체지향 언어\t

▣ 13장: 서브클래싱과 서브타이핑
01. 타입\t
___ 개념 관점의 타입\t
___ 프로그래밍 언어 관점의 타입\t
___ 객체지향 패러다임 관점의 타입\t
02. 타입 계층\t
___ 타입 사이의 포함관계\t
___ 객체지향 프로그래밍과 타입 계층\t
03. 서브클래싱과 서브타이핑\t
___ 언제 상속을 사용해야 하는가?\t
___ is-a 관계\t
___ 행동 호환성\t
___ 클라이언트의 기대에 따라 계층 분리하기\t
___ 서브클래싱과 서브타이핑\t
04. 리스코프 치환 원칙\t
___ 클라이언트와 대체 가능성\t
___ is-a 관계 다시 살펴보기\t
___ 리스코프 치환 원칙은 유연한 설계의 기반이다\t
___ 타입 계층과 리스코프 치환 원칙\t
05. 계약에 의한 설계와 서브타이핑\t
___ 서브타입과 계약\t

▣ 14장: 일관성 있는 협력
01. 핸드폰 과금 시스템 변경하기\t
___ 기본 정책 확장\t
___ 고정요금 방식 구현하기\t
___ 시간대별 방식 구현하기\t
___ 요일별 방식 구현하기\t
___ 구간별 방식 구현하기\t
02. 설계에 일관성 부여하기\t
___ 조건 로직 대 객체 탐색\t
___ 캡슐화 다시 살펴보기\t
03. 일관성 있는 기본 정책 구현하기\t
___ 변경 분리하기\t
___ 변경 캡슐화하기\t
___ 협력 패턴 설계하기\t
___ 추상화 수준에서 협력 패턴 구현하기\t
___ 구체적인 협력 구현하기\t
___ 협력 패턴에 맞추기\t
___ 패턴을 찾아라\t

▣ 15장: 디자인 패턴과 프레임워크
01. 디자인 패턴과 설계 재사용\t
___ 소프트웨어 패턴\t
___ 패턴 분류\t
___ 패턴과 책임-주도 설계\t
___ 캡슐화와 디자인 패턴\t
___ 패턴은 출발점이다\t
02. 프레임워크와 코드 재사용\t
___ 코드 재사용 대 설계 재사용\t
___ 상위 정책과 하위 정책으로 패키지 분리하기\t
___ 제어 역전 원리\t

▣ 마치며: 나아가기

▣ 부록A: 계약에 의한 설계
01. 협력과 계약\t
___ 부수효과를 명시적으로\t
___ 계약\t
02. 계약에 의한 설계\t
___사전조건\t
___ 사후조건\t
___ 불변식\t
03. 계약에 의한 설계와 서브타이핑\t
___ 계약 규칙\t
___ 가변성 규칙\t
___ 함수 타입과 서브타이핑\t

▣ 부록B: 타입 계층의 구현
___ 클래스를 이용한 타입 계층 구현\t
___ 인터페이스를 이용한 타입 계층 구현\t
___ 추상 클래스를 이용한 타입 계층 구현\t
___ 추상 클래스와 인터페이스 결합하기\t
___ 덕 타이핑 사용하기\t
___ 믹스인과 타입 계층\t

▣ 부록C: 동적인 협력, 정적인 코드
01. 동적 모델과 정적 모델\t
___ 행동이 코드를 결정한다\t
___ 변경을 고려하라\t
02. 도메인 모델과 구현\t
___ 도메인 모델에 관하여\t
___ 몬스터 설계하기\t
___ 행동과 변경을 고려한 도메인 모델\t
___ 분석 모델, 설계 모델, 그리고 구현 모델\t

▣ 부록D: 참고문헌
___ 참고문헌