什么是类与对象？-CSDN博客

本文链接：https://blog.csdn.net/Yydsaoligei/article/details/125996721

本文通过人狗大战的案例介绍了面向对象编程的概念，强调了数据与功能的绑定，防止了不合适的调用。文章阐述了面向过程与面向对象的编程思想，指出面向对象是将数据和功能封装在对象中，使它们彼此关联。同时，解释了对象与类的关系，展示了类的创建过程，包括初始化方法`__init__`的作用。最后，通过一个学生类的实例，演示了如何创建具有独有数据的对象。

摘要由CSDN通过智能技术生成

一：面向对象前戏

1.人狗大战案例

1.初步代码

# 1.'创造'出人和狗
'''推导步骤1: 直接手写字典模拟一个个人和狗'''
# person1 = {  # 使用字典模拟人
#     'name': 'jason',
#     'p_type': '猛男',
#     'attack_val': 800,
#     'life_val': 2000
# }
# person2 = {  # 使用字典模拟人
#     'name': '慢男',
#     'p_type': '闷骚',
#     'attack_val': 100,
#     'life_val': 1200
# }
# dog1 = {  # 使用字典模拟狗
#     'name': '小黑狗',
#     'd_type': '泰迪',
#     'attack_val': 50,
#     'life_val': 800
# }
# dog2 = {  # 使用字典模拟狗
#     'name': '小舔狗',
#     'd_type': '比特',
#     'attack_val': 800,
#     'life_val': 8000
# }
"""推导步骤2: 由于定义人和狗的字典基本不变 但是在很多地方又需要反复使用 所以封装成函数"""


def get_person(name, gender, age, p_type, attack_val, life_val):
    """
    专用用于产生用户字典(创造人)
    :param name: 姓名
    :param gender: 性别
    :param age: 年龄
    :param d_type: 类型
    :param attack_val:攻击力
    :param life_val: 生命值
    :return: 人的字典(人)
    """
    person_obj = {
        'name': name,
        'gender': gender,
        'age': age,
        'p_type': p_type,
        'attack_val': attack_val,
        'life_val': life_val
    }
    return person_obj


# p1 = get_person('jason', 'male', 18, '猛男', 8000, 80000)
# p2 = get_person('kevin', 'female', 28, '淑女', 10, 80)
def get_dog(name, d_type, attack_val, life_val):
    """
    专门用于产生狗字典(狗)
    :param name: 狗的名字
    :param d_type: 狗的类型
    :param attack_val: 狗的攻击力
    :param life_val: 狗的生命值
    :return: 狗的字典(狗)
    """
    dog_obj = {
        'name': name,
        'd_type': d_type,
        'attack_val': attack_val,
        'life_val': life_val
    }
    return dog_obj


# d1 = get_dog('小黄狗','中华田园犬',800, 5000)
# d2 = get_dog('小奶狗','哈士奇',100, 200)
"""推导步骤3: 让人和狗具备攻击的能力 本质其实就是定义两个函数供人和狗调用"""


def person_attack(person_obj, dog_obj):
    """
    专用提供给人调用 攻击狗
    :param person_obj: 传人数据(字典)
    :param dog_obj: 传狗数据(字典)
    """
    print('即将被攻击的狗:%s 当前血量:%s' % (dog_obj.get('name'), dog_obj.get('life_val')))  # 先展示当前狗的状态
    dog_obj['life_val'] -= person_obj.get('attack_val')  # 人锤狗 直接用狗的生命值减去人的攻击力
    print('人:%s 锤了 狗:%s 狗掉血:%s 剩余血量:%s' % (
        person_obj.get('name'), dog_obj.get('name'), person_obj.get('attack_val'), dog_obj.get('life_val')))


def dog_attack(dog_obj, person_obj):
    """
    专用提供给狗调用 攻击人
    :param dog_obj: 传狗数据(字典)
    :param person_obj: 传人数据(字典)
    """
    print('即将被攻击的人:%s 当前血量:%s' % (person_obj.get('name'), person_obj.get('life_val')))  # 先展示当前人的状态
    person_obj['life_val'] -= dog_obj.get('attack_val')  # 狗咬人 直接用人的生命值减去狗的攻击力
    print('狗:%s 咬了 人:%s 人掉血:%s 剩余血量:%s' % (
        dog_obj.get('name'), person_obj.get('name'), dog_obj.get('attack_val'), person_obj.get('life_val')))


