《0037》第三章 Python编程进阶：面向对象2

1、面向对象三大特征：封装  继承  多态

2、封装

属性和函数 封装在抽象类中

使用方法：
对象名.函数()
对象名.属性

3、继承

a.多个类之间的继承  子类可以继承父类的方法和属性(实现了代码的重用)

b.扩展一下专业的术语

Dog类是Animal类的子类、Animal类是Dog类的父类、Dog类从Animal类进行了继承
Dog类是Animal类的派生类、Animal类是Dog类的基类、Dog类从Animal类进行了派生

c.演练一下：两个类(动物类和狗类)

   动物类方法：吃睡
   狗类方法：吃睡跑

class Animal:
　　def eat(self):
　　　　print('动物有吃的功能')
　　def sleep(self):
　　　　print('动物有睡的功能')
class Dog(Animal):
　　def run(self):
　　　　print('狗有跑的功能')
erha=Dog()
erha.eat()
erha.sleep()
erha.run()

输出结果：
动物有吃的功能
动物有睡的功能
狗有跑的功能

 

d.单继承可以一直继承下去代代相传

　　class Animal:
　　　　def eat(self):
　　　　　　print('吃')
　　　　def sleep(self):
　　　　　　print('睡')
　　class Dog(Animal):
　　　　def run(self):
　　　　　　print('跑')
　　class GodDog(Dog):
　　　　def fly(self):
　　　　　　print('飞')
　　xtq=GodDog()
　　xtq.fly()
　　xtq.run()
　　xtq.eat()
　　xtq.sleep()

输出结果：
飞
跑
吃
睡

e.子类只能继承父类，无法继承父级下的同级子类

　　　　class Animal:
　　　　　　def eat(self):
　　　　　　　　print('吃')
　　　　　　def sleep(self):
　　　　　　　　print('睡')
　　　　class Dog(Animal):
　　　　　　def run(self):
　　　　　　　　print('跑')
　　　　class CommonDog(Dog):
　　　　　　def catch(self):
　　　　　　　　print('抓老鼠')
　　　　class GodDog(Dog):
　　　　　　def fly(self):
　　　　　　　　print('飞')
　　　　xtq=GodDog()
　　　　xtq.catch()

　　　　输出结果：AttributeError: 'GodDog' object has no attribute 'catch'

f.多继承：class  类名(父类,父类)

　　　　class A:
　　　　　　def demoA(self):
　　　　　　　　print('DemoA的方法')
　　　　class B:
　　　　　　def demob(self):
　　　　　　　　print('Demob的方法')
　　　　class C(A,B):
　　　　　　pass

　　　　c=C()
　　　　c.demoA()
　　　　c.demob()

　　　　输出结果：
　　　　DemoA的方法
　　　　Demob的方法

g.结论：如果一个类继承多个父类优先会继承第一个类的属性和方法

　　　　class Master:
　　　　　　def __init__(self):
　　　　　　　　self.formula = '师傅的蛋糕配方'
　　　　　　def make_cake(self):
　　　　　　　　print(f'使用{self.formula}制作蛋糕技术')

　　　　class School:
　　　　　　def __init__(self):
　　　　　　　　self.formula = '学校的蛋糕配方'
　　　　　　def make_cake(self):
　　　　　　　　print(f'使用{self.formula}制作蛋糕技术')

　　　　class apprentice(School,Master):
　　　　　　pass

　　　　xiaoming = apprentice()
　　　　xiaoming.make_cake()

　　　　输出结果：使用学校的蛋糕配方制作蛋糕技术

h.子类的重写:父类的方法不能满足子类的需求的时候，就会用到重写。结论：子类和父类有同名的方法和属性，会覆盖父类的方法属性和方法

　　　　class Master:
　　　　　　def __init__(self):
　　　　　　　　self.formula = '师傅的蛋糕配方'
　　　　　　def make_cake(self):
　　　　　　　　print(f'使用{self.formula}制作蛋糕技术')

 

　　　　class School:
　　　　　　def __init__(self):
　　　　　　　　self.formula = '学校的蛋糕配方'
　　　　　　def make_cake(self):
　　　　　　　　print(f'使用{self.formula}制作蛋糕技术')

 

　　　　class apprentice(School,Master):
　　　　　　def __init__(self):
　　　　　　　　self.formula='自己独创的蛋糕配方'
　　　　　　def make_cake(self):
　　　　　　　　print(f'使用{self.formula}制作蛋糕技术')

 

　　　　　　xiaoming=apprentice()
　　　　　　xiaoming.make_cake()

输出结果：使用独创的蛋糕配方制作蛋糕技术

 

i.super()：指向的是父类，拿到父类的属性和方法

class Master:
　　def __init__(self):
　　　　self.formula = '师傅的蛋糕配方'
　　def make_cake(self):
　　　　print(f'使用{self.formula}制作蛋糕技术')

class School(Master):
　　def __init__(self):
　　　　self.formula = '学校的蛋糕配方'
　　def make_cake(self):
　　　　print(f'使用{self.formula}制作蛋糕技术')
　　　　super(School, self).__init__()
　　　　super(School, self).make_cake()

