인터페이스와 상속를 언어별로 비교하기

// 인터페이스 — 기본 구현 가능
interface Drawable {
    val color: String       // 추상 프로퍼티
    fun draw()              // 추상 메서드
    fun describe() = "나는 $color 색 도형"  // 기본 구현
}

interface Resizable {
    fun resize(factor: Double)
}

// 다중 인터페이스 구현
class Circle(
    override val color: String,
    var radius: Double
) : Drawable, Resizable {
    override fun draw() = println("⭕ 반지름 $radius 원")
    override fun resize(factor: Double) { radius *= factor }
}

// 추상 클래스 — 상태(필드)를 가질 수 있음
abstract class Shape(val name: String) {
    var x = 0.0; var y = 0.0

    abstract fun area(): Double

    fun move(dx: Double, dy: Double) {
        x += dx; y += dy
    }
}

class Rectangle(val w: Double, val h: Double)
    : Shape("사각형") {
    override fun area() = w * h
}

fun main() {
    val c = Circle("red", 5.0)
    c.draw()
    println(c.describe())
    c.resize(2.0)
    c.draw()

    val r = Rectangle(3.0, 4.0)
    r.move(1.0, 2.0)
    println("넓이: ${r.area()}, 위치: (${r.x}, ${r.y})")
}

from abc import ABC, abstractmethod
from typing import Protocol, runtime_checkable

# 추상 기반 클래스 (ABC)
class Animal(ABC):
    def __init__(self, name: str):
        self.name = name

    @abstractmethod
    def sound(self) -> str: ...

    def describe(self):   # 공통 구현
        print(f"{self.name}는 {self.sound()} 합니다")

class Dog(Animal):
    def sound(self) -> str: return "멍멍"

class Cat(Animal):
    def sound(self) -> str: return "야옹"

# Protocol — 구조적 서브타이핑 (duck typing 공식화)
@runtime_checkable
class Drawable(Protocol):
    def draw(self) -> None: ...

class Circle:   # Drawable을 명시적으로 상속하지 않음
    def draw(self): print("⭕ 원 그리기")

class Square:
    def draw(self): print("⬜ 사각형 그리기")

def render(shape: Drawable):
    shape.draw()

# super() 활용
class Vehicle:
    def __init__(self, brand: str):
        self.brand = brand

class ElectricCar(Vehicle):
    def __init__(self, brand: str, battery: int):
        super().__init__(brand)
        self.battery = battery

Dog("Rex").describe()          # Rex는 멍멍 합니다
render(Circle())               # ⭕ 원 그리기
print(isinstance(Circle(), Drawable))  # True

package main

import (
	"fmt"
	"math"
)

// 인터페이스 정의
type Shape interface {
	Area() float64
	Perimeter() float64
}

// Stringer 인터페이스 (fmt.Stringer)
type Stringer interface {
	String() string
}

// 구현체 — 명시적 선언 없음
type Rectangle struct{ W, H float64 }
func (r Rectangle) Area() float64      { return r.W * r.H }
func (r Rectangle) Perimeter() float64 { return 2*(r.W+r.H) }
func (r Rectangle) String() string {
	return fmt.Sprintf("Rect(%.1f×%.1f)", r.W, r.H)
}

type Circle struct{ R float64 }
func (c Circle) Area() float64      { return math.Pi * c.R * c.R }
func (c Circle) Perimeter() float64 { return 2 * math.Pi * c.R }

// 인터페이스를 파라미터로
func printShape(s Shape) {
	fmt.Printf("넓이: %.2f, 둘레: %.2f
", s.Area(), s.Perimeter())
}

// 인터페이스 슬라이스
func totalArea(shapes []Shape) float64 {
	var total float64
	for _, s := range shapes { total += s.Area() }
	return total
}

// 빈 인터페이스 — 모든 타입 허용
func describe(i interface{}) {
	fmt.Printf("타입: %T, 값: %v
", i, i)
}

// 타입 단언
func main() {
	shapes := []Shape{
		Rectangle{3, 4},
		Circle{5},
	}
	for _, s := range shapes { printShape(s) }
	fmt.Printf("총 넓이: %.2f
", totalArea(shapes))

	describe(42)
	describe("hello")
	describe(Rectangle{1, 2})

	// 타입 단언
	var s Shape = Rectangle{3, 4}
	if r, ok := s.(Rectangle); ok {
		fmt.Println("Rectangle:", r.W, r.H)
	}
}

// 부모 클래스
public abstract class Animal {
    private final String name;   // 캡슐화 (private)
    protected int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age  = age;
    }

    // abstract — 하위 클래스에서 반드시 구현
    public abstract String sound();

    // 공통 구현
    public void introduce() {
        System.out.printf("%s: %s (나이 %d)%n",
            name, sound(), age);
    }

    public String getName() { return name; }
}

// 자식 클래스
public class Dog extends Animal {
    private final String breed;

    public Dog(String name, int age, String breed) {
        super(name, age);  // 부모 생성자 호출
        this.breed = breed;
    }

    @Override
    public String sound() { return "멍멍"; }

    @Override
    public String toString() {
        return String.format("Dog{name=%s, breed=%s}",
            getName(), breed);
    }
}

// final class — 상속 불가
public final class Cat extends Animal {
    public Cat(String name, int age) { super(name, age); }

    @Override public String sound() { return "야옹"; }
}

class Main {
    public static void main(String[] args) {
        Animal[] animals = {
            new Dog("Rex", 3, "진돗개"),
            new Cat("Kitty", 2),
        };

        for (Animal a : animals) {
            a.introduce();  // 다형성

            // instanceof + Pattern Matching (Java 16+)
            if (a instanceof Dog d) {
                System.out.println("견종: " + d.breed);
            }
        }
    }
}

<?php
class Animal {
    public function speak(): string {
        return '...';
    }
}

class Dog extends Animal {
    public function speak(): string {
        return 'woof';
    }
}

echo (new Dog())->speak();

// 상속 또는 확장
class User {
  constructor(name, level) { this.name = name; this.level = level; }
  summary() { return `${this.name}:${this.level}`; }
}
console.log(new User("Ada", 5).summary());

// 상속 또는 확장
class User {
  constructor(public name: string, public level: number) {}
  summary(): string { return `${this.name}:${this.level}`; }
}
console.log(new User("Ada", 5).summary());

// 상속 또는 확장
using System;

public class User { public User(string name, int level) { Name = name; Level = level; } public string Name { get; } public int Level { get; } }
Console.WriteLine(new User("Ada", 5).Name);

// 상속 또는 확장
#include <iostream>
#include <string>

struct User { std::string name; int level; };
int main() {
    User user{"Ada", 5};
    std::cout << user.name << "\n";
}

// 상속 또는 확장
struct User { name: String, level: i32 }
fn main() {
    let user = User { name: "Ada".to_string(), level: 5 };
    println!("{}", user.name);
}