面向对象----对象的组合和

对象的组合就是互可以互相调用创建对象类中的方法

对象的组合：就是一个对象的属性值是另外一个类的对象

一个类的对象作为另一个类对象的属性（就是把一个对象传递进一个类中当作参数 并且这个参数可以传递给对象的 ，一般是直接定义给init，因为init方法的属性是直接可以给对象的，如果定义在其他地方也需要用self来接收）

组合就是让两个类有可以起到关联 可以使用被调用对象的创建类中的方法，组合有两种，一种是在外部创建了对象 然后把你要调用的对象以参数的形式给传递进要调用者，也可以指着把对象定义在类内部就是直接把得到的对象传递进init方法中

组合的练习：

做一个人狗大战但是可以购买装备的程序：

class Person(object):
    def __init__(self,name,sex, hp, ad):
        self.name = name
        self.sex = sex
        self.hp = hp
        self.ad = ad
        self.money = 0  #定义一个默认的属性钱数
    #再定义一个人攻击狗的方法
    def attack(self,d):
        d.hp -= self.ad  #被攻击者的血等于攻击者的攻击力
        print('{}攻击了{},{}掉了{}血'.format(self.name,d.name, d.name,self.ad))

        #人想要攻击其他的事物也可以装备物品来攻击 这样就选哟定义一个装备物品的方法
    def wear(self,weapon):
        # self.weapon = weapon
        if self.money >= weapon.price :  #你要先判断一下您的钱数是不是可以足够购买
            self.weapon = weapon
            #您这是装备一个武器 但是武器是有价格的所以您需要把您的钱数减去武器的价格
            self.money -= self.weapon.price
            print('购买成功 您已经装备成功')
        else:
            print('余额不足请充值')

    #装备后你要拿着你装备后的武器去进攻你所要进攻的物品
    def attack_with_weapon(self,dog):
        if 'weapon' in self.__dict__:  #判断你的weapon是不是已经被接收了 定义为自己本身的
            self.weapon.skill(dog) #调用你所组合类的对象的方法
        else :
            print('清先装备武器')


        #你要装备一个装备 但是不能平白无故的装备啊 你必须要进行充值的
    def pay(self):
        money = int(input('请输入您要输入的金额'))
        self.money +=money #本身的钱  一直加上您充值进来的钱
        print('您的余额是%s'%self.money)




class Dog(object):
    def __init__(self, name, kind, hp, ad): #定义一个类的初始化方法
        self.name =name
        self.kind = kind
        self.hp = hp
        self.ad = ad
    def attack1(self, p):  #定义一个狗攻击人的类
        p.hp -= self.ad
        print('{}攻击了{}，{}掉了{}血'.format(self.name, p.name,p.name, self.ad))




#定义一个工具类 因为游戏里人是可以装备工具用来攻击其他事物的
class weapon(object):
    def __init__(self,name,price, ad, level):
        self.name = name
        self.price =price
        self.ad =ad
        self.level = level
    def skill(self,dog):
        dog.hp -=self.ad
        print('{}攻击了{}，{}掉了{}血'.format(self.name, dog.name, dog.name, self.ad))

#实例化你所创建的类的对象
alex = Person('老王', '男', 100, 30)
tendy = Dog('本本', 'teddy', 150,150)
futou = weapon('斧头', 1000, 100,1)


lst = ['攻击','充值','装备武器','使用武器攻击']
while True:
    for index, value in enumerate(lst,1):
        num = int(input('请输入您要选择的序列号'))
        if num == 1 :
            alex.attack(tendy) #让人去攻击狗
        elif num == 2 :
            alex.pay()
        elif num ==3:
            alex.wear(futou)
        elif num ==4 :
            alex.attack_with_weapon(tendy)
        else :
            print('序列号有误')

面向对象求一个圆形的面积的程序 需要用到对象的组合

from math import pi
class Ring(object):
    def __init__(self, r):
        self.r = r
    def mianji(self):  #求取的是面积
        return pi*self.r**2  
    def zhouchang(self):  #求取的是周长
        return pi*self.r*2
