Carbon类与继承 #

一、类概述 #

类是面向对象编程的核心概念，封装数据和行为。Carbon的类支持继承、接口实现和访问控制。

二、类定义 #

2.1 基本定义 #

carbon 
class Person {
  var name: String;
  var age: i32;
  
  fn New(name: String, age: i32) -> Person {
    return Person(name = name, age = age);
  }
  
  fn Introduce(me) -> String {
    return "我是{0}，今年{1}岁".Format(me.name, me.age);
  }
}

2.2 创建对象 #

carbon 
var person: Person = Person.New("Alice", 30);
Print("{0}", person.Introduce());

2.3 成员初始化 #

carbon 
class Point {
  var x: f64 = 0.0;
  var y: f64 = 0.0;
  
  fn New(x: f64, y: f64) -> Point {
    return Point(x = x, y = y);
  }
}

var origin: Point = Point();  // 使用默认值
var p: Point = Point.New(3.0, 4.0);

三、访问控制 #

3.1 private成员 #

carbon 
class BankAccount {
  private var balance_: f64 = 0.0;
  
  fn New(initial: f64) -> BankAccount {
    return BankAccount(balance_ = initial);
  }
  
  fn Balance(me) -> f64 {
    return me.balance_;
  }
  
  fn Deposit(me&, amount: f64) {
    if (amount > 0) {
      me.balance_ += amount;
    }
  }
}

var account: BankAccount = BankAccount.New(100.0);
account.Deposit(50.0);
Print("余额: {0}", account.Balance());
// account.balance_ = 0;  // 错误：私有成员不可访问

3.2 protected成员 #

carbon 
class Animal {
  protected var name_: String;
  
  fn New(name: String) -> Animal {
    return Animal(name_ = name);
  }
  
  fn MakeSound(me) -> String {
    return "某种声音";
  }
}

class Dog extends Animal {
  fn New(name: String) -> Dog {
    return Dog(name_ = name);
  }
  
  fn MakeSound(me) -> String {
    return "{0}说：汪汪！".Format(me.name_);  // 可以访问protected成员
  }
}

3.3 public成员 #

carbon 
class Point {
  public var x: f64;
  public var y: f64;
  
  fn New(x: f64, y: f64) -> Point {
    return Point(x = x, y = y);
  }
}

var p: Point = Point.New(3.0, 4.0);
p.x = 5.0;  // public成员可直接访问

四、继承 #

4.1 基本继承 #

carbon 
class Animal {
  var name: String;
  
  fn New(name: String) -> Animal {
    return Animal(name = name);
  }
  
  fn MakeSound(me) -> String {
    return "某种声音";
  }
}

class Dog extends Animal {
  var breed: String;
  
  fn New(name: String, breed: String) -> Dog {
    return Dog(name = name, breed = breed);
  }
  
  fn MakeSound(me) -> String {
    return "汪汪！";
  }
}

var dog: Dog = Dog.New("Buddy", "Golden Retriever");
Print("{0}", dog.MakeSound());  // 汪汪！

4.2 调用父类方法 #

carbon 
class Animal {
  var name: String;
  
  fn New(name: String) -> Animal {
    return Animal(name = name);
  }
  
  fn Describe(me) -> String {
    return "动物: {0}".Format(me.name);
  }
}

class Dog extends Animal {
  var breed: String;
  
  fn New(name: String, breed: String) -> Dog {
    return Dog(name = name, breed = breed);
  }
  
  fn Describe(me) -> String {
    return base.Describe(me) + "，品种: {0}".Format(me.breed);
  }
}

4.3 多态 #

carbon 
class Shape {
  fn Area(me) -> f64;
}

class Circle extends Shape {
  var radius: f64;
  
  fn New(radius: f64) -> Circle {
    return Circle(radius = radius);
  }
  
  fn Area(me) -> f64 {
    return 3.14159 * me.radius * me.radius;
  }
}

class Rectangle extends Shape {
  var width: f64;
  var height: f64;
  
  fn New(width: f64, height: f64) -> Rectangle {
    return Rectangle(width = width, height = height);
  }
  
  fn Area(me) -> f64 {
    return me.width * me.height;
  }
}

fn PrintArea(shape: Shape) {
  Print("面积: {0}", shape.Area());
}

PrintArea(Circle.New(5.0));
PrintArea(Rectangle.New(4.0, 3.0));

五、抽象类 #

5.1 定义抽象类 #

carbon 
abstract class Shape {
  fn Area(me) -> f64;
  fn Perimeter(me) -> f64;
  
  fn Describe(me) -> String {
    return "面积: {0}, 周长: {1}".Format(me.Area(), me.Perimeter());
  }
}

5.2 实现抽象类 #

carbon 
class Circle extends Shape {
  var radius: f64;
  
