PHP 클래스와 객체: 인터페이스, 추상 클래스 및 핵심 키워드

PHP는 강력한 객체 지향 프로그래밍(OOP) 기능을 제공하여 코드를 구조화하고 재사용성을 높일 수 있도록 돕습니다. 이 글에서는 인터페이스와 추상 클래스 같은 핵심 OOP 개념과 함께, static, final 키워드 및 부모 클래스 생성자 호출 방법에 대해 자세히 살펴보겠습니다.

1. 인터페이스 (Interface)

PHP에서 인터페이스는 특정 클래스가 반드시 구현해야 하는 메서드의 집합을 정의하는 데 사용됩니다. 인터페이스 자체는 메서드의 구현 내용을 포함하지 않고, 오직 메서드의 시그니처(이름, 매개변수)만을 선언합니다. 이를 통해 서로 다른 클래스들이 동일한 계약(contract)을 따르도록 강제할 수 있으며, 코드의 일관성과 확장성을 높일 수 있습니다.

인터페이스는 interface 키워드를 사용하여 정의하며, 내부의 모든 메서드는 기본적으로 public 접근 제어자를 가집니다. 인터페이스 내에서는 상수를 정의할 수 있지만, 변수는 정의할 수 없습니다. 클래스가 인터페이스를 구현하려면 implements 키워드를 사용해야 하며, 해당 인터페이스에 정의된 모든 메서드를 구현해야 합니다. 만약 하나라도 빠트리면 치명적인 오류가 발생합니다. 또한, PHP 클래스는 쉼표(,)로 구분하여 여러 인터페이스를 동시에 구현할 수 있습니다.

<?php
// 인터페이스 내의 모든 메서드는 암묵적으로 public입니다.
interface Loggable
{
    const LOG_LEVEL = 'INFO'; // 인터페이스는 상수를 가질 수 있습니다.

    public function writeLog(string $message): void;
    public function getLogLevel(): string;
}

interface Runnable
{
    public function startProcess(): void;
    public function stopProcess(): void;
}

// 하나의 클래스는 여러 인터페이스를 구현할 수 있습니다.
class TaskExecutor implements Loggable, Runnable
{
    private string $currentLog = '';

    public function writeLog(string $message): void
    {
        $this->currentLog .= "[" . self::LOG_LEVEL . "] " . $message . "\n";
        echo "로그 기록: " . $message . "\n";
    }

    public function getLogLevel(): string
    {
        return self::LOG_LEVEL;
    }

    public function startProcess(): void
    {
        echo "프로세스 시작.\n";
        $this->writeLog("프로세스가 시작되었습니다.");
    }

    public function stopProcess(): void
    {
        echo "프로세스 종료.\n";
        $this->writeLog("프로세스가 종료되었습니다.");
    }

    public function displayAllLogs(): string
    {
        return $this->currentLog;
    }
}

$executor = new TaskExecutor();
$executor->startProcess();
$executor->writeLog("중간 작업 수행 중...");
$executor->stopProcess();

echo "--- 전체 로그 --- \n";
echo $executor->displayAllLogs();
echo "현재 로그 레벨: " . $executor->getLogLevel() . "\n";
?>

2. 추상 클래스 (Abstract Class)

추상 클래스는 하나 이상의 추상 메서드를 포함하는 클래스입니다. 추상 메서드는 구현 없이 선언부만 가지는 메서드를 의미합니다. 이러한 추상 클래스는 직접 객체로 인스턴스화할 수 없으며, 반드시 다른 클래스가 상속(extends)하여 추상 메서드를 구현해야만 합니다.

추상 클래스를 상속받는 자식 클래스는 부모 추상 클래스에 정의된 모든 추상 메서드를 반드시 구현해야 합니다. 이때 자식 클래스에서 구현하는 추상 메서드의 접근 제어자는 부모 클래스에 정의된 접근 제어자와 같거나 더 넓은 범위(예: protected를 public으로 변경 가능, private로는 변경 불가능)를 가져야 합니다. 추상 클래스는 일반 메서드와 속성도 가질 수 있으며, 생성자도 가질 수 있습니다.

<?php
// 추상 클래스는 추상 메서드와 일반 메서드를 모두 포함할 수 있습니다.
abstract class GeometryShape
{
    protected float $area = 0.0;

