面向对象总结

一，最简单的构造方法

带一个参数

class Dog:
    def __init__(self,name):
        self.name = name      实例变量（静态属性），在实例时使用

    def bulk(self):           动态属性，也就是方法
        print("%s: wang wang wang!" % self.name)


d1 = Dog("陈荣华")
d2 = Dog("陈三炮")
d3 = Dog("陈老泡")

d1.bulk()
d2.bulk()
d3.bulk()

结果：

陈荣华: wang wang wang!
陈三炮: wang wang wang!
陈老泡: wang wang wang!

 

解析 构造函数和方法中self

 

构造函数：

d1 = Dog("陈荣华")  实例化解析

最原始的思想是  d1 = Dog.__init("陈荣华"), 返回一个内存地址，其实不是
它其实相当于  
d1 = Dog(d1,"陈荣华") 
d1.name = "陈荣华"
构造初始化的本身，所以构造函数中必须有self


方法

d1.bulk()  

相当于
Dog.bulk(d1)
每次调用要知道是谁在调用，所以方法中，都有self


二、析构函数

析构函数：在实例释放、销毁的时候执行的，通常用于做一些收尾工作，如关闭一些数据库连接、或关闭打开临时文件

def __del__(self):
    pass #print("%s 彻底死了。。。。" %self.name)


如果new 两个对象 调用各种方法，
两个对象在 方法都执行完会相继执行  这个析构方法

三、私有属性和私有方法

前面加两个下划线    __

 

举例：

私有属性

def __init__(self, name, role, weapon, life_value=100, money=15000):
    #构造函数
    #在实例化时做一些类的初始化的工作
    self.name = name #r1.name=name实例变量(静态属性),作用域就是实例本身
    self.role = role
    self.weapon = weapon
    self.__life_value = life_value
    self.money = money

def show_status(self):
    print("name:%s weapon:%s life_val:%s" %(self.name,
                                             self.weapon,
                                            self.__life_value))


实例化的对象肯定是不能访问这个属性的，但是在本类中的方法里可以访问。如上面这个方法

私有方法

def __shot(self): # 类的方法，功能 （动态属性）
    print("shooting...")

在外面类中肯定调用不到了
这样来说，析构方法也是私有方法咯


四、继承

普通继承

class People(object): #新式类
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.friends = []
        print("--doens't run ")
    def eat(self):
        print("%s is eating..." % self.name)
    def talk(self):
        print("%s is talking..." % self.name)
    def sleep(self):
        print("%s is sleeping..." % self.name)

class Man(People):
    pass

m1 = Man("NiuHanYang",22)
m1.eat();

结果：

--doens't run
NiuHanYang is eating...

 

重构

class People(object): #新式类
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.friends = []
        print("--doens't run ")
    def eat(self):
        print("%s is eating..." % self.name)
    def talk(self):
        print("%s is talking..." % self.name)
    def sleep(self):
        print("%s is sleeping..." % self.name)

class Man(People):
    def __init__(self,name,age,money):
        #People.__init__(self,name,age)
        super(Man,self).__init__(name,age) #新式类写法
        self.money  = money
        print("%s 一出生就有%s money" %(self.name,self.money))

m1 = Man("NiuHanYang",22,50000)
m1.eat();

结果：

--doens't run
NiuHanYang 一出生就有50000 money
NiuHanYang is eating...

注：A、重构的init方法中，参数一定要包含父类的参数。蓝色标注

      B、重构有两种方法，第一种：

People.__init__(self,name,age)
第二种：

super(Man,self).__init__(name,age)

C、新属性   self.money  = money

根据结果可以看到，父类的方法也实现了，打印出了结果。也复写了父类方法，子类中也打印了结果。

普通的方法，重构父类方法，相同。


多继承

class People(object): #新式类
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.friends = []
        print("--doens't run ")
    def eat(self):
        print("%s is eating..." % self.name)
    def talk(self):
        print("%s is talking..." % self.name)
    def sleep(self):
        print("%s is sleeping..." % self.name)

class Relation(object):

    def make_friends(self,obj): #w1
        print("%s is making friends with %s" % (self.name,obj.name))

class Man(Relation,People):
    def __init__(self,name,age,money):
        #People.__init__(self,name,age)
        super(Man,self).__init__(name,age) #新式类写法
        self.money  = money
        print("%s 一出生就有%s money" %(self.name,self.money))

class Woman(People,Relation):
    def get_birth(self):
        print("%s is born a baby...." % self.name)

m1 = Man("NiuHanYang",22,50000)
w1 = Woman("ChenRonghua",26)
m1.make_friends(w1)

结果：

--doens't run
NiuHanYang 一出生就有50000 money
--doens't run
NiuHanYang is making friends with ChenRonghua

 

py2 经典类是按深度优先来继承的，新式类是按广度优先来继承的
py3 经典类和新式类都是统一按广度优先来继承的

 

五、多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

Python多态示例

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

#_*_coding:utf-8_*_     class Animal(object):     def __init__(self, name):  # Constructor of the class         self.name = name       def talk(self):              # Abstract method, defined by convention only         raise NotImplementedError("Subclass must implement abstract method")     class Cat(Animal):     def talk(self):         print('%s: 喵喵喵!' %self.name)     class Dog(Animal):     def talk(self):         print('%s: 汪！汪！汪！' %self.name)       def func(obj): #一个接口，多种形态     obj.talk()   c1 = Cat('小晴') d1 = Dog('李磊')   func(c1) func(d1)

 

class Animal:
    def __init__(self, name):  # Constructor of the class
        self.name = name

    def talk(self):  # Abstract method, defined by convention only
        pass #raise NotImplementedError("Subclass must implement abstract method")

    @staticmethod
    def animal_talk(obj):
        obj.talk()

class Cat(Animal):
    def talk(self):
        print('Meow!')

class Dog(Animal):
    def talk(self):
        print('Woof! Woof!')

d = Dog("陈荣华")
#d.talk()

c = Cat("徐良伟")
#c.talk()
#
# def animal_talk(obj):
#     obj.talk()

Animal.animal_talk(c)
Animal.animal_talk(d)

 

http://www.cnblogs.com/alex3714/articles/5188179.html