3. 클래스와 객체지향 프로그래밍

class 클래스명:
  클래스 변수
  생성자
  메서드

객체를 담을 변수명 = 클래스명()

객체명(변수명).메서드명()

# '사용자'라는 개념을 표현하는 User 클래스(설계도)를 만듭니다.
class User:
    # 클래스에 소속된 함수를 '메서드'라고 부릅니다.
    # 메서드의 첫 번째 매개변수는 항상 'self'여야 합니다.
    def introduce(self):
        print("안녕하세요, 저는 사용자입니다.")

# User 클래스를 이용해 u1이라는 객체(실체)를 만듭니다. (인스턴스화)
u1 = User()

# u1 객체의 메서드를 호출합니다.
u1.introduce() # 출력: 안녕하세요, 저는 사용자입니다.

class User:
    # 객체가 생성될 때 이름(name)을 받아 초기화합니다.
    def __init__(self, name):
        # self.name은 이 객체에 소속된 변수(인스턴스 변수)가 됩니다.
        self.name = name
        print(f"{self.name}님이 태어났습니다!")

    def introduce(self):
        # self.name을 이용해 자기 이름을 소개합니다.
        print(f"안녕하세요, 제 이름은 {self.name}입니다.")

# User 객체를 만들 때 'name' 값을 전달해야 합니다.
user1 = User("Kim") # 출력: 철수님이 태어났습니다!
user2 = User("Park") # 출력: 영희님이 태어났습니다!

user1.introduce() # 출력: 안녕하세요, 제 이름은 철수입니다.
user2.introduce() # 출력: 안녕하세요, 제 이름은 영희입니다.

class User:
    def __init__(self, name):
        self.name = name
        print(f"{self.name}님이 태어났습니다!")
    
    def __del__(self):
        print(f"{self.name}님이 세상을 떠났습니다...")
    
    def introduce(self):
        print(f"안녕하세요, 제 이름은 {self.name}입니다.")

# 객체 생성
user1 = User("김철수")
user1.introduce()

# 객체를 명시적으로 삭제하거나 참조가 사라지면 __del__ 호출
del user1  # 출력: 김철수님이 세상을 떠났습니다...

# 또는 변수에 다른 값을 할당해도 __del__ 호출
user2 = User("이영희")
user2 = None  # 출력: 이영희님이 세상을 떠났습니다...

class User:
    # 클래스 변수: 모든 User 객체가 공유
    user_count = 0
    species = "인간"
    
    def __init__(self, name):
        self.name = name  # 인스턴스 변수: 각 객체마다 다른 값
        User.user_count += 1  # 클래스 변수 증가
        print(f"{self.name}님이 생성되었습니다. (전체 사용자: {User.user_count}명)")
    
    def introduce(self):
        print(f"안녕하세요, 저는 {self.name}입니다. ({self.species})")
    
    @classmethod
    def get_user_count(cls):
        return cls.user_count

# 객체 생성
user1 = User("Kim")  # 출력: Kim님이 생성되었습니다. (전체 사용자: 1명)
user2 = User("Park")  # 출력: Park님이 생성되었습니다. (전체 사용자: 2명)

# 클래스 변수 접근
print(f"전체 사용자 수: {User.user_count}")  # 출력: 전체 사용자 수: 2
print(f"사용자 종족: {User.species}")        # 출력: 사용자 종족: 인간

# 클래스 메서드 호출
print(f"현재 사용자 수: {User.get_user_count()}")  # 출력: 현재 사용자 수: 2

# User 클래스는 부모 클래스가 됩니다.
class User:
    def __init__(self, name):
        self.name = name
    def introduce(self):
        print(f"제 이름은 {self.name}입니다.")

# User 클래스를 상속받는 Student 클래스(자식)를 정의합니다.
class Student(User):
    # 자식 클래스만의 새로운 메서드를 추가할 수 있습니다.
    def study(self):
        print(f"{self.name} 학생은 공부를 합니다.")

# Student 객체를 만듭니다.
s1 = Student("민준")

# 부모 클래스(User)의 메서드를 그대로 사용할 수 있습니다.
s1.introduce() # 출력: 제 이름은 민준입니다.

# 자식 클래스(Student)에만 있는 메서드도 사용할 수 있습니다.
s1.study()     # 출력: 민준 학생은 공부를 합니다.

### super() 함수: 부모 클래스 메서드 호출하기

자식 클래스에서 부모 클래스의 메서드를 호출할 때는 <code class="yellow-code">super()</code> 함수를 사용합니다. 특히 `__init__` 메서드에서 부모의 초기화를 먼저 수행하고 싶을 때 유용합니다.

```python
class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species
        print(f"{self.name} ({self.species})이(가) 태어났습니다!")
    
    def make_sound(self):
        print("동물이 소리를 냅니다.")

class Dog(Animal):
    def __init__(self, name, breed):
        # super()를 사용해 부모 클래스의 __init__ 호출
        super().__init__(name, "강아지")
        self.breed = breed  # 자식 클래스만의 추가 속성
        print(f"품종: {self.breed}")
    
    def make_sound(self):
        # 부모 클래스의 메서드를 오버라이딩
        print(f"{self.name}이(가) 멍멍! 짖습니다.")
    
    def fetch(self):
        print(f"{self.name}이(가) 공을 가져옵니다.")

# Dog 객체 생성
my_dog = Dog("뽀삐", "말티즈")
# 출력:
# 뽀삐 (강아지)이(가) 태어났습니다!
# 품종: 말티즈

my_dog.make_sound()  # 출력: 뽀삐이(가) 멍멍! 짖습니다.
my_dog.fetch()       # 출력: 뽀삐이(가) 공을 가져옵니다.

class Vehicle:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
    
    def start_engine(self):
        print(f"{self.brand} {self.model}의 엔진이 시동됩니다.")
    
    def get_info(self):
        return f"브랜드: {self.brand}, 모델: {self.model}"

class Car(Vehicle):
    def __init__(self, brand, model, color):
        super().__init__(brand, model)
        self.color = color
    
    # 부모 클래스의 메서드를 완전히 재정의
    def start_engine(self):
        print(f"{self.color}색 {self.brand} {self.model}의 엔진이 부드럽게 시동됩니다!")
    
    # 부모 클래스의 메서드를 확장 (super() 사용)
    def get_info(self):
        parent_info = super().get_info()
        return f"{parent_info}, 색상: {self.color}"

class Motorcycle(Vehicle):
    def __init__(self, brand, model, engine_size):
        super().__init__(brand, model)
        self.engine_size = engine_size
    
    # 부모 클래스의 메서드를 완전히 다른 방식으로 재정의
    def start_engine(self):
        print(f"{self.brand} {self.model} ({self.engine_size}cc)의 엔진이 우렁차게 시동됩니다!")

# 객체 생성 및 테스트
car = Car("현대", "아반떼", "흰색")
motorcycle = Motorcycle("혼다", "CBR600RR", 600)

print("=== 차량 정보 ===")
print(car.get_info())        # 출력: 브랜드: 현대, 모델: 아반떼, 색상: 흰색
print(motorcycle.get_info()) # 출력: 브랜드: 혼다, 모델: CBR600RR

print("\n=== 엔진 시동 ===")
car.start_engine()        # 출력: 흰색 현대 아반떼의 엔진이 부드럽게 시동됩니다!
motorcycle.start_engine() # 출력: 혼다 CBR600RR (600cc)의 엔진이 우렁차게 시동됩니다!