C#에서의 객체지향에 관한 PPT입니다 필자의 생각과 경험으로 만든 자료라 일반적인 교육 자료와 사용하는 용어 등이 매우 다를 수 있습니다. --------------------------------------------------- PPT about Object-Oriented Programming in C# Language

1. HELLO, C# : OOP
by Variel
http://blog.variel.kr/

2. 객체지향 (Object-Orient)
자기의 일은 스스로 하자

3. 객체지향 – 철학적인 바탕
• 이 세상이 작동하는 원리를 프로그래밍에 담자
• 이 세상이 작동하는 원리란?
1. 이 세상을 물체들로 이루어져있다
2. 물체들은 각자 고유한 특성을 가지고 있다
3. 물체와 물체들은 서로 상호작용을 하며 세상을 움직인다
• 물체의 내외는 분리되어 필요한 인터페이스를 통해 상호작용한다

4. 객체지향 – 프로그래밍에서의 장점
• 물체 내외가 분리되어있어
물체의 외부가 물체의 내부에 함부로 영향을 주지 못 한다
• 프로그래머가 신경을 쓸 부분이
물체의 내부적인 특성과 외부와의 인터페이스
두 가지로 압축된다
• 유지 및 보수가 쉬워진다
• 필요한 부분을 다른 프로젝트에서 재사용할 수 있다

5. 클래스 (Class)
세상 모든 물체를 분류하다

6. 클래스 (class: [C] 부류, 종류)
• 세상의 수많은 물체들은 공통으로 속한 분류가 있다
• 이예찬, 문상현: 인간
• 아이폰6, 갤럭시S6: 스마트폰
• 박보영, 아이유, 김태희: 여신
• 그 물체들은 보다 저차원 적인 분류를 상속받을 수 있다
• 인간: 포유류
• 스마트폰: 통신장비
• 포유류: 동물
• 통신장비: 물체
• 동물: 물체

7. 클래스 (class: [C] 부류, 종류)
• 서로 다른 물체들의 공통된 부분을 묶어 분류하여 틀로 만든 것
• 예시
• 게임 캐릭터들은 공통적으로 HP를 가진다
• 게임 캐릭터들은 상대방으로부터 데미지를 입을 수 있다
• 게임 캐릭터들은 상대방을 공격할 수 있다.
• 틀로부터 물체들을 찍어낼 수 있으며,
물체 별로 특성을 할당할 수 있다.
• 예시
• GameCharacter p1 = new GameCharacter();
• GameCharacter p2 = new GameCharacter();
• p1.Hp = 100;
• p2.Hp = 50;

8. 정보의 은닉 (Encapsulation)
“나에 대해 너무 알려고 하지 말고 간섭도 하지 말아요!”

9. 정보의 은닉 (캡슐화) – 현실과의 비교
• 물체 외부에서 물체 내부의 특성을 함부로 조작하면 안 된다
• 반드시 다른 물체와의 상호작용을 통해 조작되어야 한다
• 예시
• ‘사람의 시력’이라는 값을 함부로 조작할 수는 없다
• ‘가까운 거리를 계속 보고 있기’등 상호작용을 통해 시력이 변할 수는 있다
• 참고: http://blog.variel.kr/220073616076

10. 정보의 은닉 (캡슐화) – 접근 제한자
• public vs private
• 내부의 특성은 private, 외부로 공개되는 상호작용은 public을 쓴다
• 같은 클래스 내부에서는 private 특성들에 모두 접근이 가능하다
• 다른 클래스 간에는 public 상호작용들을 통해서만 접근이 가능하다