class Ring2(object):
    def __init__(self,our_r, in_r):
        # 创建两个对象因为你是传递进来了两个参数
        self.Ring = Ring(our_r)   #外环
        self.Ring2 = Ring(in_r) #内环

    def Area(self):
        return self.Ring.mianji() - self.Ring2.mianji()  #大圆的面积减去小圆的面积 就是圆形的面积
    def cal_perimeter(self):
        return self.Ring.zhouchang() + self.Ring2.zhouchang()  #大圆的周长加上小圆的周长



r1 = Ring2(10,5)
print(r1.Area())
print(r1.cal_perimeter())

class Clas:
    def __init__(self,name, num , course, type):
        self.name =name
        self.num = num
        self.course = course
        self.type = type

class Teacher(object):
    def __init__(self,name,sex,age, py11):  # 把创建的的对象以一个参数的形式传递进去
        self.name = name
        self.sex = sex
        self.age = age
        self.py11 = py11
py11 = Clas('超级无敌s11',89,'python','脱产全栈') #创建一个Clas的对象
print(py11.course)
boss_jin = Teacher('太白', '?', 40,py11)
print(boss_jin.py11.course)  #因为你建立的对象以参数的形式传递进了另一个类中 并且还定义了一个自己的参数接收所以 自己本身的参数就相当于你定义的对象
print(boss_jin.py11.name)
print(boss_jin.py11.num)

 

 

 

继承

方法的继承：和Java的继承理念一样只不过python比Java简单  就是在子类后面加上（）括号里面写上要继承的父类的名字即可

         Class a ：

                   Pass

Class b（a）：

这就是代表类b继承了类a 就可以使用a类中的所有方法 并且可以调用

a中的所有方法

继承 只需要在一个类后面加上（）在括号中写入要继承的父类的名字即可

可以是多次继承  b继承a，如果 c再继承b那么 c也可以调用a中的内容

继承

所有的继承都差不多  字类继承父类可以调用父类中的方法

# 父类 ：基类 超类
# 子类 ：派生类

父类中没有的属性 在子类中出现 叫做派生属性

父类中没有的方法 在子类中出现 叫做派生方法
只要是子类的对象调用，子类中有的名字 一定用子类的，子类中没有才找父类的，如果父类也没有报错
如果父类 子类都有 用子类的

 

在python3中，所有的类都会默认继承object类
继承了object类的所有类都是新式类
如果一个类没有继承任何父类，那么__bases__属性就会显示<class 'object'>

我们可以运用方法__bases__来查找当前类继承的类  你用当前类所创建的对象执行这个方法就可以得到这个对象对应的类 所继承的类

class Parent:pass
class Son(Parent):pass
print(Son.__bases__)

如果字类继承了父类那么字类就可以调用父类中的属性和方法  它的执行流程就是 ，当你字类调用父类的收你在字类的内存空间中生成了一个指针 这个指针会指向父类 但是这个指针是单向的就好比对象指向创建它的类

，这个时候字类就可以使用父类中的除了私有属性或者私有方法的所有内容，但是不可以对父类中的内存空间存储的内容进行修改只可以改变

继承中的派生方法就是你父类中没有的方法你在字类中重新创建的方法

class Animal(object): #定义一个动物类  
    role = "Animal"
    def __init__(self,name,hp,ad):
        self.name = name
        self.hp = hp
        self.ad = ad
    def eat(self):
        print('%s吃药回血了'%self.name)
class Person(Animal):
    r = 'Person'
    def attack(self, dog):
        print('%s攻击了%s'%(self.name,dog.name))
    def eat2(self):
        print('执行了Person类的eat方法')
        self.money = 100
        self.money -= 10
        self.hp += 10
class Dog(Animal):
    def bite(self,person):
        print('{}咬了{}'.format(self.name,person.name))


alex = Person('alex',10,5)
dog = Dog('teddy',100,20)
print(Person.__dict__)
print(Person.role)  #这个时候就可以调用父类中的属性了
print(alex.__dict__)

alex.eat2()
alex.eat()  #这个是执行父类中的方法
dog.eat()  #这个也是它的字类调用父类

来一个面试题：

class Parent:
    def func(self):
        print('in parent func')
    def __init__(self):
        self.func()
class Son(Parent):
    def func(self):
        print('in son func')
s = Son()  #结果是执行了字类中的方法   

上面的流程是：