7. 面向对象

  # A-定义类。使用 class 关键字定义类
class Dog:
    species = "Canis familiars" # 类属性

    # __init__ 为初始化方法，可以传入初始化参数，定义属性
    def __init__(self, name, breed):
        self.name = name # 通过 self 将属性绑定到对象。为实例属性
        self.breed = breed 

    # 实例方法。为定义的行为
    def bark(self): # 用 self 作为方法的第一个参数
        print(f"{self.name} says: Woof!")

    # 设置年龄
    def setAge(self, age):
        self.age = age

    # 获取年龄
    def getAge(self):
        return self.age

    # 通过装饰器定义类方法
    @classmethod
    def describe(cls):
        return cls.species

# B-创建对象。使用类创建对象
dog1 = Dog("Buddy", "Golden Retriever")
dog2 = Dog("Max", "Bulldog")

# 调用实例属性
print(dog1.name)
print(dog2.breed)

# 调用方法
dog1.bark()
dog2.bark()

# 调用类属性
print(Dog.species) # 通过类访问
print(dog1.species) # 通过实例访问
print(dog2.species)

# 调用类方法
print(Dog.describe()) # 通过类访问
print(dog1.describe()) # 通过实例访问
print(dog2.describe())
  

  class Dog:
    species = "Canis familiars"
  

      def __init__(self, name, breed):
        self.name = name
        self.breed = breed
  

      def bark(self):
        print(f"{self.name} says: Woof!")
  

      def setAge(self, age):
        self.age = age

    def getAge(self):
        return self.age
  

      @classmethod
    def describe(cls):
        return cls.species
  

  dog1 = Dog("Buddy", "Golden Retriever")
dog2 = Dog("Max", "Bulldog")
  

  print(dog1.name)
print(dog2.breed)
  

  dog1.bark()
dog2.bark()
  

  dog1.setAge(3)
print(dog1.getAge())
  

  print(Dog.species)
print(dog1.species)
print(dog2.species)
  

  print(Dog.describe())
print(dog1.describe())
print(dog2.describe())
  

  class MyClass:
    def __init__(self):
        self.__private_attr = 43 # 私有属性
        self._protected_attr = "This is a convention-prottected attribute" # 

    def get_private_attr(self):
        return self.__private_attr # 通过方法访问私有属性

    def set_private_attr(self, value):
        self.__private_attr = value

    # 私有方法
    def __private_method(self):
        print("This is a private mehotd.")

    def public_method(self):
        self.__private_method() # 类内调用私有方法


obj = MyClass()
print(obj._MyClass__private_attr) # 可以通过名称改写机制访问，但不推荐

obj.set_private_attr(97) # 设置私有属性
print(obj.get_private_attr()) # 通过方法访问私有属性
  

  #include <iostream>
#include <format>

// 定义类
class Dog {
// 私有成员变量和成员函数
private:
	int age;
// 公有成员变量和成员函数
public:
    //成员变量
	static std::string species; // 静态成员变量
	std::string name;
	std::string breed;

    // 构造函数
	Dog(const std::string& name, const std::string& breed) {
		this->name = name;
		this->breed = breed;
		this->age = 0;
	}

    //成员函数
	void bark() const {
		std::cout << std::format("{} syas: Woof!\n", name);
	}

    //设置年龄
	void setAge(int age) {
		this->age = age;
	}

    // 获取年龄
	int getAge() const {
		return age;
	}

    // 静态成员函数
	static std::string describe() {
		return species;
	}

};

std::string Dog::species = "Canis familiaris";

