📊 流行語言面向對象特性對比

🔍 詳細語言分析

1. Python - 靈活的多範式OOP

class Animal:
    def __init__(self, name):
        self.name = name  # 公共屬性
        self._protected = "protected"  # 保護約定
        self.__private = "private"  # 名稱修飾實現私有
    
    def speak(self):
        raise NotImplementedError("子類必須實現")

class Dog(Animal):  # 單繼承
    def speak(self):
        return f"{self.name} says Woof!"

class Robot:
    def beep(self):
        return "Beep beep!"

class RoboDog(Dog, Robot):  # 多繼承
    def speak(self):
        return f"{self.name} says Electronic Woof!"

2. C - 過程式語言，無內置OOP

// 使用結構體和函數模擬OOP
typedef struct {
    char name[50];
    int age;
} Person;

// "方法"作為獨立函數
void person_introduce(Person* self) {
    printf("Hello, I'm %s, %d years old\n", self->name, self->age);
}

// 無繼承、多態等高級特性

3. C++ - 強大的多範式OOP

class Shape {
protected:
    double width, height;
public:
    Shape(double w, double h) : width(w), height(h) {}
    virtual double area() = 0;  // 純虛函數
    virtual ~Shape() {}  // 虛析構函數
};

class Rectangle : public Shape {
public:
    Rectangle(double w, double h) : Shape(w, h) {}
    double area() override {
        return width * height;
    }
};

class Triangle : public Shape {
public:
    Triangle(double w, double h) : Shape(w, h) {}
    double area() override {
        return width * height / 2;
    }
};

4. Java - 嚴格的純OOP

interface Flyable {
    void fly();
}

abstract class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public abstract String speak();
    
    public String getName() {
        return name;
    }
}

class Bird extends Animal implements Flyable {
    public Bird(String name) {
        super(name);
    }
    
    @Override
    public String speak() {
        return "Chirp!";
    }
    
    @Override
    public void fly() {
        System.out.println(getName() + " is flying");
    }
}

5. C# - 現代化的企業級OOP

interface ILogger {
    void Log(string message);
}

abstract class Vehicle {
    public string Model { get; set; }
    public abstract void Start();
}

class Car : Vehicle, ILogger {
    public override void Start() {
        Console.WriteLine($"{Model} car starting");
    }
    
    public void Log(string message) {
        Console.WriteLine($"Log: {message}");
    }
    
    // 自動屬性
    public int Year { get; set; }
}

6. JavaScript - 基於原型的OOP

// 原型鏈繼承
function Animal(name) {
    this.name = name;
}

Animal.prototype.speak = function() {
    return `${this.name} makes a sound`;
};

function Dog(name) {
    Animal.call(this, name);
}

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;
Dog.prototype.speak = function() {
    return `${this.name} says Woof!`;
};

// ES6 Class語法糖
class Cat extends Animal {
    constructor(name) {
        super(name);
    }
    
    speak() {
        return `${this.name} says Meow!`;
    }
}

7. PHP - 腳本語言的OOP支持

interface Logger {
    public function log($message);
}

trait Timestamp {
    public function getTimestamp() {
        return date('Y-m-d H:i:s');
    }
}

class User implements Logger {
    use Timestamp;  // Trait實現代碼複用
    
    private $name;
    
    public function __construct($name) {
        $this->name = $name;
    }
    
    public function log($message) {
        echo $this->getTimestamp() . " - {$this->name}: $message";
    }
    
    // 魔術方法
    public function __get($property) {
        if ($property === 'name') {
            return $this->name;
        }
    }
}

8. Go - 極簡的OOP替代方案

// 接口定義
type Speaker interface {
    Speak() string
}

// 結構體代替類
type Dog struct {
    Name string
}

// 方法綁定到結構體
func (d Dog) Speak() string {
    return d.Name + " says Woof!"
}

// 組合代替繼承
type Robot struct {
    Model string
}

func (r Robot) Beep() string {
    return r.Model + " says Beep!"
}

type RoboDog struct {
    Dog    // 嵌入實現組合
    Robot  // 嵌入實現組合
}

func (rd RoboDog) Speak() string {
    return rd.Dog.Speak() + " and " + rd.Robot.Beep()
}

🎯 關鍵發現

1. OOP純度梯度：

   • 純OOP: Java, C#
   • 多範式OOP: Python, C++, PHP
   • 原型OOP: JavaScript
   • 極簡OOP: Go
   • 無OOP: C, SQL

2. 繼承模型差異：

   • 多繼承: Python, C++
   • 單繼承+接口: Java, C#, PHP
   • 原型鏈: JavaScript
   • 組合優於繼承: Go
   • 無繼承: C, SQL

3. 封裝機制：

   • 訪問修飾符: Java, C#, C++, PHP
   • 命名約定: Python (_protected, __private)
   • 閉包: JavaScript
   • 包級可見性: Go

4. 多態實現：

   • 接口多態: Java, C#, Go
   • 虛函數: C++
   • 鴨子類型: Python, JavaScript
   • 無多態: C, SQL

💡 總結

各種流行語言展現了豐富的OOP實現多樣性：

• 企業級開發: Java, C# 提供嚴格的OOP保障
• 系統編程: C++ 提供性能與OOP的平衡
• Web開發: Python, JavaScript, PHP 提供靈活的OOP選擇
• 極簡主義: Go 重新思考OOP的本質
• 傳統語言: C 堅守過程式編程

每種語言的OOP設計都反映了其設計哲學和目標應用領域，沒有絕對的優劣，只有適合不同場景的選擇。