객체지향 3요소

 

캡슐화(Encapsulation), 상속(Inheritance), 다형성(Polymorphism)
: (캡슐화) 데이터와 메소드를 하나로 묶고 외부접근을 제한
: (상속) 부모클래스의 특성을 자식 클래스가 물려받음
: (다형성) (1)같은 인터페이스로 다양햔 형태의 객체를 다룸

1. 캡슐화
-캡슐화 방법: 외부에서 변수 참조할때 접근을 제어함
:(객체지향) private(비공개), public(외부공개), protected(경우에따라공개)

class Student:
    def __init__(self, name, addr, r_num):
        self.name = name    # public
        self._addr = addr   # protected
        self.__r_num = r_num # private
    def introduce(self):   # public
        #print(f"안녕하세요, {self.name},{self._addr},{self._r_num}"
        self.__introduce() 
    def __introduce(self): # private
        print(f"안녕하세요, {self.name},{self._addr},{self._r_num}"
    #setter, getter 함수 추가
    def set_r_num(self, r_num):
        self.__r_num = r_num
    def get_r_num(self):
        return self.__r_num

s1 = Student("운국")
s1.introduce()
print(s1.name)
print(s1._addr)
print(s1.__r_num) # 오류발생, 접근불가(private 변수 접근불가)
s1.__introduce()  # 오류발생, 접근불가(private 함수 접근불가)
#setter, getter 함수로 private 변수 접근
s1.set_r_num('851224')
print(s1.get_r_num())

2. 상속
- 상속 특징: 부모클래스 특성을 자식클래스가 물려받아서 재사용가능(코드 재사용성 개선), 계층구조형성
- 상속 문법: class Child(Parent):
- 오버라이딩(override, 메소드 재정의): 물려받은 부모메소드를 자식이 다른 행동으로 덮어쓴다.
- super() 키워드: 부모클래스의 메소드 호출

# 부모 클래스 (기본 클래스, 슈퍼 클래스)
class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print(f"{self.name}이(가) 소리를 냅니다")    
    def sleep(self):
        print(f"{self.name}이(가) 잠을 잡니다")

# 자식 클래스 (파생 클래스, 서브 클래스)
class Dog(Animal):  # Animal을 상속받음
    def speak(self):  # 메서드 오버라이딩
        print(f"{self.name}이(가) 멍멍 짖습니다")

class Cat(Animal):  # Animal을 상속받음
    def speak(self):  # 메서드 오버라이딩
        print(f"{self.name}이(가) 야옹 웁니다")

# 사용
dog = Dog("바둑이")
cat = Cat("나비")

dog.speak()  # "바둑이이(가) 멍멍 짖습니다"
cat.speak()  # "나비이(가) 야옹 웁니다"
dog.sleep()  # "바둑이이(가) 잠을 잡니다" (부모 메서드 사용)

- super()

class Vehicle:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
    
    def start(self):
        print(f"{self.brand} {self.model} 시동을 켭니다")

class Car(Vehicle):
    def __init__(self, brand, model, doors):
        super().__init__(brand, model)  # 부모 클래스의 __init__ 호출
        self.doors = doors
    
    def start(self):
        super().start()  # 부모 클래스의 start() 호출
        print("자동차 특별 기능이 활성화됩니다")

- 다중상속

class Flyable:
    def fly(self):
        print("날아갑니다")

class Swimmable:
    def swim(self):
        print("수영합니다")

class Duck(Animal, Flyable, Swimmable):  # 다중 상속
    def speak(self):
        print(f"{self.name}이(가) 꽥꽥 웁니다")

# 사용
duck = Duck("도날드")
duck.speak()  # "도날드이(가) 꽥꽥 웁니다" (Animal 상속)
duck.fly()    # "날아갑니다" (Flyable 상속)
duck.swim()   # "수영합니다" (Swimmable 상속)

3. 다형성
- 다형성: 여러 형태를 가진다는 뜻
> 동일한 인터페이스(메서드 이름)를 가지고 있지만, 클래스에 따라 서로 다른 방식으로 동작
- 다형성 장점: 유연한 설계가 가능, 하나의 인터페이스로 일관된 호출 가능

class Animal:
    def speak(self):
        print("동물이 소리를 냅니다.")

class Dog(Animal):
    def speak(self):
        print("멍멍!")

class Cat(Animal):
    def speak(self):
        print("야옹!")

def make_animal_speak(animal:Animal):
    animal.speak()  # 동일한 메서드 호출

# 실행
animals = [Dog(), Cat()]
for a in animals:
    make_animal_speak(a)
    print(isinstance(a, Dog))    
    print(isinstance(a, Animal))

 

덕 타이핑(duck typing) 
: 객체의 {메소드,속성} 같으면 같은 객체 type으로 간주, 실행가능
: 상속하지 않더라도 다형성 지원

class TV:
    def power_on(self):
        return "TV 켜짐"
class AirConditioner:
    def power_on(self):
        return "에어컨 켜짐"
class Radio:
    def power_on(self):
        return "라디오 켜짐"

# 뭐든 power_on()만 있으면 작동!
def turn_on_device(device):
    return device.power_on()

# 모두 다른 클래스지만 똑같이 동작
print(turn_on_device(TV()))           # "TV 켜짐"
print(turn_on_device(AirConditioner())) # "에어컨 켜짐"
print(turn_on_device(Radio()))         # "라디오 켜짐"

 

 

Python 기초 관련 더 많은 정보를 공부하고 싶으신 분들은 아래 링크 참고하세요~

https://inf.run/7QqW9

자동매매 python기초| 코딩멘토 - 인프런 강의