Day14 class응용, 상속, 추상, 오버라이딩, 객체지향프로그래밍 OOP [파이썬 1달만에 마스터하기]

지난 시간 리뷰

(class 퀵복습 - 강아지 문)

class dog:
    def __init__(self,n):
        self.name = n
    def intro(self):
        print(f"저는 {self.name}입니다.")

a = dog('킹율')
a.intro() # 저는 킹율입니다.
b = dog('흰둥이')
b.intro() # 저는 흰둥이입니다.

(class 예제 - Bank Account 문제)

class BankAccount:
    def __init__(self,account_number,owner_name):
        self.account_number = account_number
        self.owner_name = owner_name
        self.balance = 0

    def deposit(self,amount):
        if amount > 0:
            self.balance += amount
            return True
        else:
            print("금액을 잘못 입력 하였습니다. (-)불가")
            return False

    def withdraw(self,amount):
        if amount > 0 and amount < self.balance:
            self.balance -= amount
            return True
        else:
            print("금액을 잘못 입력 하였습니다.")
            return False

    def get_balance(self):
        return self.balance

    def get_account(self):
        return (f"Account: {self.account_number}, "
                f"Owner: {self.owner_name}, "
                f"Balance: {self.balance}")

def bankSystem():

    globalAccount={}

    while True:
        print("은행 계좌 시스템")
        print("1. 계좌 개설")
        print("2. 입금")
        print("3. 출금")
        print("4. 잔액 조회")
        print("5. 종료")
        systemNumber = input("선택:")

        if systemNumber == "1":
            account_number = input("계좌 번호: ")
            owner_name = input("소유자 이름: ")
            globalAccount[account_number] = BankAccount(account_number,owner_name)
            print("계좌 개설이 완료 되었습니다!")

        elif systemNumber == "2":
            account_number = input("계좌 번호: ")
            amount = int(input("입금액: "))
            if account_number in globalAccount and globalAccount[account_number].deposit(amount):
                print("입금 완료")
            else:
                print("입금 실패")

        elif systemNumber == "3":
            account_number = input("계좌 번호: ")
            amount = int(input("출금액: "))
            if account_number in globalAccount and globalAccount[account_number].withdraw(amount):
                print("출금 완료")
            else:
                print("출금 실패")

        elif systemNumber == "4":
            account_number = input("계좌번호:")
            if account_number in globalAccount:
                print(globalAccount[account_number].get_account())
            else:
                print("계좌를 찾을 수 없습니다.")
        elif systemNumber == "5":
            print("은행 계좌 프로그램 종료")
            break;


bankSystem()

------------------------------------------------------------------------------------------------------------------------------------------------

Day 14

상속과 추상
상속 (inheritance): 객체지향 프로그래밍에서 매우 중요한 개념. 상속을 통해 한 클래스 (자식)가 다른 클래스 (부모)의 속성과 메서드를 그대로 이어받을 수 있음. 이는 코드의 재사용성을 높이고, 중복을 줄여 프로그램의 구조를 더욱 효율적으로 만듬.

 

(상속의 기본 문법:)

class ParentClass:
    #부모 클래스의 메서드와 속성 정의
    pass

class ChildClass(ParentClass):
    #자식 클래스에서 추가된 메서드와 속성 정의
    pass

오버라이딩 (Overriding)
오버라이딩은 자식 클래스가 부모 클래스로부터 상속받은 메서드를 자신의 필요에 맞게 재정의하는 것을 의미함. 이를 통해 상속받은 기능을 유지하면서도, 특정 부분을 자식 클래스에 맞게 커스터마이징 할 수 있음.

오버라이딩의 특징:
(재정의): 부모 클래스의 메서드와 동일한 이름, 매개변수로 자식 클래스에서 메서드를 재정의
(확장): 부모 클래스의 기능을 유지하면서 추가적인 기능을 더할 수 있음
(다형성): 같은 메서드 이름으로 다양한 기능을 구현할 수 있어, 다형성을 실현하는데 중요한 역할을 함

 

(상속과 오버라이딩 예시)

class Monster:
    def __init__(self,hp,name,damage):
        self.hp = hp
        self.name = name
        self.damage = damage
        def attack(self,character):
            character.hp -= self.damage

class Slime(Monster):
    def __init__(self,hp,name,damage,poison):
        super().__init__(hp,name)  # 위 부모의 init(생성자)을 넣기
        self.poison = poison       # 자기의 생성자

    def attack(self, character):
        character.hp -= self.damage * 2   # overriding 예시

    def sprayPoison(self,character):
        character.hp -= self.damage + self.poison

#kim = character()

a = Slime(50,'귀여운슬라임',30,5)
a.attack(kim)
a.sprayPoison(kim)

 

 

(abstract class 예시)

from abc import ABC, abstractmethod

class Shape(ABC):

    @abstractmethod
    def get_area(self):
        pass

    @abstractmethod
    def get_round(self):
        pass

class Circle(Shape):
    def __init__(self,r):
        self.radius = r

    def get_area(self):
        return 3.14*self.radius**2
    def get_round(self):
        return 3.14*self.radius*2

class Triangle(Shape):
    def __init__(self,b,h):
        self.base = b
        self.height = h
    def get_area(self):
        return self.base * self.height * 0.5
    def get_round(self):
        return self.base * 3

class Square(Shape):
    def __init__(self,s):
        self.side = s
    def get_area(self):
        return self.side * self.side
    def get_round(self):
        return self.side * 4

a = Triangle(5,5)
print(a.get_area())   #12.5
print(a.get_round())  #15

b = Square(8)
print(b.get_area())   #64
print(b.get_round())  #32

 

객체지향프로그래밍 (OOP)
요소:
캡슐화 (encapsulation) - 데이터보호,
상속 (inheritance) - 코드 간략화,
다형성 (polymorphism) - 코드 유지보수 용이

원칙: SOLID 원칙의 소개 및 설명 (class 잘 만드는 방법)
S: 단일 책임 원칙
O: 개방/폐쇄 원칙
L: 리스코프 교환 원칙
I: 인터페이스 원칙
D: 의존성 역전 원칙