11. 정보의 은닉 (캡슐화) - 예시
public class GameObject
{
private double hitPoint;
private double physicalDefencePoint;
private double magicalDefencePoint;
private double defencePointMultiplier;
public double GetTotalDefencePoint()
{
return (this.physicalDefencePoint + this.magicalDefencePoint)
*this.defencePointMultiplier;
}
public double Damage(double physicalAttckPoint,
double magicalAttackPoint)
{
this.hitPoint -= (physicalAttckPoint - this.physicalDefencePoint*this.defencePointMultiplier)
+ (magicalAttackPoint - this.physicalDefencePoint*this.defencePointMultiplier);
}
}
설명: 게임 오브젝트의 방어력도 다 같은 게 아니라 물리방어력, 마법방어력 등 다양한 방어력이 있다. 해당
게임 오브젝트의 총 방어력을 가져오는 상호작용이 정의가 되어 있고, 물리공격력과 마법공격력을 각각 입력
받아 데미지를 입게 만드는 상호작용이 정의가 되어 있다. 물리방어력과 마법 방어력, 체력 등의 특성들은 외
부에서 함부로 변경이 되면 안 된다.

12. 추상화 (Abstraction)
복잡한 것을 간단하게, 그걸 또 간단하게

13. 추상화 – 현실과의 비교
• 어떤 행위들을 단순화 시킨 것
• 예시
1. 다리의 대퇴사두근을 수축시켜 다리를 들어올리고
2. 반대쪽 다리의 종아리를 이완시켜 앞으로 기울인 다음
3. 다시 대퇴사두근을 이완시켜 다리를 내려놓는다
4. 이 과정을 반복한다
• 이 과정들을 추상화 하여 ‘걷기’라고 부른다

14. 추상화
• 함수를 만들어서 사용하는 것 부터가 일종의 추상화
• 복잡한 것을 더 단순하게 소스코드상에 표현할 수 있다
• 세부적인 것을 알 필요가 없으므로
소스코드를 훑었을 때 눈에 빨리 들어온다

15. 상속 (Inheritance)
자식은 부모를 닮는다! 아니, 포함한다!

16. 상속 – 현실과의 비교
• 인간(호모 사피엔스 사피엔스)는 생물 분류 체계에서
아래와 같은 위치에 속해있다
• 동물계
• 척추동물아문
• 포유류
• 영장목
• 유인원과
• 유인원과 동물들은 영장목의 공통된 특징들을 모두 가지고 있다
• 영장목의 동물들은 포유류의 공통된 특징들을 모두 가지고 있다
• 포유류의 동물들은 척추동물아문의 공통된 특징들을 모두 가지고 있다
• 척추동물아문의 동물들 동물계 전체의 공통된 특징을 모두 가지고 있다

17. 상속
• 부모 클래스의 특성 및 상호작용을
자식 클래스가 그대로 가지고 있는 것
public class Parent
{
private int hp;
public int GetHp() { return hp; }
public void SetHp(int value) { hp = value; }
}
public class Child : Parent
{
private int mp;
public int GetMp() { return mp; }
public void SetMp(int value) { mp = value; }
}
선언 사용
상속 받은
상호작용

18. 상속
• 자식 클래스는 부모 클래스의 모
든 것을 가지고 있기에
아래와 같은 표현도 유효 하다
• 대신 부모 클래스의 것들만 쓸
수 있다
• 부모 클래스는 자식 클래스의 모
든 것을 가지고 있지는 않으므로
아래와 같은 표현은 불가하다
Child child = new Parent();
child.SetHp(100);
child.SetMp(100);
Parent child = new Child();
child.SetHp(100);
child.SetMp(100); 불가능
불가능

19. 상속 – public vs private vs protected
• public
• 어느 곳에서든 접근 할 수 있다
• private
• 선언 한 클래스 내부에서만 접근 할 수 있다
• 자식 클래스도 접근을 못 한다
• protected
• 자식 클래스들이 접근할 수 있다
• 선언 한 클래스 내부에서도 당연히 접근할 수 있다
• 자식이 아닌 클래스에서는 접근 할 수 없다

20. 다형성 (Polymorphism)
피부 색이 달라도 우리는 모두 인간!

21. 다형성 – 현실과의 비교
• 인간이 두 다리를 써서 움직이는 행위
• 개가 네 다리를 써서 움직이는 행위
• 비둘기가 두 다리를 써서 움직이는 행위
• 모두 ‘걷기’라고 할 수 있다.
• 비둘기가 두 날개를 써서 움직이는 행위
• 독수리가 두 날개를 써서 움직이는 행위
• 모두 ‘날기’라고 할 수 있다

