Python with OOP

OOP

• 객체지향 프로그래밍

• 기능(함수, 변수) 재사용이 가능하도록 설계 및 프로그래밍

def PP(): # 절차 프로그래밍 (Procedural Programming)
	print("A")

class OOP: # 객체 지향 프로그래밍 (Object Oriented Programming)
	def __init__(self, A):
		self.A = A
	

	def B(self):
		self.B = B

캡슐화

class Capsule:
	def __init__(self, A):
		self.A = A

	def B(self):
		self.A
		print("B에 A 기능 가져오기") 

	def C(self):
		self.A
		print("C에 A 기능 가져오기")

상속과 포함

class Parents:
	def __init__(self, A):
		self.A = A
		print(f"나는 부모인 {A}이고 너는 자식이야")

class Child(Parents): # Parents 클래스 상속
	def B(self):
		super().__init__(A) # super()로 상속받은 클래스의 기능 가져오기
		print(f"저는 {A}씨의 자식이에요")

추상화

class A:
  def __init__(self):
    self.AA = "추상화되기 전"

  def BB(self):
    self.AA = "추상화시키기"
    return self.AA

A = A()
A.BB() # 속성을 수정하는 메서드를 이용해 속성 변경 (=> 추상화)

다형성

class A:
	def __init__(self):
		self.AA = "A의 AA"
	def BB(self):
		self.AA = "A의 AA 추상화"

class B:
	def __init__(self):
		self.AA = "B의 AA"
	def BB(self):
		self.AA = "B의 AA 추상화" 

A = A()
B = B()
A.BB()
B.BB()

# 다른 클래스에 같은 메서드를 가지고 있으며 다르게 동작 => 다형성

연산자

• 1개
  • if A is not B
  • A는 B가 아니다
• 2개
  • if not A is B
  • A가 아닌 것은 B이다

클래스 인스턴스화

class A:
	print("인스턴스화")

A = A() # 인스턴스화 -> 메모리에 할당

속성 충돌방지

# 속성 충돌시키기
class A:
	def __init__(self):
		self.AA = 0
		self._AA = 10
		self.__AA = 20

class B(A):
	def __init__(self):
		super().__init__(self)
		self.__AA = 40 # __AA와 속성 충돌발생

# 속성 충돌방지
class A:
	def __init__(self):
		self.AA = 0
		self.__AA = 20 # 상위 클래스 -> __

class B(A):
	def __init__(self):
		super().__init__(self)
		self._AA = 40 # 하위 클래스 -> _

오버라이딩

class A:
	def AA(self):
		return "오버라이딩 전"

class B(A): # 상속
  def AA(self): # 메소드 오버라이딩
    super().AA()
    return "오버라이딩 후"

A = A()
B = B()

print(A.AA()) # 상위 클래스 메소드
print(B.AA()) # 상속받은 메소드 사용