    abstract public function calculateArea(): void; // 추상 메서드: 구현 없이 선언만
    abstract protected function setDimensions(array $dimensions): void; // protected 추상 메서드

    public function getArea(): float
    {
        return $this->area;
    }

    public function describe(): void
    {
        echo "이것은 기하학적 도형입니다.\n";
    }
}

// 자식 클래스는 하나의 추상 클래스만 상속할 수 있습니다.
// 모든 추상 메서드를 반드시 구현해야 합니다.
class Circle extends GeometryShape
{
    private float $radius;

    public function __construct(float $radius)
    {
        $this->setDimensions(['radius' => $radius]);
        $this->calculateArea(); // 생성자에서 면적 계산
    }

    // protected 추상 메서드를 구현할 때, 접근 제어자를 같거나 더 넓게 할 수 있습니다.
    // 여기서는 protected로 유지
    protected function setDimensions(array $dimensions): void
    {
        if (isset($dimensions['radius']) && $dimensions['radius'] > 0) {
            $this->radius = $dimensions['radius'];
        } else {
            throw new \InvalidArgumentException("유효하지 않은 반지름입니다.");
        }
    }

    public function calculateArea(): void
    {
        $this->area = M_PI * $this->radius * $this->radius;
    }

    public function describe(): void
    {
        parent::describe(); // 부모 클래스의 일반 메서드 호출
        echo "저는 원이며, 반지름은 {$this->radius}입니다.\n";
    }
}

class Rectangle extends GeometryShape
{
    private float $width;
    private float $height;

    public function __construct(float $width, float $height)
    {
        $this->setDimensions(['width' => $width, 'height' => $height]);
        $this->calculateArea();
    }

    // public으로 접근 제어자를 확장하여 구현
    public function setDimensions(array $dimensions): void
    {
        if (isset($dimensions['width']) && $dimensions['width'] > 0 &&
            isset($dimensions['height']) && $dimensions['height'] > 0) {
            $this->width = $dimensions['width'];
            $this->height = $dimensions['height'];
        } else {
            throw new \InvalidArgumentException("유효하지 않은 너비 또는 높이입니다.");
        }
    }

    public function calculateArea(): void
    {
        $this->area = $this->width * $this->height;
    }

    public function describe(): void
    {
        echo "저는 사각형이며, 너비는 {$this->width}, 높이는 {$this->height}입니다.\n";
    }
}


$circle = new Circle(5);
$circle->describe();
echo "원의 면적: " . $circle->getArea() . "\n\n";

$rectangle = new Rectangle(4, 6);
$rectangle->describe();
echo "사각형의 면적: " . $rectangle->getArea() . "\n";
?>

3. 인터페이스와 추상 클래스 비교 (Interface vs. Abstract Class Comparison)

인터페이스와 추상 클래스는 모두 다형성을 구현하고 코드의 구조를 잡는 데 사용되지만, 몇 가지 중요한 차이점이 있습니다.

  • 정의 및 구현 방식
    • 인터페이스: interface 키워드로 정의하며, 클래스는 implements 키워드를 사용하여 인터페이스를 구현합니다.
    • 추상 클래스: abstract class 키워드로 정의하며, 클래스는 extends 키워드를 사용하여 추상 클래스를 상속받습니다.
  • 인스턴스화
    • 인터페이스: 직접 객체로 만들 수 없습니다.
    • 추상 클래스: 직접 객체로 만들 수 없습니다.
  • 메서드 구현
    • 인터페이스: 모든 메서드가 추상 메서드이며, 구현을 포함할 수 없습니다. (PHP 8.0부터는 기본 메서드 구현이 가능하지만, 일반적인 인터페이스의 목적은 아닙니다.)
    • 추상 클래스: 추상 메서드뿐만 아니라 구현된 일반 메서드도 포함할 수 있습니다.
  • 속성 (변수)
    • 인터페이스: 상수는 정의할 수 있지만, 일반적인 멤버 변수(클래스 속성)는 정의할 수 없습니다.
    • 추상 클래스: 일반적인 멤버 변수와 상수를 모두 정의할 수 있습니다.
  • 접근 제어자
    • 인터페이스: 모든 메서드는 암묵적으로 public입니다.
    • 추상 클래스: 메서드와 속성에 public, protected, private 접근 제어자를 사용할 수 있습니다.
  • 생성자
    • 인터페이스: 생성자를 가질 수 없습니다.
    • 추상 클래스: 생성자를 가질 수 있습니다.
  • 다중 상속/구현
    • 인터페이스: 클래스는 여러 인터페이스를 동시에 구현할 수 있습니다.
    • 추상 클래스: 클래스는 단 하나의 추상 클래스만 상속할 수 있습니다. (PHP는 단일 상속만 지원)