22. 다형성
• ‘다리 달린 것(HasLeg)’이라는 부모 클래스가 있다
• 이 클래스를 상속 받은 사람, 개, 비둘기라는 클래스가 있다
• 모두 걸을 수 있다(Walk)
• 그렇다면 아래의 코드가 가능하다
HasLeg animal;
animal = new Human();
animal.Walk();
animal = new Dog();
animal.Walk();
animal = new Dove();
animal.Walk();

23. 다형성
• 같은 의미의 동작이지만 실행 주체에 따라서 내부의 동작이 다르다
• 인간의 ‘걷기’는 두 다리를 써서 걷는다
• 개의 ‘걷기’는 네 다리를 써서 걷는다
• 비둘기의 ‘걷기’는 두 다리를 써서 걷는다
• 어쨌든 ‘다리 달린 것’은 ‘걷기’를 할 수 있다
• ‘다리 달린 것’ 형태의 변수를 선언하면
실제 그것이 인간이든 개이든 비둘기이든 간에 ‘걷기’를 할 수 있다.
• 다만 그 내부의 동작은 다를 수 있다.

24. 다형성 – 소스코드
• 일반적으로 부모가 가진 메소드를 자식은 그대로 쓴다
• 하지만 자식은 그 메소드를 다시 정의할 수 있다
• 부모 입장에서는 자식이 재정의 해도 된다는 의미로
virtual이라는 키워드를 사용한다
• 자식 입장에서는 부모의 메소드를 재정의 한다는 의미로
override라는 키워드를 사용한다
public class Animal
{
public virtual void Move(int distance)
{
Console.WriteLine("I'm doing animal walking");
}
}
public class Human : Animal
{
public override void Move(int distance)
{
Console.WriteLine("I'm doing human walking");
}
}

25. 인터페이스 (Interface)
너와! 나의! 연결! 고리!

26. 인터페이스 – 현실과의 비교
• 한 사람은 둘 이상의 부모(어머니 + 아버지)를 가질 수 없다
• 동물은 움직인다. 식물은 거의 못 움직인다. 근데 예외는 있다
• 파리지옥도 무언가를 쥘 수 있고 사람도 무언가를 쥘 수 있다
• 근데 그 둘은 완전히 다른 계에 있다(식물계 – 동물계)
• 즉, 상속 관계가 전혀 없다
• 그렇지만 쥘 수 있다는 것은 같다
• 그냥 ‘쥘 수 있는 능력이 있다’는 것을 나타낼 수는 없을까?

27. 인터페이스
• 내부에서 어떻게 동작하는지는 관심 없다
• 어차피 외부에 노출이 돼서 사용 되는 것은 상호작용, 즉 인터페이스
• 인터페이스는 다중 상속구현이 가능하다!
• 예: 사람은 ‘쥘 수 있음’, ‘걸을 수 있음’, ‘볼 수 있음’ 등의
인터페이스를 구현할 수 있다.

28. 인터페이스 – 소스코드
• 인터페이스는 public 상호작용만 가질 수 있다
• ‘~할 수 있다’고 했는데 내부에서만 할 수 있는 건 말이 안 되기 때문
• 따라서 접근 제한자를 쓸 필요가 없다 (무조건 public)
• 인터페이스를 상속 받는 클래스는 반드시 public으로
상호작용을 구현해야 한다
public interface IGrabbable
{
void Grab(Object something);
}
public interface IWalkable
{
void Walk(int distance);
}
인터페이스 선언 public class Human : IGrabbable, IWalkable
{
public void Grab(Object something)
{
// Do Something
}
public void Walk(int distance)
{
// Do Something
}
}
인터페이스 사용 (상속 및 구현)
public class Program
{
public static void Main(string[] args)
{
Human yeChan = new Human();
yeChan.Grab(yeChan);
yeChan.Walk(100);
IGrabbable grabbable = yeChan;
grabbable.Grab(yeChan);
grabbable.Walk(); // ERROR
IWalkable walkable = yeChan;
walkable.Walk(100);
walkable.Grab(yeChan); //ERROR
}
}
구현된 오브젝트 사용