定义person类，定义成员属性name和age

当你定义一个`Person`类时，你可以为其创建两个成员属性，`name`和`age`。这两个属性通常用于存储个体的名字和年龄信息。在Python中，这可以通过以下方式实现：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# 这里定义了构造函数__init__，当创建Person实例时，传入的名字和年龄会被用来初始化相应的属性

在这个例子中，`__init__`是一个特殊的方法，被称为构造函数，每当一个新的`Person`对象被创建时，它都会自动被调用。`self`参数代表对象本身，`name`和`age`则是传递给该类的参数。

现在，如果你想创建一个具体的`Person`实例，例如John，年龄为30，可以这样做：

john = Person("John", 30)
print(john.name)  # 输出 "John"
print(john.age)   # 输出 30

相关问题

定义Person类 name和age

在面向对象编程中，我们通常会定义一个基础类，例如"Person"，用于表示一类具有共同属性的对象。在这个例子中，我们可以创建一个名为Person的类，它包含两个私有成员变量：name和age，分别代表人的姓名和年龄。下面是这个类的一个简单示例：

public class Person {
    // 私有成员变量，表示姓名和年龄
    private String name;
    private int age;

    // 构造函数，用于初始化对象
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 获取名字的方法，提供访问权限
    public String getName() {
        return name;
    }

    // 设置名字的方法，同样提供访问权限
    public void setName(String name) {
        this.name = name;
    }

    // 获取年龄的方法
    public int getAge() {
        return age;
    }

    // 设置年龄的方法
    public void setAge(int age) {
        this.age = age;
    }
}

1）定义抽象类object：只提供一个纯虚函数print(); 2）定义person类，公有继承object类，定义属性name（姓名）、age（年龄）和sex（性别），并定义print()成员函数显示相关信息； 3）定义employee类，公有继承person类，定义属性ID（员工ID），定义print()成员函数显示相关信息； 4）在main()函数中，定义object指针变量调用person 对象及employee对象的print成员函数。 （根据实际需求定义各个类的构造函数）

好的，以下是代码实现：

#include <iostream>
using namespace std;

// 定义抽象类object
class object {
public:
    virtual void print() = 0;     // 纯虚函数
};

// 定义person类，公有继承object类
class person : public object {
public:
    person(string n, int a, string s) : name(n), age(a), sex(s) {}   // 构造函数
    void print() {      // 重写print函数
        cout << "姓名：" << name << "，年龄：" << age << "，性别：" << sex << endl;
    }
private:
    string name;
    int age;
    string sex;
};

// 定义employee类，公有继承person类
class employee : public person {
public:
    employee(string n, int a, string s, int i) : person(n, a, s), ID(i) {}   // 构造函数
    void print() {      // 重写print函数
        person::print();    // 调用person的print函数
        cout << "员工ID：" << ID << endl;
    }
private:
    int ID;
};

int main() {
    object* obj1 = new person("张三", 25, "男");     // 创建person对象
    obj1->print();      // 调用print函数

    object* obj2 = new employee("李四", 30, "女", 1001);     // 创建employee对象
    obj2->print();      // 调用print函数

    delete obj1;
    delete obj2;
    return 0;
}

在上述代码中，先定义了一个抽象类`object`，其中包含一个纯虚函数`print()`。然后定义了`person`类，它公有继承自`object`类，并包含姓名、年龄和性别三个属性，以及重写的`print()`函数。接着定义了`employee`类，它公有继承自`person`类，并增加了一个员工ID属性，同样重写了`print()`函数。在`main()`函数中，通过`new`关键字分别创建了`person`和`employee`对象，并通过`object`指针调用它们的`print()`函数。最后别忘了释放内存。