int main() {
    // 实例化对象
	Dog dog1("Buddy", "Golden Retriever");
	Dog dog2("Max", "Bulldog");

	std::cout << dog1.name << std::endl;
	std::cout << dog2.name << std::endl;

	dog1.bark();
	dog2.bark();

    // 修改属性
	dog1.setAge(3);
	std::cout << dog1.getAge() << std::endl;

    // 访问静态成员变量
	std::cout << Dog::species << std::endl;
	std::cout << dog1.species << std::endl;
	std::cout << dog2.species << std::endl;

    // 调用静态成员函数
	std::cout << Dog::describe() << std::endl;
	std::cout << dog1.describe() << std::endl;
	std::cout << dog2.describe() << std::endl;

	return 0;
}
  

  class Dog {
private:
    ...
public:
    ...
};
  

  Dog(const std::string& name, const std::string& breed)
  

  std::string Dog::species = "Canis familiaris";
  

  int main() {
    Dog dog1("Buddy", "Golden Retriever");
    Dog dog2("Max", "Bulldog");
  

      std::cout << dog1.name << std::endl;
    std::cout << dog2.name << std::endl;
  

      dog1.bark();
    dog2.bark();
  

      dog1.setAge(3);
    std::cout << dog1.getAge() << std::endl;
  

      std::cout << Dog::species << std::endl;
    std::cout << dog1.species << std::endl;
    std::cout << dog2.species << std::endl;
  

      std::cout << Dog::describe() << std::endl;
    std::cout << dog1.describe() << std::endl;
    std::cout << dog2.describe() << std::endl;
  

  using System;

// 定义类
class Dog
{
    // 静态变量
    public static string species = "Canis familiaris"; 

    // 实例成员变量
    public string name;
    public string breed;
    private int age;

    // 构造方法
    public Dog(string name, string breed)
    {
        this.name = name;
        this.breed = breed;
        this.age = 0; // 设置默认值
    }

    // 狗叫的实例方法
    public void Bark()
    {
        Console.WriteLine($"{this.name} says: Woof!");
    }

    // 设置狗的年龄
    public void SetAge(int age)
    {
        this.age = age;
    }

    // 访问狗的年龄
    public int GetAge()
    {
        return this.age;
    }

    // 描述物种的静态方法
    public static string Describe()
    {
        return species;
    }

}

class Program
{    
    static void Main()
    {
        // 创建 Dog 的实例
        Dog dog1 = new Dog("Buddy", "Golden Retriever");
        Dog dog2 = new Dog("Max", "Bulldog");

        // 访问狗的名字和品种
        Console.WriteLine(dog1.name);
        Console.WriteLine(dog2.breed);

        // 调用狗的实例方法（狗吠）
        dog1.Bark();
        dog2.Bark();    

        // 设置和打印狗的年龄
        dog1.SetAge(3);
        dog1.GetAge();

        // 打印静态变量
        Console.WriteLine(Dog.species);
        //Console.WriteLine(dog1.species); // 实例化对象不能访问静态变量

        // 调用静态方法
        Console.WriteLine(Dog.Describe()); 
       // Console.WriteLine(dog1.Describe());  // 实例化方法不能调用静态方法
    }
}
  

  using System;
  

  class Dog
{
    public static string species = "Canis familiaris";
  

      public string name;
    public string breed;
    private int age;
  

      public Dog(string name, string breed)
    {
        this.name = name;
        this.breed = breed;
        this.age = 0;
    }
  

      public void Bark()
    {
        Console.WriteLine($"{this.name} says: Woof!");
    }
  

      public void SetAge(int age)
    {
        this.age = age;
    }
  

      public int GetAge()
    {
        return this.age;
    }
  

      public static string Describe()
    {
        return species;
    }
  

  class Program
{
    static void Main()
    {
  

          Dog dog1 = new Dog("Buddy", "Golden Retriever");
        Dog dog2 = new Dog("Max", "Bulldog");

        Console.WriteLine(dog1.name);
        Console.WriteLine(dog2.breed);
  

          dog1.Bark();
        dog2.Bark();
  

          dog1.SetAge(3);
        dog1.GetAge();
  

          Console.WriteLine(Dog.species);
        //Console.WriteLine(dog1.species);
  

          Console.WriteLine(Dog.Describe());
        // Console.WriteLine(dog1.Describe());
    }
}
  

  using System;

public static class MathUtilities
{
    public static double Pi = 3.14;
    public static double Square(double x)
    {
        return x * x;   
    }
}

class Program
{    
    static void Main()
    {
        Console.WriteLine(MathUtilities.Pi);
        Console.WriteLine(MathUtilities.Square(5));
    }
}
  

  using System;

public class Example
{
    public static int counter;

    // 静态构造函数
    static Example()
    {
        counter = 10;
        Console.WriteLine("Static constructor called.");
    }

    public static void ShowCounter()
    {
        Console.WriteLine($"Counter: {counter}");
    }
}

class Program
{    
    static void Main()
    {
        Example.ShowCounter();
    }
}
  

  using System;

public class Counter
{
    private static int _count;

    public static int Count
    {
        get { return _count; }
        set { _count = value; }
    }
}

class Program
{    
    static void Main()
    {
            Counter.Count = 7;
            Console.WriteLine(Counter.Count);
    }
}
  

  public class Counter
{
    private static int _count;
  

      public static int Count
    {
        get { return _count; }
        set { _count = value; }
    }
  

  # 定义父类（基类）
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return f"{self.name} makes a sound."

# 定义子类（派生类）
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name) # 调用父类的构造方法
        self.breed = breed

    def speak(self): # 子类重新父类的方法
        print(f"{self.name} barks.")


class Cat(Animal):
    def speak(self): # 子类重新父类的方法
        print(f"{self.name} meows.")


dog = Dog("Buddy", "Golden Retriever")
cat = Cat("Whiskers")

dog.speak()
cat.speak()
  

  class Animal:
    def __init__(self, name):
        self.name = name


class Mammal:
    def give_birth(self):
        print(f"{self.name} gives birth.")


class Dog(Animal, Mammal):
    def __init__(self, name, breed):
        Animal.__init__(self, name)
        self.breed = breed

    def speak(self):
        print(f"{self.name} barks.")


dog = Dog("Buddy", "Golden Retriever")
dog.speak()
dog.give_birth()

print(Dog.mro())
  

  #include <iostream>
#include <format>

// 基类
class Base {
public:
    int baseValue;

    Base(int val) : baseValue(val) {} // 基类构造函数

    virtual void display() { // 使用 virtual（虚函数），允许派生类重写该方法
        std::cout << std::format("Base class value: {}\n", baseValue);
    }
};

// 派生类
class Derived : public Base { // 公有继承
public:
    int derivedValue;

    Derived(int baseVal, int derivedValue) : Base(baseVal), derivedValue(derivedValue) {} // 派生类构造函数

    void display() override { // 使用 override，重写基类的虚函数 display
        std::cout << std::format("Derived class value: {}\n", derivedValue);
    }
};

int main() {
    Derived instance(10, 20); // 创建 Derived 类对象 instance

    // 调用 display 方法
    instance.display();

    return 0;
}
  

  #include <iostream>
#include <format>

// 基类
class Animal {
public:
    Animal(const std::string& name):name(name){}

    virtual void speak() {
        std::cout << std::format("{} makes a sound.\n", name);
    }

protected:
    std::string name;
};

// 派生类
class Dog : public Animal {
public:
    Dog(const std::string& name,const std::string& breed):Animal(name),breed(breed){}

    void speak()override {
        std::cout << std::format("{}, barks!\n", name);
    }
private:
    std::string breed;
};



int main() {
    Dog dog("Buddy", "Golden Retriever");
    dog.speak();

    return 0;
}
  

  #include <iostream>
#include <format>

class A {
public:
    void displayA() {
        std::cout << "Class A" << std::endl;
    }
};

class B {
public:
    void displayB() {
        std::cout << "Class B" << std::endl;
    }
};

class C : public A, public B {
public:
    void displayC() {
        std::cout << "Class C" << std::endl;
    }
};


int main() {
    C obj;
    obj.displayA();
    obj.displayB();
    obj.displayC();

    return 0;
}
  

  #include <iostream>

class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called!" << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructor called!" << std::endl;
    }
};