요약하자면, 인터페이스는 "무엇을 할 수 있는지(what it can do)"에 대한 계약을 정의하는 반면, 추상 클래스는 "무엇이며 어떻게 동작하는지(what it is and how it works)"에 대한 부분적인 구현과 함께 상속 계층 구조를 제공합니다.

4. 키워드 (Keywords)

Static 키워드 (Static Keyword)

static 키워드를 사용하면 클래스를 인스턴스화하지 않고도 클래스 속성이나 메서드에 직접 접근할 수 있습니다. 정적 속성과 메서드는 특정 객체가 아닌 클래스 자체에 속하며, 모든 인스턴스에서 공유됩니다.

  • 정적 속성은 클래스이름::$속성 형식으로 접근하며, 객체를 통해 $객체->속성 형태로 접근할 수 없습니다.
  • 정적 메서드는 클래스이름::메서드() 형식으로 호출하며, 정적 메서드 내부에서는 $this 키워드를 사용할 수 없습니다. ($this는 특정 객체를 참조하기 때문입니다.)
  • 정적 메서드에서 같은 클래스의 정적 멤버에 접근할 때는 self::$속성 또는 self::메서드()를 사용합니다.
<?php
class AppConfig
{
    // 정적 속성: 클래스 수준에서 공유됩니다.
    public static string $appName = "MyApplication";
    public static string $version = "1.0.0";
    private static int $instanceCount = 0; // 내부에서만 사용

    // 정적 메서드: 인스턴스 생성 없이 호출 가능
    public static function getAppInfo(): string
    {
        // 정적 메서드 내에서 정적 속성에 접근할 때는 self:: 또는 static:: 사용
        return "애플리케이션: " . self::$appName . ", 버전: " . self::$version;
    }

    public static function incrementInstanceCount(): void
    {
        self::$instanceCount++;
    }

    public static function getInstanceCount(): int
    {
        return self::$instanceCount;
    }

    // 일반 메서드 (인스턴스 필요)
    public function __construct()
    {
        self::incrementInstanceCount();
    }

    public function getWelcomeMessage(): string
    {
        // 일반 메서드 내에서 정적 속성 접근
        return "환영합니다, " . self::$appName . "에 오신 것을!";
    }
}

// 클래스 인스턴스화 없이 정적 속성 접근
echo "애플리케이션 이름: " . AppConfig::$appName . "\n";
echo "현재 버전: " . AppConfig::$version . "\n";

// 클래스 인스턴스화 없이 정적 메서드 호출
echo AppConfig::getAppInfo() . "\n";

// 인스턴스 생성 및 정적 속성/메서드와의 상호작용
$config1 = new AppConfig();
$config2 = new AppConfig();
echo "생성된 인스턴스 수: " . AppConfig::getInstanceCount() . "\n";
echo $config1->getWelcomeMessage() . "\n";

// 정적 속성 변경
AppConfig::$version = "1.0.1-beta";
echo "업데이트된 버전: " . AppConfig::$version . "\n";
echo AppConfig::getAppInfo() . "\n"; // 변경된 버전이 반영됨
?>

Final 키워드 (Final Keyword)

final 키워드는 상속과 메서드 오버라이딩을 제한하는 데 사용됩니다. 이 키워드는 클래스나 메서드 앞에 붙일 수 있습니다.

  • 클래스에 final: 클래스 선언 시 final 키워드를 사용하면 해당 클래스는 다른 어떤 클래스도 상속받을 수 없습니다. 이는 특정 클래스의 확장이나 변경을 완전히 막고 싶을 때 유용합니다.
  • 메서드에 final: 부모 클래스의 메서드에 final 키워드를 붙이면, 자식 클래스에서 해당 메서드를 재정의(override)할 수 없게 됩니다. 이는 부모 클래스의 특정 동작이 자식 클래스에서 변경되지 않도록 보장할 때 사용됩니다.
