OO的特征:面向对象
1.封装
2.继承
3.多态
OOA:面向对象分析
OOP:面向对象编程
OOD:面向对象设计
==============================================
#封装:
#类
class Turtle:
#属性
color = 'green'
weight = 10
legs = 4
shell = True
mouth = "大嘴"
#方法
def climb(self):
print("我正在很努 力的向前爬")
def run(self):
print("我正在飞快的向前跑")
def bite(self):
print("咬死你!")
#创建对象
tt = Turtle()
tt.bite()
#继承 : 这个类继承list,并拥有List的所有方法
class Mylist(list):
pass
list2 = Mylist()
list2.append(range(10))
print list2
如果子类中定义与父类同名的方法或属性,则会自动覆盖父类对应的方法或属性
class Parend():
def hello(self):
print("正在调用父类的方法……")
class Child(Parend):
def hello(self):
print("正 在调用子类的方法……")
c = Child();
c.hello()
正 在调用子类的方法……
class Fish:
def __init__(self):
self.x = r.randint(0,10)
self.y = r.randint(0,10)
#每移动一次就向 西移动一个位置
def move(self):
self.x -=1
print("我的位置是",self.x,self.y)
class Goldfish(Fish):
pass
class Carp(Fish):
pass
class Salmon(Fish):
pass
#乌龟
class Shark(Fish):
#这里的名子和父类一样,这时就覆写父类,当调用继承下来的move()方法,调用方法时,就会报错,因为没有初始化父类的
#所以要初始化一下父类的
def __init__(self):
super().__init__()
self.hungry = True
def eat(self):
if self.hungry:
print("吃货的梦想就是天天吃")
self.hungry = False
else:
print("吃不了了")
shark = Shark()
shark.move()
多重继承:
class Basel:
def fool(self):
print("我是foo1,我为Basel代言")
class Base2:
def foo2(self):
print("我是foo2,我为Base2代言")
class C(Basel,Base2):
pass
c = C()
c.foo2()
c.fool()
我是foo2,我为Base2代言
我是foo1,我为Basel代言
#多态 :调用的函数名子一样,但实现方法内容却不一样
class A:
def fun(self):
print("我是A")
class B:
def fun(self):
print("我是B")
a = A()
b = B()
a.fun()
b.fun()
self:就是实例化的对象,相当于this
class Ball:
def setName(self,name):
self.name = name
def kick(self):
print("我叫%s,谁踢我……"%self.name)
a = Ball()
a.setName("张")
a.kick()
我叫张,谁踢我……
b = Ball()
b.setName("李")
b.kick()
我叫李,谁踢我……
init(self): 构造方法,实例对象时会自动传入参数,进行初始化
class Ball:
def __init__(self,name):
self.name = name
def kick(self):
print("我叫%s,谁踢我……"%self.name)
a = Ball("张")
a.kick()
b = Ball("李")
b.kick()
公有和私有
私有:只需要在变量名或函数名前加上__两个下划线,那么这个函数或变量就会变为私有的了
class Person:
__name = "张"
def getName(self,name):
self.__name = name
return self.__name
p = Person()
#通过公有方法更改私有属性
print p.getName("李")
#通过对象引用访问私有属性 ,其它是未私有的,可以通过其它方式来访问它
print p._Person__name
组合:就是将实例 化后的类放入新类的初始化中,这样,这些类就组合在一起了,不是很有继承关系的就可以用组合
class Turtle:
def __init__(self,x):
self.num = x
class Fish:
def __init__(self,x):
self.num = x
class Pool:
def __init__(self,x,y):
self.turtle = Turtle(x)
self.fish = Fish(y)
def print_num(self):
print("水池里总共有乌龟%d 只,小鱼 %d 条"%(self.turtle.num,self.fish.num))
pool = Pool(1,10)
pool.print_num()
一些相关的BIF(对象内置函数)
#一个类是否是另一个类的子类 ,classinfo:可以是一个元组,也就是多个
issubclass(class,classinfo)
#一个类是否是另一个类的实例
isinstance(object,classinfo)
#对象中是否有这个属性
hasttr(objcet,name)
#返回对象中指定的属性值,没有,则返回自定义的值
getattr(object,name,[default])
#设置对象中指定的属性值,没有,则新创建一个新的属性
setattr(object,name,value)
#删除对象中指定的属性
delattr(object,name)
#设置一个属性,设置已级定义好的属性
传入的都是定义好的方法名
property(fget=None,fset=None,fdel=None,doc=None)
>>> class C:
def __init__(self,size=10):
self.size = size
def getSize(self):
return self.size
def setSize(self,value):
self.size = value
def delSize(self):
del self.size
x = property(getSize,setSize,delSize)
通过 定义的x 间接的获取属性
>>>
>>> c1 = C()
>>> c1.getSize()
10
>>> c1.x #相当于调用了定义的get方法
10
>>> c1.x = 18 #相当于调用了定义的set方法
>>> c1.x
18
>>> c1.size
18
>>> c1.getSize()
18
>>> del c1.x
>>> c1.size
Traceback (most recent call last):
File "<pyshell#10>", line 1, in <module>
c1.size
AttributeError: 'C' object has no attribute 'size'