int main() {
    MyClass obj; // 创建对象，调用构造函数
    std::cout << "Inside main function." << std::endl;
    // main 函数结束，obj 的析构函数被调用
    return 0;
}
  

  #include <iostream>
#include <format>

class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called!" << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructor called!" << std::endl;
    }
};


int main() {
    MyClass arr[3];
    std::cout << "Inside main function." << std::endl;

    return 0;
}
  

  #include <iostream>
#include <format>

class Base {
public:
    Base() {
        std::cout << "Constructor called!" << std::endl;
    }

    virtual ~Base() { std::cout << "Base destructor" << std::endl; }
};

class Derived : public Base {
    ~Derived() override { std::cout << "Derived destructor" << std::endl; }
};


int main() {
    Base* obj = new Derived();
    delete obj;

    return 0;
}
  

  using System;

class BaseClass
{
    public string Name { get; set; }

    public void Display()
    {
        Console.WriteLine($"Name: {Name}");
    }
}

class DerivedClass : BaseClass
{
    public int Age { get; set; }

    public void Show()
    {
        Console.WriteLine($"Name: {Name}； Age: {Age}");
    }
}


class Program
{    
    static void Main()
    {
        // 创建 BaseClass 类的实例，设置字段值，并调用 Show 和 Display 方法
        DerivedClass derivedObj=new DerivedClass();
        derivedObj.Name = "Bob";
        derivedObj.Age = 29;
        derivedObj.Show();

        derivedObj.Display();  
    }
}
  

  using System;

