17. 변수(variable)와 프로퍼티 (Fields & Properties)

변수 (Fields)와 프로퍼티 (Properties)

클래스(class)에서 데이터를 저장하는 방법은 두 가지가 있습니다:

1. 변수 (Fields): 내부적으로만 사용
2. 프로퍼티 (Properties): 외부에서 읽거나 쓸 때 제어가 필요한 경우

변수 (Fields)

변수(variable)는 클래스(class) 내부에서 직접 사용하는 데이터입니다.

기본 사용법

public class Player
{
    public int score;      // 외부에서 접근 가능
    private int bonus;     // 내부에서만 접근 가능
}

특징

• 간단하고 빠름
• 직접 값을 읽고 쓸 수 있음
• 제어나 검증이 불가능

프로퍼티 (Properties)

프로퍼티는 변수(variable)처럼 보이지만, 읽기(get)와 쓰기(set)를 제어할 수 있습니다.

기본 문법

public class Player
{
    private int score;  // 내부 변수 (보통 private)
    
    public int Score    // 프로퍼티 (대문자로 시작)
    {
        get { return score; }      // 읽기
        set { score = value; }     // 쓰기 (value는 자동으로 전달됨)
    }
}

사용 예시

Player player = new Player();
player.Score = 100;        // set 호출 (value = 100)
int currentScore = player.Score;  // get 호출

프로퍼티의 용도

1. 캡슐화(encapsulation)

내부 변수(variable)를 숨기고 프로퍼티를 통해 접근합니다.

public class Player
{
    private int health;  // 외부에서 직접 접근 불가
    
    public int Health    // 프로퍼티로만 접근 가능
    {
        get { return health; }
        set { health = value; }
    }
}

2. 유효성 검사

값을 설정할 때 검증할 수 있습니다.

public class Player
{
    private int health = 100;
    
    public int Health
    {
        get { return health; }
        set 
        {
            // 0~100 사이의 값만 허용
            if (value < 0)
                health = 0;
            else if (value > 100)
                health = 100;
            else
                health = value;
        }
    }
}

3. 계산된 값 반환(return)

값을 계산해서 반환(return)할 수 있습니다.

public class Player
{
    public int score = 10;
    public int bonus = 5;
    
    public int TotalScore  // 읽기 전용 프로퍼티
    {
        get { return score + bonus; }  // 계산된 값 반환
    }
}

// 사용
Player player = new Player();
Debug.Log(player.TotalScore);  // 15 출력 (10 + 5)

읽기 전용 프로퍼티

set을 생략하면 읽기만 가능한 프로퍼티가 됩니다.

public class Player
{
    private int level = 1;
    
    public int Level
    {
        get { return level; }  // set이 없으므로 읽기 전용
    }
}

자동 구현 프로퍼티

간단한 프로퍼티는 더 짧게 작성할 수 있습니다.

일반 프로퍼티

private string name;

public string Name
{
    get { return name; }
    set { name = value; }
}

자동 구현 프로퍼티

public string Name { get; set; }  // 훨씬 간단!

자동으로 내부 변수(variable)를 생성하고 get/set을 처리합니다.

읽기 전용 자동 프로퍼티

public string Name { get; private set; }  // 외부에서는 읽기만 가능

변수(variable) vs 프로퍼티 비교

특징	변수 (Fields)	프로퍼티 (Properties)
사용 시기	내부적으로만 사용	외부 접근 제어 필요
검증	불가능	가능 (set에서)
계산	불가능	가능 (get에서)
코드 길이	짧음	상대적으로 김
성능	약간 빠름	약간 느림 (미미함)

실전 활용 예시

예시 1: 점수 관리 (계산된 값 반환(return))

public class Player : MonoBehaviour
{
    public int baseScore = 0;
    public int bonusScore = 0;
    
    // 계산된 총점 반환 (읽기 전용)
    public int TotalScore
    {
        get { return baseScore + bonusScore; }
    }
    
    void Start()
    {
        baseScore = 100;
        bonusScore = 50;
        Debug.Log("총점: " + TotalScore);  // 150 출력
    }
}

예시 2: 체력 제한 (값 검증)

public class Player : MonoBehaviour
{
    private int health = 100;
    private int maxHealth = 100;
    
    public int Health
    {
        get { return health; }
        set 
        {
            // 0~maxHealth 사이로 제한
            health = Mathf.Clamp(value, 0, maxHealth);
            
            // 체력이 변경될 때마다 UI 업데이트
            UpdateHealthUI();
        }
    }
    
    void UpdateHealthUI()
    {
        Debug.Log("현재 체력: " + health + " / " + maxHealth);
    }
    
    void Start()
    {
        Health = 150;  // 100으로 제한됨
        Health = -10;  // 0으로 제한됨
    }
}

예시 3: 경험치와 레벨 (계산된 프로퍼티)

public class Player : MonoBehaviour
{
    private int experience = 0;
    private int level = 1;
    
    public int Experience
    {
        get { return experience; }
        set 
        {
            experience = value;
            // 경험치가 변경되면 레벨 체크
            CheckLevelUp();
        }
    }
    
    public int Level
    {
        get { return level; }
        private set { level = value; }  // 외부에서 직접 설정 불가
    }
    
    void CheckLevelUp()
    {
        int requiredExp = level * 100;
        if (experience >= requiredExp)
        {
            Level++;
            Debug.Log("레벨업! 현재 레벨: " + Level);
        }
    }
}

예시 4: 무기 프로퍼티 (자동 구현)

public class Weapon : MonoBehaviour
{
    // 자동 구현 프로퍼티 (간단한 경우)
    public string Name { get; set; }
    public int Damage { get; set; }
    
    // 읽기 전용 프로퍼티
    public int Durability { get; private set; } = 100;
    
    public void Use()
    {
        Durability--;  // 내부에서만 수정 가능
        if (Durability <= 0)
        {
            Debug.Log(Name + "이(가) 부서졌습니다!");
        }
    }
}

언제 무엇을 사용할까?

변수(variable) 사용

• 클래스(class) 내부에서만 사용
• 간단한 데이터 저장
• 제어가 필요 없을 때

프로퍼티 사용

• 외부에서 접근해야 할 때
• 값 검증이 필요할 때
• 계산된 값을 반환(return)해야 할 때
• 읽기/쓰기를 제어해야 할 때

주의사항

1. 프로퍼티 이름은 대문자로 시작 (일반적으로)
2. 내부 변수(variable)는 private으로 숨기는 것이 좋음
3. 자동 구현 프로퍼티는 간단한 경우에만 사용
4. 계산이 복잡하면 일반 프로퍼티 사용 권장

---

← 목차로 돌아가기