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'