# 调用产生人和狗的函数
p1 = get_person('jason', 'male', 18, '猛男', 8000, 90000)
p2 = get_person('kevin', 'female', 28, '淑女', 10, 200)
d1 = get_dog('小黄狗', '恶霸犬', 800, 8000)
d2 = get_dog('小黑狗', '巴哥犬', 200, 500)
# 调用攻击彼此的函数
# person_attack(p1, d1)
dog_attack(d2, p2)

上述代码出现的问题：人和狗攻击的函数可以被任意调用

人可以调用狗攻击的功能
狗可以调用人攻击的功能
2.优化代码

"""推导步骤4: 人和狗攻击乱套"""
# person_attack(d2, p1)
# dog_attack(p2, d1)
"""推导步骤5: 人跟人攻击狗的函数绑定 狗跟狗攻击人的函数绑定
我们定义的函数默认情况下都是可以被任意调用的 但是现在我们想实现定义的函数只有特定的东西才可以调用
"""

def get_person(name, gender, age, p_type, attack_val, life_val):
    """
    专用用于产生用户字典(创造人)
    :param name: 姓名
    :param gender: 性别
    :param age: 年龄
    :param d_type: 类型
    :param attack_val:攻击力
    :param life_val: 生命值
    :return: 人的字典(人)
    """
    def person_attack(person_obj, dog_obj):
        """
        专用提供给人调用 攻击狗
        :param person_obj: 传人数据(字典)
        :param dog_obj: 传狗数据(字典)
        """
        print('即将被攻击的狗:%s 当前血量:%s' % (dog_obj.get('name'), dog_obj.get('life_val')))  # 先展示当前狗的状态
        dog_obj['life_val'] -= person_obj.get('attack_val')  # 人锤狗 直接用狗的生命值减去人的攻击力
        print('人:%s 锤了 狗:%s 狗掉血:%s 剩余血量:%s' % (
            person_obj.get('name'), dog_obj.get('name'), person_obj.get('attack_val'), dog_obj.get('life_val')))
    person_obj = {
        'name': name,
        'gender': gender,
        'age': age,
        'p_type': p_type,
        'attack_val': attack_val,
        'life_val': life_val,
        'person_attack':person_attack
    }
    return person_obj


def get_dog(name, d_type, attack_val, life_val):
    """
    专门用于产生狗字典(狗)
    :param name: 狗的名字
    :param d_type: 狗的类型
    :param attack_val: 狗的攻击力
    :param life_val: 狗的生命值
    :return: 狗的字典(狗)
    """
    def dog_attack(dog_obj, person_obj):
        """
        专用提供给狗调用 攻击人
        :param dog_obj: 传狗数据(字典)
        :param person_obj: 传人数据(字典)
        """
        print('即将被攻击的人:%s 当前血量:%s' % (person_obj.get('name'), person_obj.get('life_val')))  # 先展示当前人的状态
        person_obj['life_val'] -= dog_obj.get('attack_val')  # 狗咬人 直接用人的生命值减去狗的攻击力
        print('狗:%s 咬了 人:%s 人掉血:%s 剩余血量:%s' % (
            dog_obj.get('name'), person_obj.get('name'), dog_obj.get('attack_val'), person_obj.get('life_val')))
    dog_obj = {
        'name': name,
        'd_type': d_type,
        'attack_val': attack_val,
        'life_val': life_val,
        'dog_attack':dog_attack
    }
    return dog_obj
d1 = get_dog('小黄狗', '恶霸犬', 800, 8000)
p1 = get_person('jason', 'male', 18, '猛男', 8000, 90000)
p1.get('person_attack')(p1, d1)

3.总结：
- 把人的数据和人的功能绑定在一起，只有人能调用人的功能
- 把狗的数据和狗的功能绑定在一起，只有狗能调用狗的功能
综上：我们将数据和功能绑定在一起的操作，称之为"面向对象编程"
面向对象编程的本质：将特定的数据和特定的功能绑定在一起，只有彼此之间可以相互使用

二：编程思想

1.面向过程

过程就是流程，按照流程，有步骤地书写代码，最终得到想要的结果
eg:注册功能，登录功能，转账功能等

2.面向对象

对象其实就是一个含有绑定的数据和功能关系的容器
eg:游戏角色

3.总结：

1.面向过程：让你给出一个解决问题的具体方案
2.面向对象：让你创造除一个可以操作的事物即可

三：对象与类

1.对象：
- 概念：数据和功能的结合体
- 功能：用来记录多个对象不同的数据和功能
2.类：
- 概念：多个对象相同的数据和功能的结合体
- 功能：用来记录多个对象相同的数据和功能