  fn New(radius: f64) -> Circle {
    return Circle(radius = radius);
  }
  
  fn Area(me) -> f64 {
    return 3.14159 * me.radius * me.radius;
  }
  
  fn Perimeter(me) -> f64 {
    return 2.0 * 3.14159 * me.radius;
  }
}

六、接口 #

6.1 定义接口 #

carbon 
interface Printable {
  fn Print(me);
}

interface Comparable {
  fn Compare(me, other: me) -> i32;
}

interface Serializable {
  fn Serialize(me) -> String;
  fn Deserialize(data: String) -> me;
}

6.2 实现接口 #

carbon 
class Person {
  var name: String;
  var age: i32;
  
  impl Printable {
    fn Print(me) {
      Print("Person({0}, {1})", me.name, me.age);
    }
  }
  
  impl Comparable {
    fn Compare(me, other: Person) -> i32 {
      return me.age - other.age;
    }
  }
}

var p1: Person = Person(name = "Alice", age = 30);
var p2: Person = Person(name = "Bob", age = 25);

p1.Print();
var cmp: i32 = p1.Compare(p2);

6.3 多接口实现 #

carbon 
class Product {
  var id: i32;
  var name: String;
  var price: f64;
  
  impl Printable {
    fn Print(me) {
      Print("Product({0}: {1}, ${2})", me.id, me.name, me.price);
    }
  }
  
  impl Serializable {
    fn Serialize(me) -> String {
      return "{0}|{1}|{2}".Format(me.id, me.name, me.price);
    }
    
    fn Deserialize(data: String) -> Product {
      var parts: [String] = data.Split("|");
      return Product(
        id = i32(parts[0]),
        name = parts[1],
        price = f64(parts[2])
      );
    }
  }
}

七、构造与析构 #

7.1 构造函数 #

carbon 
class Resource {
  var handle_: i32;
  
  fn New() -> Resource {
    var r: Resource = Resource(handle_ = 0);
    r.handle_ = AllocateResource();
    return r;
  }
}

7.2 析构函数 #

carbon 
class Resource {
  var handle_: i32;
  
  fn New() -> Resource {
    return Resource(handle_ = AllocateResource());
  }
  
  fn Delete(me&) {
    if (me.handle_ != 0) {
      FreeResource(me.handle_);
      me.handle_ = 0;
    }
  }
}

八、静态成员 #

8.1 静态变量 #

carbon 
class Counter {
  static var count_: i32 = 0;
  
  fn New() -> Counter {
    count_ += 1;
    return Counter();
  }
  
  fn Count() -> i32 {
    return count_;
  }
}

var c1: Counter = Counter.New();
var c2: Counter = Counter.New();
Print("创建数量: {0}", Counter.Count());  // 2

8.2 静态方法 #

carbon 
class Math {
  static fn Square(x: f64) -> f64 {
    return x * x;
  }
  
  static fn Cube(x: f64) -> f64 {
    return x * x * x;
  }
}

Print("{0}", Math.Square(5.0));  // 25.0
Print("{0}", Math.Cube(3.0));    // 27.0

九、最佳实践 #

9.1 组合优于继承 #

carbon 
// 组合
class Engine {
  fn Start() { Print("引擎启动"); }
}

class Car {
  var engine: Engine;
  
  fn New() -> Car {
    return Car(engine = Engine());
  }
  
  fn Start(me) {
    me.engine.Start();
    Print("汽车启动");
  }
}

9.2 接口隔离 #

carbon 
// 小接口
interface Reader {
  fn Read(me) -> String;
}

interface Writer {
  fn Write(me&, data: String);
}

interface ReadWriter extends Reader, Writer {
}

// 实现
class File implements ReadWriter {
  impl Reader {
    fn Read(me) -> String {
      return "文件内容";
    }
  }
  
  impl Writer {
    fn Write(me&, data: String) {
      Print("写入: {0}", data);
    }
  }
}

9.3 封装数据 #

carbon 
class Temperature {
  private var celsius_: f64;
  
  fn New(celsius: f64) -> Temperature {
    return Temperature(celsius_ = celsius);
  }
  
  fn Celsius(me) -> f64 {
    return me.celsius_;
  }
  
  fn Fahrenheit(me) -> f64 {
    return me.celsius_ * 9.0 / 5.0 + 32.0;
  }
  
  fn SetCelsius(me&, value: f64) {
    me.celsius_ = value;
  }
}

十、总结 #

本章我们学习了：

  1. 类定义：基本定义、创建对象
  2. 访问控制：private、protected、public
  3. 继承：基本继承、调用父类、多态
  4. 抽象类：定义和实现
  5. 接口：定义、实现、多接口
  6. 静态成员：静态变量、静态方法
  7. 最佳实践：组合、接口隔离、封装

接下来让我们学习Carbon的泛型编程！

最后更新：2026-03-27