class apprentice(School):
　　def __init__(self):
　　　　self.formula='自己独创的蛋糕配方'
　　def make_cake(self):
　　　　print(f'使用{self.formula}制作蛋糕技术')
　　　　super().__init__()
　　　　super(apprentice, self).make_cake() # 换这样写也行：super().make_cake()

xiaoming=apprentice()
xiaoming.make_cake()

输出结果：
使用独创的蛋糕配方制作蛋糕技术
使用学校的蛋糕配方制作蛋糕技术
使用师傅的蛋糕配方制作蛋糕技术

j.总结继承

1.子类继承父类后，子类拥有父类的方法和属性
2.子类可以重写父类的方法和属性，重写之后子类就覆盖了父类的方法和属性
3.子类调用父类的方法和属性，用super()方法

4、私有属性（了解）

a.定义：属性或者方法前面加个__

b.内部类和外部类：访问公有方法和私有属性、私有方法

公有方法：内部类和外部类都可以访问
私有属性：内部类和外部类都不能访问
私有方法：内部类和外部类都不能访问

class Girl:
　　def __init__(self,name):
　　　　self.name=name
　　　　self.__age=18
　　def desc(self):
　　　　print('大家好，我是{},年龄{}'.format(self.name,self.__age))
　　def __desc(self):
　　　　print('大家好，我是{},年龄{}'.format(self.name,self.__age))

 

class FatGirl(Girl):
　　def fgirl(self):
　　　　print('大家好，我是:{},年龄{}'.format(self.name, self.__age))

 

xiaoli=Girl('小丽')
xiaohua=FatGirl('小花')
print(xiaoli)
print(xiaohua)
# 公有方法：内部类和外部类都可以访问
xiaoli.desc()
xiaohua.desc()
# 私有属性：内部类和外部类都不能访问
xiaoli.__age
xiaohua.__age
# 私有方法：内部类和外部类都不能访问
xiaoli.__desc()
xiaohua.__desc()

输出结果：
<__main__.Girl object at 0x108630c10>
<__main__.FatGirl object at 0x108653970>
大家好，我是小丽,年龄18
大家好，我是小花,年龄18
AttributeError: 'FatGirl' object has no attribute '__age'
AttributeError: 'Girl' object has no attribute '__desc'

 

c.外部方法调用内部方法：访问私有属性无法访问

class Girl:
　　def __init__(self,name):
　　　　self.name=name
　　　　self.__age=18

class FatGirl(Girl):
　　def fgirl(self):
　　　　print('大家好，我是:{},年龄{}'.format(self.name, self.__age))

xiaohua=FatGirl('小花')
# 外部方法调用内部方法：访问私有属性无法访问
xiaohua.fgirl()

输出结果：AttributeError: 'FatGirl' object has no attribute '_FatGirl__age'

d.扩展：伪私有(并没有真意义上的私有 解决方案：_类名__名称)

私有属性：内部类和外部类都可以访问
私有方法：内部类和外部类都可以访问
　　class Girl:
　　　　def __init__(self,name):
　　　　　　self.name=name
　　　　　　self.__age=18
　　　　def __desc(self):
　　　　　　print('大家好，我是{},年龄{}'.format(self.name,self.__age))

class FatGirl(Girl):
　　def fgirl(self):
　　　　print('大家好，我是:{},年龄{}'.format(self.name, self.__age))

# 扩展：伪私有,并没有真意义上的私有 解决方案：_类名__名称
g=Girl('小花')
l=FatGirl('小李')
# 私有属性：内部类和外部类都可以访问
print(g._Girl__age)
print(l._Girl__age)
# 私有方法：内部类和外部类都可以访问
g._Girl__desc()
l._Girl__desc()

输出结果：
18
18
大家好，我是小花,年龄18
大家好，我是小李,年龄18

5、多态(了解)

a.定义：子类重写父类的方法，调用不同子类对象的相同父类方法，产生不同结果

b.示例一

class Dog:
　　def __init__(self,name):
　　　　self.name=name
　　def work(self):
　　　　print('看守家门')

 

class BigDog(Dog):
　　def work(self):
　　　　print('赴缉毒')

 

class PuppyDog(Dog):
　　def work(self):
　　　　print('抓小偷')
class Person:
　　def with_dog(self,obj):
　　　　print('警员和%s一起去干什么:'%(obj.name))
　　obj.work()

 

big=BigDog('大狗')
puppy=PuppyDog('小狗')

 

p=Person()
p.with_dog(puppy)
p.with_dog(big)

输出结果：
警员和小狗一起去干什么:
抓小偷
警员和大狗一起去干什么:
赴缉毒

 

c.示例二

class Duck:
　　def fly(self):
　　　　print('鸭子会飞')
class Swan:
　　def fly(self):
　　　　print('天鹅会飞')
class Plan:
　　def fly(self):
　　　　print('飞机会飞')

 

def fly(a):
a.fly()

 

d=Duck()
fly(d)
s=Swan()
fly(s)
p=Plan()
fly(p)

输出结果：
鸭子会飞
天鹅会飞
飞机会飞