第二十九章 面向对象（Python）

---

一、面向过程

面向过程编程（POP）：按照业务逻辑从上到下设计程序的方式。 特点： 用一长段代码来实现指定功能，一步接一步，环环相扣。 缺点： 但是大型项目，如果使用面向过程编程，则很容易导致代码结构过于紧密、耦合度高，易出现代码冗余，不利于并且团队开发。

二、面向对象

面向对象编程 (OOP）：将具有相关性的数据/行为封装成整体(对象)，以整体的角度来完成处理 特点： 将数据和业务抽象为对象，有利于程序整体结构的分析和设计，使设计思路更加清晰 业务以对象为单位，对象各自完成工作，减少了代码耦合度，有助于业务升级和代码重构 方便工作划分，有利于提高团队开发的效率。

1、对象

是记录数据，完成行为的一个具体"事物"。比如具体某一个人 对象的组成： 属性： 用于记录与对象相关的数据，比如姓名，年龄等 方法： 用于实现与对象相关的操作，比如吃饭，睡觉等。

2、类

类（class）：描述具有共同特征的事物的概念。物以类聚，人以群分。很多事物存在相同的操作/行为，比如人都进行吃饭、睡觉，狗都会跑会叫等等。

3、类与对象的关系

区分：类是总结事物特征的抽象概念，而对象是具体存在的实物某个。 关系：在编程中，类就是创建对象的制造手册，用来定义对象的行为。每个对象必须有一个对应的类。

'''
class 类名:
    方法列表
'''


class dog:
    def __init__(self, type):
        '''
        如何让创建出来的对象包含一些默认属性，并且有初始值？
        __init__()方法叫做对象的初始化方法，在创建一个对象后会被自动调用，不需要手动调用
        开发者可以实现init方法，并在该方法中定义属性并设置初始值

        自定义__init__()
        __init__(self)除了参数，还可以设置任意个数的自定义参数，例如self__init__(self,x,y,z)
        init方法设置的自定义参数必须和创建对象时传递的参数保持一致，例如tom = Cat(x,y,z)

        '''
        self.age = 1  # 设置默认值狗的年龄
        self.type = type

    def __str__(self):
        '''
        如果直接打印对象，会看到创建出来的对象在内存中的地址
        使用print输出对象的时候，只要对象定义了方法，就会打印该方法return的信息描述
        字符串符的返回值必须是字符串类型
        :return:
        '''
        return "名字是：%s，年龄是：%s" % (self.name, self.age)

    def eat(self):  # self对应的实参就是调用该方法的对象,self主要用于在方法中使用自己的属性和方法
        print("狗吃骨头，它的名字是：%s" % self.name)
        print("它的年龄是：%d" % self.age)
        print("它是：%s" % self.type)


dog1 = dog("小型犬")  # 创建对象,格式：引用对象的变量名 = 类名()
dog1.name = "来福"  # 定义属性，格式：引用对象的变量名.属性名 = 数据
print(dog1.name)
dog1.eat()  # 调用方法，格式：引用对象的变量名.方法名()
print(dog1)

'''
面向其对象： 搬家具
搬家具规则：

1.家具分不同的类型，并占用不同的面积
2.家具显示信息时，显示家具的类型和家具占用的面积
3.房子有自己的地址和占用的面积
4.房子可以添加家具，如果房子的剩余面积可以用着，则提示家具添加成功;否则提示添加失败
5.输出房子信息时，可以显示房子的地址、被面积、剩余面积
6.需求：输出房子时，显示包含的所有家具的类型
两个类：房子和家具

房子：
    属性：
        地址
        面积
    方法：
        添加家具
            可以添加家具，房子剩余面积
        不可以添加家具，提醒添加失败
家具：
    属性：
        家具的类型
        家具占用的面积
    方法：
'''


class home:
    def __init__(self, mj, symj):
        self.dz = "上海市"
        self.mj = mj
        self.symj = symj
        self.list = []

    def __str__(self):
        return "家庭地址：%s，家庭面积：%d，家庭剩余面积：%s，家具有：%s" % (self.dz, self.mj, self.symj, self.list)

    def addjj(self, jj):
        self.symj = self.symj - jj.jjmj
        if self.symj > 0:
            print("家具：%s添加成功,面积：%d！,房子剩余面积：%d" % (jj.jj_type, jj.jjmj, self.symj))
            self.list.append(jj.jj_type)
        else:
            print("添加失败！")


class jj:
    def __init__(self, jj_type, jjmj):
        self.jj_type = jj_type
        self.jjmj = jjmj

    def __str__(self):
        return "家具的类型：%s，家具面积：%d" % (self.jj_type, self.jjmj)


fz = home(1000, 1000)
bx = jj("冰箱", 100)
fz.addjj(bx)
print(fz)

class Animal:
    Animal_type = "动物"  # 类属性，类对象所拥有的属性，它被该类的所有实例对象所共有。类属性可以使用类对象或实例的访问,类属性也可以设置为私有，前边添加两个下划线

    def __init__(self):  # 父类中的私有方法、属性，不会被子类继承,可以通过调用继承的父类的共有方法，间接的访问父类的私有方法、属性
        self.__name = "犬"
        self.height = 100

    def __ss(self):
        print("死")

    def eat(self):
        print("吃东西")
        self.__ss()  # 可以通过调用继承的父类的共有方法，间接的访问父类的私有方法
        print(self.__name)

    # 类方法，用classmethod来进行修饰,对象方法必须有实例对象才能调用,而类方法可以用类对象/实例对象 来调用
    @classmethod  # 可以在没有实例对象的，完成类属性的处理
    def get_type(cls):
        return cls.Animal_type

    # 静态方法，取消不需要参数的传递，有利于减少不必要的内存占用和性能消耗
    @staticmethod
    def introduce():  # 静态方法不会自动传递实例对象和类对象,静态方法 也能够通过实例对象和类对象去访问。
        print("犬科哺乳动物,属于食肉目..")


class work:
    def run(self):
        print("跑")


class Dog(Animal, work):  # 继承类Animal所有的属性和方法,多继承Animal和work
    def __init__(self):  # 可以认为是重写父类__init__方法
        self.__baby_count = 0
        super().__init__()  # 调用父类属性

    def __str__(self):
        return "我有%d个崽儿" % self.__baby_count

    def birth(self):
        """生育"""
        print("生了一个崽儿")
        print(self.height)
        self.__baby_count += 1
        self.__leave()

    def __leave(self):
        """产假"""
        print("休3个月产假")

    def run(self):
        print("使劲跑")
    # def eat(self):  # 当子类实现一个和父类同名的方法时，叫做重写父类方法，子类重写了父类方法，子类再调用该方法将不会执行父类的处理
    #     print("使劲吃")
    #     super().eat()  # 最好用的,子类重写了父类方法，仍然想执行父类中的方法，则可以在类中使用来调用方法super（）


class tuzi(Animal):  ## 在不改变原run方法的情况下, 让不同动物做不同的动作
    def run(self):
        print("跳")


dog1 = Dog()  # dog1,通过类创建的对象 又称为实例对象，对象属性又实例属性，记录对象各自的数据，不同对象的同名实例属性，记录的数据可能各不相同
dog1.eat()
dog1.run()
# dog1.__ss()# 父类中的私有方法无法被继承
# print(dog1.__baby_count)  #错误无法通过对象直接调用私有属性
# dog1.__leave()    # 无法通过对象直接调用私有方法

'''
私有方法和私有属性只能通过类的内部间接调用，比如brith方法，而无法直接用类的对象直接调用。
'''

dog1.birth()
print(dog1)

tz = tuzi()
tz.run()

print(Animal.Animal_type)  # 类属性可以使用类对象或实例的访问

print(Animal.get_type())  # 类方法可以直接用类对象调用
d = Animal()
print(d.get_type())  # 也可以用实列对象调用

Animal.introduce()
d1 = Animal()
d1.introduce()