# oop三大特征：封装，继承，多态
# # # 封装：指的是把内容封装到某个地方，便于后面使用
# # # 需要：把内容封装到某个地方
# # # 从另外处调用封装的内容
# # # 对于封装来说，就是使用初始化构造方法将内容封装到对象中，然后通过对象直接或者self
# # # 来获取被封装的内容
# # #
# # # 继承：子继承父的内容【属性和行为】（父亲有的，儿子都有；相反儿子有的，父亲不一定有）
class Animal:
def eat(self):
pass
def drink(self):
pass
class Dog(Animal):#继承
def wwj(self):
print('小狗汪汪叫')
pass
class Cat(Animal):
def mmj(self):
print('小猫喵喵叫')
pass
d1=Dog()
d1.eat()
c1=Cat()
c1.drink()
c1.mmj()
d1.wwj()
#多继承
class ShenXian:
def fly(self):
print('神仙会飞')
pass
class Monkey:
def chitao(self):
print('猴子喜欢吃桃')
class SunWuKong(ShenXian,Monkey):
pass
rs=SunWuKong()
rs.fly()
rs.chitao()
#问题是当多个父类当中存在相同的方法时，应该去调用哪一个类
class D(object):
def eat(self):
print('D.eat')
class C(D):
def eat(self):
print('c.eat')
class B(D):
def eat(self):
print('b.eat')
pass
class A(B,C):
pass
a=A()
a.eat()
print(A.__mro__)
class GrandFather():
def eat(self):
print('吃的方法')
class Fater(GrandFather):
def eat(self):
print('父亲经常吃海鲜')#相当方法重写了
pass
class Son(Fater):
pass
son=Son()
print(Son.__mro__)
son.eat()#此方法 是从爷爷继承过来的
神仙会飞
猴子喜欢吃桃
b.eat
(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)
(<class '__main__.Son'>, <class '__main__.Fater'>, <class '__main__.GrandFather'>, <class 'object'>)
父亲经常吃海鲜
class Dog:
def __init__(self,name,color):
self.name=name
self.color=color
def bark(self):
print('汪汪叫----')
pass
class kejiquan(Dog):
def __init__(self,name,color):#重写父类的方法
# Dog.__init__(self,name,color)#调用父类的方法，手动调用
super().__init__(name,color)#super 自动找到父类，进而调用方法,假设继承多个父类，会按照顺序逐个找，然后调用
self.height=90
self.weight=20
def __str__(self):
return '{}的颜色为{} 它的身高是{} 体重是{}'.format(self.name,self.color,self.weight,self.height)
pass
def bark(self):
super().bark()
print('叫的跟神一样？？？？')
print(self.name)
pass
kj=kejiquan('kek','yellow')
kj.bark()
print(kj)
汪汪叫----
叫的跟神一样？？？？
kek
kek的颜色为yellow 它的身高是20 体重是90
#属性：类属性和实例属性
#类属性就是类对象所拥有的属性
class Student:
name='李明'#属于类属性，就是Student类对象所拥有的
def __init__(self,age):
self.age=age#实例属性
pass
pass
lm=Student(18)
print(lm.name) # 通过对象去访问类属性
print(lm.age)
xh=Student(28)
print(xh.name)
print(xh.age)
print('---------通过类对象Student访问name----------------')
print(Student.name)
# print(Student.age)
# 小结：类属性可以被类对象和实例对象使用
# 实例对象只能被实例对象访问
李明
18
李明
28
---------通过类对象Student访问name----------------
李明
class People:
country='China'
@classmethod #使实例方法变成类方法
def get_country(cls):
return cls.country# 访问类属性
pass
@classmethod
def change_country(cls,data):
cls.country=data #修改类属性的值，在类方法中
pass
@staticmethod#变成静态方法
def getData():
return People.country
pass
print(People.get_country())
p=People()
print('实例对象访问%s'%p.get_country())
People.change_country('英国')
print(People.get_country())
print(People.getData())
#一般情况下，不会通过实例方法访问静态方法
#静态方法：主要来存放逻辑性的代码，本身和类以及实例对象没有交互
#在静态方法中，不会设计到类中方法和属性的操作
import time
class Time:
def __init__(self, hour, min, second):
self.hour = hour
self.min = min
self.second = second
@staticmethod
def showTime():
return time.strftime('%H:%M:%S', time.localtime())
pass
print(Time.showTime())
#总结：
#从方法定义的形式可以看出：
# 1.类方法的第一个参数是类对象cls进而去引用类对象的属性和方法，必须使用装饰器
# @classmethod来修饰
# 2.实例方法的第一个参数必须是self，通过self可以去引用类属性或者实例属性，
# 同名称实例属性和类属性的话，实例属性的优先级最高
# 3.静态方法不需要定义额外的参数，若要是引用属性的话
# 则可以通过类对象或者实例对象去引用即可
# 必须用装饰器@staticmethod来修饰
China
实例对象访问China
英国
英国
17:00:56
#多态：顾名思义就是多种形态，状态。
#对于不同的子类【对象】有不同的行为表现
#要想实现多态，必须要有两个前提：
#1.继承：多态必须发生在父类和子类之间
#2.重写：子类重写父类的方法
class Animal:
def say(self):
print('我是动物')
pass
class Duck(Animal):
def say(self):#重写父类的方法
print('我是一只鸭子')
pass
class Dog(Animal):
def say(self):
print('我是一只小狗')
def commonIncode(obj):
obj.say()#统一调用方法
# duck1=Duck()
# duck1.say()
# dog1=Dog()
# dog1.say()
listobj=[Duck(),Dog()]
for item in listobj:#循环调用函数
commonIncode(item)
#多态的好处：
#增加程序的灵活性
#增加程序对的扩展性
浙公网安备 33010602011771号