OOP의 기본개념과 구성

OOP(Object Oriented Programming)

 

세상에 있는 모든 물체에 대해서 클래스와 인스턴스라는 object화시켜서 프로그램을 구성하는 것

 

OOP의 기본 전제는 기능(함수, 변수) 재사용이 가능하도록 설계 및 프로그래밍 했는지

 

---

OOP의 구성

 

1) 캡슐화

 

: 내부 속성(변수)과 함수를 하나로 묶어서 클래스로 선언

 

: 기능이 많아지고 코드가 복잡해질수록 재사용 등으로 활용하기 어렵기 때문에 미리 묶어주는 방법

 

2) 상속과 포함

 

상속 : 상위 클래스의 모든 기능(함수, 변수)을 재사용할 수 있다.

 

포함 : 다른 클래스의 일부 기능(함수)만을 재사용한다.

 

3) 추상화

 

: 실제 대형 프로젝트를 진행할 때 예외처리를 위해 상속을 받아서 특정 기능을 생성하는 경우에 도움이 된다

 

: 프로그램이 복잡해지는 경우 1차적인 설계를 위해 기능을 추상화시켜놓고, 활용여부는 차후 결정하기 위함이다.

 

4) 다형성

 

: 다형성은 구현되는 하위클래스에 따라 클래스를 다르게 처리

 

# 캡슐화

class Encap:
  def __init__(self,value):
    self.value = value
    print('init :', self.value)

  def _set(self):
    print('set :', self.value)

  def printTest(self):
    print('printTest :', self.value)

  # def __printTest2(self):
  #   print('printTest :', self.value)

# object 생성
e = Encap(10)

# object 실행 
# 케이스1
e.__init__(20)
e._set()
e.printTest()
#e.__printTest2()


print('\n')

# 케이스2
e.__init__(30)
e._set()
e.printTest()

# 상속코드

# 클래스 선언
class Person:
    def __init__(self, name):
        self.name = name
        
class Student(Person):      # Person 클래스 상속받음(name 변수를 파라미터로 재사용)
    def study(self):
        print (self.name + " studies hard")

class Employee(Person):     # Person 클래스 상속받음(name 변수를 파라미터로 재사용)
    def work(self):
        print (self.name + " works hard")

# object 생성
s = Student("Dave")
e = Employee("David")

# object 실행
s.study()
e.work()

# 포함코드

# 클래스 선언
class Person:
    def __init__(self, age):
        self.age = age

    def printPerson(self):          # 포함을 사용하기 위한 Person 클래스의 다른 함수
        print('Person_printPerson')

class Student:
    def __init__(self, age):
        self.age = age
        self.p = Person(self)       # Student가 Person에 포함되기 위해, Person 클래스에 대한 object 생성

    def aging(self):
        return self.age

    def personComposit(self,age):
        return age, self.p.printPerson()  # 포함개념적용된 Student 클래스의 Person object의 함수

# object 생성
s = Student(10) # 한 번 생성된 object는 파라미터가 변하지 않는 이상 출력값 또한 변하지 않는다.
p = Person(20)

# object 실행
print("s.aging() :", s.aging())   # result : 10
print('\n')


print('test')
print('print with test', "s.personComposit() :", s.personComposit(40)) 
# result 출력 순서 : Person.printPerson -> print with test -> s.personComposit() 


print('\n')
print('test2')
print('print with test2', "p.printPerson() :", p.printPerson()) 
# result 출력 순서 : Person.printPerson -> print with test2 -> p.printPerson()

# 포함코드

# 클래스 선언
class Bill():
    def __init__(self, description):
        self.description = description


class Tail():
    def __init__(self, length):
        self.length = length


class Duck():
    def __init__(self, bill, tail):
        self.bill = bill
        self.tail = tail

    def about(self):
        print(
            f"This duck has a {self.bill.description} and a {self.tail.length}.")

# object 생성
duck = Duck(Bill('bill object'), Tail('tail object'))

# object 실행
duck.about()

# 추상화 코드

from abc import *    # abc 모듈의 클래스와 메소드를 갖고온다.(abc : abstract base class)

# 추상 클래스
class People(metaclass=ABCMeta):  

# 추상 메소드
    @abstractmethod # 추상 메소드에는 @abstractmethod를 선언해줘야 함
    def charecter(self): 
        pass        # 추상 메소드는 기능 내 실제 실행내용은 없다.

# 상속받는 클래스
class Student(People):
    def charecter(self, pow, think):
        self.pow = pow
        self.think = think

        print('체력: {0}'.format(self.pow))
        print('생각: {0}'.format(self.think))

# 상속받는 클래스
class Driver(People):
    def charecter(self, pow, think):
        self.pow = pow
        self.think = think

        print('체력: {0}'.format(self.pow))
        print('생각: {0}'.format(self.think))

# Student object 생성      
peo1 = Student()
print('Student : ')

# Student object 실행
peo1.charecter(30, 10)

print()

# Driver object 생성
peo2 = Driver()
print('Driver : ')

# Driver object 실행
peo2.charecter(10, 10)

#다형성

class Person:
  def run(self):
    print('run')

  def play(self):
    print('play')
  
class Student(Person):
  def run(self):
    print('fast run')
  
  def play(self):
    print('play')
  
class teacher(Person):
  def teach(self):
    print('teach')

  def play(self):
    print('teach play')


# 리스트를 생성한다.
number = list()
# 생성한 리스트에 다형성 개념을 위해 다른 클래스(Student, teacher)가 상위 클래스(Person)를 참조할 수 있도록 한다.
number.append(Student())  # 리스트 끝에 서브 클래스 Student()를 넣습니다. 
number.append(teacher())  # 다시 리스트 끝에 서브 클래스 teacher()를 넣습니다.

print("=========")
for Student in number:
    Student.run()     # 상위클래스인 Person의 run은 상속하여 사용하지만 내용은 다르다.


print("=========")
for teacher in number: 
    teacher.play()    # 상위클래스인 Person의 play는 상속하여 사용하지만 내용은 다르다.