[python]（8）----面向对象和过程

1，面向过程和面向对象
class 类名():
类体（属性和方法）
面向过程
自上而下顺序执行，逐步求精；
其程序结构是按功能划分为若干个基本模块，这些模块形成一个树状结构；
各模块之间的关系尽可能简单，在功能上相对独立；
每一模块内部均是由顺序、选择和循环三种基本结构组成；
其模块化实现的具体方法是使用子程序。
程序流程在写程序时就已决定。

面向对象
把数据及对数据的操作方法放在一起，作为一个相互依存的整体——对象。
对同类对象抽象出其共性，形成类。
类中的大多数数据，只能用本类的方法进行处理。
类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信
程序流程由用户在使用中决定。
2，创建对象
引用（变量） = 类名()
init(self) 构造函数
3，方法： 类方法 对象方法
4，面向对象的三大特性：
**继承类：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
**封装:**将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体（即类）；封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。
**多态:**多态指的是一类事物有多种形态——如：动物有多种形态：人、狗、猪。

class 子类/派生类（父类/超类/基类）：

   class A(object):
       def a():
           pass
       pass
   class B():
       def b():
           pass
       pass
   class C()
      class D(A,B,C):
       def b():

从左到右，整体深度优先 局部广度优先（有菱形结构）

覆盖/重写
多态： 多种形态 :继承-重写
类与类之间的关系： 继承 关联（组合，聚合） 依赖
关联： 一个类的对象作为另一个类的属性
依赖: 一个类的对象作为另一个类的方法的参数
耦合程度： 继承>关联>依赖
代码复用/减少代码冗余

class A():
    def a(self,name):
        print(name)

class B(A):
    def a(self):            #方法重写
        print("子类a方法")

b = B()
b.a("hj")

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 student():
    def __init__(self,name):
        self.name = name
    def study(self):
        print("我爱python")
class teacher():
    def __init__(self,stu):
        self.stu = stu
    def teach(self):
        print("教%spython"%self.stu.name)
s = student("曹阳")
t = teacher(s)
t.teach()

依赖关系

class student():
    def __init__(self,name):
        self.name = name
    def study(self):
        print("我爱python")
class teacher():
    def teach(self,stu):
        print("教%spython"%stu.name)
s = student("曹阳")
t = teacher()
t.teach(s)

class A():
    name = "张三"     #类属性
    def __init__(self,age):
        self.age = age      #对象属性
    @staticmethod
    def a():
        print("类方法-静态方法")

    def aa(self):
        print("对象方法")
print(A.name)
A.a()
a = A(18)
print(a.age)
a.aa()

封装

class A():
    __name = "张三"     #类属性  _A__name
    def __init__(self,age):     #slef._A__age
        self.__age = age      #对象属性
    @staticmethod
    def __a():              #_A__a()
        print("类方法-静态方法",A.__name__)

    def aa(self):           #slef._A__aa()
        print("对象方法")
    def get_name(self):
        return self.__name
    def set_age(self,age):
        if age>150 or age < 0:
            print("非法年龄")
        else:
            self.__age = age
    @staticmethod
    def get_name():
        return A.__name
    @staticmethod
    def set_name(name):
        if isinstance(name,str):
            A.__name = name
        else:
            raise TypeError("类型错误,非str类型不能赋值")

A.set_name(12)
print(A.get_name())

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

    def a(self):
        print("我是a")

    def _b(self):
        print("我是_b")

    def __c(self):#私有的
        print("我是__b")
    def __eq__(self, other):
        return self.name == other.name
#print(dir(object))#打印方法
#print(isinstance(a,A))
#print(issubclass(B,A))             #是否x是x的子类
a1 = A("zs")
a2 = A("zs")
#print(a1==a2)#比较地址是否相等用==
print(a1.__eq__(a2))#比较值是否相等