Python 类、对象、方法、面向对象的特征

编程语言的发展：机器语言 → 汇编语言 → 高级语言 → 面向对象的语言

类

对具有相同属性和方法的抽象

#创建类
class 类名():
    类体(属性和方法)
# 子类也叫 派生类；父类也叫 超类 或 基类

类与类的关系：继承 关联（组合，聚合） 依赖
# 关联（组合，聚合）：一个类的对象作为另一个类的属性 这样两个类的关系叫关联关系
# 依赖：一个类的对象作为另一个类的方法的参数
耦合程度：继承>关联>依赖（一般是 高内聚 低耦合 进行编程）

对象

具有属性和方法的实物 (万事万物皆对象)

   #创建对象
    引用(变量) = 类名()
    __init__(self) 构造函数

方法

方法可分为三种：类方法(两种：解释器 静态方法) 对象方法
静态方法：

class person():
    def __init__(self,name,age,sex,heigth):
        self.name = name
        self.age = age
        self.sex = sex
        self.heigth = heigth
    @staticmethod
    def run():
        print("跑步")
p = person("李宏宇",18,"男",180)
person.run()

对象方法：必须通过对象调用的方法

class person():
    def __init__(self,name,age,sex,heigth):
        self.name = name
        self.age = age
        self.sex = sex
        self.heigth = heigth
    def say(self):
        print(self.name,self.age,self.sex,self.heigth,"hello")
p = person("李宏宇",18,"男",180)
#调用对象方法
p.say()

注：
__init__构造函数
self是即将要出现的那个对象，临时指向新创建的对象

面向对象的特征：继承、封装、多态

继承：减少代码量，耦合程度太高

#任何类都可以被继承，默认继承object类
class A(object):
    pass
class B(A):
    pass

class animal():

    def __init__(self,name,weight,age):
        self.name = name
        self.weight = weight
        self.age = age

    def eat(self):
        print("吃饭")
        
    def run(self):
        print("跑步")
        
    def sleep(self):
        print("睡觉")
        
class cat(animal):

    def __init__(self):    #构造函数：没有显示声明，系统会默认提供一个
        super().__init__("小花",2,2)    #子类使用父类属性时，必须手动调用父类构造函数 super()
    pass

注：当父类方法不能满足子类需求时，可进行重写和覆盖（子类覆盖父类，与参数个数无关）

多继承：

class father0():
    pass
class father1():
    pass
class father2():
    pass
class son(father0,father1,father2):
    pass

注：继承关系从左到右，一层一层寻找，整体深度优先 局部广度优先（有菱型结构），若没有找到会报错

多态：多种形态（继承中的重写和覆盖）

class animal():
    def eat(self):
        print("吃饭")
class person(animal):
    def eat(self):
        print("吃大米饭")
class dog(animal):
    def eat(self):
        print("吃骨头")
class cat(animal):
    def eat(self):
        print("吃鱼")
p = person()
d = dog()
c = cat()
p.eat()
d.eat()
c.eat()
#创建不同子类的对象，调用相同的方法，但显示的结果不一样，这就是多态

封装：将属性私有化

class  A():
    __name = "张三"        
    def __a():       
        pass
#在属性前面加__以达到封装效果（并不是封装的很好）
#原理：是一种变形，如果调用_A__name还是可以使用的