// 基类
class Animal
{
    public string Name { get; set; }

    public Animal(string name)
    {
        Name = name;
    }

    public virtual void Speak()
    {
        Console.WriteLine($"{Name} makes a sound.");
    }
}

// 派生类
class Dog : Animal
{
    public Dog(string name) : base(name) { }

    public override void Speak() // 重写基类方法
    {
        Console.WriteLine($"{Name} barks.");
    }
}

// 派生类
class Cat : Animal
{
    public Cat(string name) : base(name) { }

    public override void Speak() // 重写基类方法
    {
        base.Speak();
        Console.WriteLine($"{Name} meows.");
    }
}


class Program
{    
    static void Main()
    {
        Animal dog = new Dog("Budyy");
        Animal cat = new Cat("Whiskers");

        dog.Speak();
        cat.Speak();
    }
}
  

  using System;

// 定义接口
public interface IDrivable
{
    void Drive(); // 接口方法没有实现
}

public interface IFlyable
{
    void Fly(); // 接口方法没有实现
}

// 实现多个接口
public class Vehicle : IDrivable, IFlyable
{
    public void Drive()
    {
        Console.WriteLine("Driving the vehicle");
    }

    public void Fly()
    {
        Console.WriteLine("Flying the vehicle");
    }
} 

class Program
{    
    static void Main()
    {
        Vehicle v = new Vehicle();
        v.Drive(); // 调用 Drive 方法
        v.Fly(); // 调用 Fly 方法
    }
}
  

  using System;

// 定义基础接口
public interface IShape
{
    void Draw();
}

public interface IColorable
{
    void Color();
}

// 定义一个继承多个接口的接口
public interface IColoredShape : IShape, IColorable
{
    void GetShapeDetails();
}

// 实现接口
public class Circle : IColoredShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing Circle");
    }

    public void Color()
    {
        Console.WriteLine("Coloring Circle");
    }

    public void GetShapeDetails()
    {
        Console.WriteLine("This is a colored circle");
    }
}

class Program
{
    static void Main()
    {
        Circle c = new Circle();
        c.Draw(); // 绘制圆形
        c.Color(); // 给圆形上色
        c.GetShapeDetails(); // 获取圆形细节
    }
}
  

  from abc import ABC, abstractmethod


class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass


class Dog(Animal):
    def speak(self):
        return "Woof"


class Cat(Animal):
    def speak(self):
        return "Meow"


# animal = Animal() # 错误，不能实例化抽象类，返回错误信息为 TypeError: Can't instantiate abstract class Animal without an implementation for abstract method 'speak'
dog = Dog()
cat = Cat()

print(dog.speak())
print(cat.speak())
  

  #include <iostream>
#include <format>

class Animal {
public:
    virtual void speak() = 0; // 纯虚函数
    virtual ~Animal(){} // 虚析构函数
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Woof" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "Meow" << std::endl;
    }
};


int main() {
    // Animal animal; // 错误：不能实例化抽象类，返回错误信息为，object of abstract class type "Animal" is not allowed
    Animal* dog = new Dog();
    Animal* cat = new Cat();

    dog->speak();
    cat->speak();

    delete dog;
    delete cat;

    return 0;
}
  

  using System;

abstract class Animal
{
    public abstract void Speak(); // 抽象方法

    public void Move()
    {
        Console.WriteLine("Moving...");
    }
}

class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Woof");
    }
}

class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Meow");
    }
}

class Program
{
    static void Main()
    {
        // Animal animal = new Animal(); // 错误：不能实例化抽象类，返回错误信息为，Cannot create an instance of the abstract type or interface 'Animal'
        Animal dog = new Dog(); 
        Animal cat = new Cat();

        dog.Speak();
        cat.Speak();

        dog.Move();
    }
}