python_面向对象

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'