<?php
// final 클래스는 상속될 수 없습니다.
// final class ImmutableObject { ... }

class BaseProcessor
{
    protected string $processorName = "기본 처리기";

    public function processData(array $data): string
    {
        return "{$this->processorName}: 데이터 처리 중...";
    }

    // final 메서드는 자식 클래스에서 재정의할 수 없습니다.
    final public function initialize(): void
    {
        echo "{$this->processorName}: 초기화 완료.\n";
    }
}

class AdvancedProcessor extends BaseProcessor
{
    public function __construct()
    {
        $this->processorName = "고급 처리기";
    }

    // 부모의 processData 메서드는 final이 아니므로 재정의 가능합니다.
    public function processData(array $data): string
    {
        // 부모 메서드의 기능을 확장하거나 완전히 대체할 수 있습니다.
        $baseResult = parent::processData($data);
        return $baseResult . " (고급 로직 적용)";
    }

    // final 메서드를 재정의하려고 시도하면 치명적인 오류가 발생합니다.
    /*
    public function initialize(): void
    {
        echo "자식 클래스의 초기화 재정의.\n"; // Fatal error: Cannot override final method
    }
    */
}

$advanced = new AdvancedProcessor();
$advanced->initialize(); // 부모의 final 메서드 호출
echo $advanced->processData(['item1', 'item2']) . "\n";

// 재정의 시도 코드 (주석 처리하여 에러 방지)
// $errorTest = new AdvancedProcessor();
// $errorTest->initialize(); // 여기서 재정의된 initialize를 호출하면 에러
?>

부모 클래스 생성자 호출 (Calling Parent Constructor)

PHP에서 자식 클래스가 생성될 때, 부모 클래스의 생성자가 자동으로 호출되지 않습니다. 만약 자식 클래스에서 부모 클래스의 초기화 로직을 실행해야 한다면, 자식 클래스의 생성자 내에서 명시적으로 parent::__construct()를 호출해야 합니다.

이는 자식 클래스의 생성자가 부모 클래스의 생성자와 다른 매개변수를 받거나, 부모 생성자의 특정 동작 이후에 자식 클래스만의 초기화가 필요할 때 유용합니다. parent:: 구문은 현재 클래스의 부모 클래스에 정의된 메서드에 접근할 때 사용됩니다.

<?php
class Logger
{
    protected string $logFile;

    public function __construct(string $file = "application.log")
    {
        $this->logFile = $file;
        echo "[Logger] 로그 파일 설정: {$this->logFile}\n";
    }

    public function write(string $message): void
    {
        // 실제 파일 쓰기 로직 대신 단순 출력
        echo "[Logger] " . date('Y-m-d H:i:s') . " - " . $message . "\n";
    }
}

class DatabaseLogger extends Logger
{
    private string $dbConnectionInfo;

    public function __construct(string $dbInfo, string $file = "db_log.log")
    {
        // 부모 클래스의 생성자를 명시적으로 호출합니다.
        // 이때, 부모 생성자에 필요한 인수를 전달해야 합니다.
        parent::__construct($file);
        
        $this->dbConnectionInfo = $dbInfo;
        echo "[DatabaseLogger] 데이터베이스 연결 정보 설정: {$this->dbConnectionInfo}\n";
    }

    public function write(string $message): void
    {
        // 부모의 로깅 방식도 사용하면서 추가적인 데이터베이스 로깅 로직을 구현할 수 있습니다.
        parent::write("DB 로그 메시지: " . $message);
        echo "[DatabaseLogger] 데이터베이스에 로그 기록: '{$message}'\n";
    }

    public function getDbInfo(): string
    {
        return $this->dbConnectionInfo;
    }
}

// 부모 클래스만 사용하는 경우
$simpleLogger = new Logger("debug.log");
$simpleLogger->write("단순 로그 메시지입니다.");
echo "\n";

// 자식 클래스를 사용하는 경우 (부모 생성자도 호출됨)
$dbLogger = new DatabaseLogger("mysql://user:pass@host/db", "db_errors.log");
$dbLogger->write("데이터베이스 오류 발생!");
echo "DB 연결 정보: " . $dbLogger->getDbInfo() . "\n";
?>

태그: PHP 객체 지향 프로그래밍 인터페이스 추상 클래스 static 키워드

10월 16일 19:02에 게시됨