四：对象与类的创建过程

前提：在编程的世界里，先有类，再产生对象

1.类的语法：

class 类名:  # 类名推荐书写方式：首字母大写
    共有的数据
    共有的功能

2.类的特点：

类在定义阶段就被执行了

3.类中的一些初步方法：

1.查看名称空间的方法：print(Student.__ dict__) 结果是一个字典
2.使用字典的取值方式获取值的方法：print(Student.__ dict __ [‘school’]) print(Student.__ dict__ .get(‘choice_course’))

4.类中的一些简化方法：

采用句点符
1.print(Student.school)
2.print(Student.choice_course)

5.实例化对象类

方法：类名加括号
eg: stu1 = Student()

6.对象中的一些方法

1.对象调用类中的数据和功能

stu1 = Student()
stu2 = Student()
print(stu1.school)
print(stu2.school)
# print(stu1)  # <__main__.Student object at 0x000001D923B04A60>
# print(stu2)  # <__main__.Student object at 0x0000025E8A48F130>
# print(stu1.__dict__, stu2.__dict__)  # {} {}
# print(stu1.school)
# print(stu2.school)
# print(stu1.choice_course)
# print(stu2.choice_course)
Student.school = '北京大学'  # 修改school键对应的值
print(stu1.school)
print(stu2.school)

五：对象的独有数据

# 学生类
# class Student:
#     # 学生对象公共的数据
#     school = '清华大学'
#
#     # 学生对象公共的方法
#     def choice_course(self):
#         print('正在选课')

'''推导思路1:  直接利用__dict__方法朝字典添加键值对'''
# obj1 = Student()
# obj1.__dict__['name'] = 'jason'  # 等价于 obj1.name = 'jason'
# obj1.__dict__['age'] = 18  # 等价于 obj1.age = 18
# obj1.__dict__['gender'] = 'male'  # ...
# print(obj1.name)
# print(obj1.age)
# print(obj1.gender)
# print(obj1.school)
# obj2 = Student()
# obj2.__dict__['name'] = 'kevin'
# obj2.__dict__['age'] = 28
# obj2.__dict__['gender'] = 'female'
# print(obj2.name)
# print(obj2.age)
# print(obj2.gender)
# print(obj2.school)
'''推导思路2: 将添加独有数据的代码封装成函数'''
# def init(obj,name,age,gender):
#     obj.__dict__['name'] = name
#     obj.__dict__['age'] = age
#     obj.__dict__['gender'] = gender
# stu1 = Student()
# stu2 = Student()
# init(stu1,'jason',18,'male')
# init(stu2, 'kevin',28,'female')
# print(stu1.__dict__)
# print(stu2.__dict__)
'''推导思路3: init函数是专用给学生对象创建独有的数据 其他对象不能调用>>>:面向对象思想   将数据和功能整合到一起
将函数封装到学生类中 这样只有学生类产生的对象才有资格访问
'''


class Student:
    """
    1.先产生一个空对象
    2.自动调用类里面的__init__方法 将产生的空对象当成第一个参数传入
    3.将产生的对象返回出去
    """
    def __init__(self, name, age, gender):
        self.name = name  # obj.__dict__['name'] = name
        self.age = age  # obj.__dict__['age'] = age
        self.gender = gender  # obj.__dict__['gender'] = gender
        # 左右两边的名字虽然一样 但是意思不一样 左边的其实是字典的键 右边的其实是实参

    # 学生对象公共的数据
    school = '清华大学'

    # 学生对象公共的方法
    def choice_course(self):
        print('正在选课')


# stu1 = Student()
# print(stu1.__dict__)
# Student.init(stu1, 'jason', 18, 'male')
# print(stu1.__dict__)
# print(stu1.name)

stu1 = Student('jason', 18, 'male')
print(stu1)
stu2 = Student('kevin', 28, 'female')
print(stu2)

六：自我练习

class Student:
    school = 'oldboy'
    teacher = 'jason'

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

    def learn(self):
        print(f'学生:{self.name}在:{self.school}学校学的:{self.teacher}老师的课程是:{self.course}')


stu1 = Student('达夫', 'python全栈开发')
# stu1.learn()  # 学生:达夫在:oldboy学校学的:jason老师的课程是:python全栈开发

# stu1.age = 19
# print(stu1.__dict__)  # {'name': '达夫', 'course': 'python全栈开发', 'age': 19}

Student.school = 'shanghai'
print(Student.__dict__.get('school'))  # shanghai