python--面向对象组合

面向对象的命名空间  

类中的方法
   类中的静态属性
   对象的属性
类的组合应用

面向对象的命名空间

 

class A:
     country='中国'
a=A()
a.name='alex'
print(a.name)      #结果是alex  想要添加属性可以这么添加
b=A()
print(b.name)       #结果是没有name的属性

对象中有地址簿来调用类的方法，表现内存不同，不过实际调用内存相同
对象和类调用动态属性表现的地址不一样，实际一样
静态属性完全一样地址

class A:
     country='印度'
a=A()
b=A()
a.country='中国'
print(a.country)    #中国
print(A.country)    #印度
print(b.country)    #印度

对于关于类的静态属性：
    如果类.属性 调用的就是类中的属性
 对象.属性  先从自己的内存空间找名字，找到了用自己的，没找到就用类的，类里没有报错
 关于类的动态属性：
 这个方法本事就存在类中，并不会存在对象的内存中
 在对象调用类中的方法的时候，要依赖于一个地址簿，去类中寻找对应的方法
 关于对象的属性
 对象的属性就存在对象的命名空间中
 只能被对象调用、修改
 不能被类调用   

面向对象组合 

一个对象的属性是另一个对象
 可以做到解耦，可以用其他对象做属性
 什么有什么的关系
命名空间
类的命名空间和对象的命名空间是分开的，且每个对象都有独立的命名空间，公用一个类的命名空间
继承：
继承是一种新的语法，是类中提供的一种新语法
面向对象三大特性：封装、继承、多态
封装：类里面的属性，其他类或东西没法用
继承：什么是什么的关系

class Animal:        #父类，超类
    def eat(self):
        print('eating')
    def drink(self):
        print('drinking')
    def sleep(self):
        print('sleeping')
class Dog(Animal):  #子类，派生类  继承方法类加括号后面放继承了谁
    pass
class Cat(Animal):  #子类，派生类
    pass

抽象从小的范围往大的范围走
继承是从大的范围往小的范围走

class Dog(Animal,Bnimal):  #可以继承多个
       pass
class Animal:
    def eat(self):
        print('eating%s'% self.food)  #self谁调用就是谁
    def drink(self):
        print('drinking')
    def sleep(self):
        print('sleeping')
class Dog(Animal):
    print('旺旺旺')
class Cat(Animal):
    print('喵喵喵')

w=Dog()
c=Cat()
w.food='狗粮'   #所以可以这么用创建一个food
w.eat()      #然后eat里面的self.food就是调用的那个

 父类子类都有__init__的话，先调用自己的
 想要调用父类__init__的话，用super方法，参数直接传，不用写self
 super().__init__()
 super就是执行父类
 类外面执行的话super()默认不调自己的，调父类的括号前面是类名，后面对象
 如果继承多个类，就找能找到的第一个父类里面的方法

 class A:
    def hahaha(self):
        print('A')
class C:
    def hahaha(self):
        print('C')
class B(A,C):
    def hahaha(self):
     C.__init__(self,name)        #经典类调用父类中方法的方式
        super().hahaha()             #新式类
        print('B')

b=B()
b.hahaha()
super(B,b).hahaha()

在继承中
子类可以继承父类的所有属性和方法
但是  当父类和子类中有同名方法的时候 一定调用子类的
如果想使用父类该方法的功能，需要借助super方法4
对象可以调用自己本类和父类的所有方法和属性，先调用自己的，自己没有才调父类的
谁(对象)调用方法，方法中的self就指向谁
例子

class Dong:
    def __init__(self,name,food):
        self.name=name
        self.food=food
        self.family='地上'
    def eat(self):
        print('eat')
    def drink(self):
        print('drink')
    def sleep(self):
        print('sleep')
    def say(self):
        print('say')

class Dog(Dong):
    def __init__(self,name,food):
        super().__init__(name, food)
    def swim(self):
        print('%sswim,吃%s,住%s'%(self.name,self.food,self.family))
class Bird(Dong):
    def __init__(self,name,food):
        super().__init__(name, food)
        self.family = '天上'
    def fly(self):
        print('%sfly,吃%s,住在%s'%(self.name,self.food,self.family))
wangcai=Dog('旺财','狗粮')
bage=Bird('八哥','花籽')
wangcai.swim()
bage.fly()

例子2：

class Shuxing:
    def __init__(self,name,blood,aggr):
        self.name=name
        self.blood=blood
        self.aggr=aggr
class Person(Shuxing):
    def __init__(self,name,blood,aggr,qian):
        super().__init__(name,blood,aggr)
        self.qian=qian               派生属性
    def attack(self,dog):             派生方法
        print('%s攻击了%s'%(self.name,dog.name))
        dog.blood-=self.aggr
class Dog(Shuxing):
    def __init__(self,name,blood,aggr,pz):
        super().__init__(name,blood,aggr)
        self.pinzhong=pz             派生属性
    def attack(self,person):          派生方法
        print('%s攻击了%s'%(self.name,person.name))
        person.blood -= self.aggr
        print(person.blood)
haijiao=Person('ren',2000,100,200)
jifao=Dog('fd',50000,200,'金毛')
haijiao.attack(jifao)
jifao.attack(haijiao)