python面向对象编程

#########面向对象编程#########

 

 

一 编程范式

 

•面向对象编程——Object Oriented Programming,简称 OOP,把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。

•面向过程把函数继续切分为子函数,来降低系统的复杂度。

 

二 基础概念

 

• 类: 在 Python 中,所有数据类型都可以视为对象,当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类(Class)。

• OOP首选思考的不是程序的执行流程,而是某个数据类型应该被视为一个对象,这个对象拥有的属性(Property)。

• 方法: 给对象发消息实际上就是调用对象对应的关联函数,我们称之为对象的方法(Method)。

 

三 类

class Animals(object):   ###定义类，object顶级类

    def __init__(self,name,age):  ###构造函数，后面跟你要传递的参数

        self.name = name

        self.age = age

 

    def eating(self):    ####方法，与函数唯一的区别是self

        print "%s is eating ....." %self.name

 

    def drink(self):             

        print "%s is drinking ....." %self.name

fentiao = Animals('fentiao',5)  ######实例化

fentiao.eating()

fentiao.drink()

• Class 是一种抽象概念,比如我们定义的 Class——Animals,是指动物这个概念;

• 实例()则是一个个具体的  Animals;

• 面向对象的抽象程度又比函数要高,因为一个 Class 既包含数据,又包含操作数据的方法。

• object表示该类是从哪个类继承下来的。通常,如果没有合适的继承类,就使用 object 类,这是所有类最终都会继承的类。

• 创建实例的方式:fentiao = Animals('fentiao',5)

• 可以自由地给实例变量绑定属性,fentiao.name fentaio.age

•可定义一个特殊的 __init__ 方法,在创建实例的时候,就把name , age等属性绑上去

• __init__ 方法的第一个参数永远是 self ,表示创建的实例本身;

• 在类中定义的函数只有一点不同,就是第一个参数永远是实例变量self ,并且调用时,不用传递该参数。

 

 

四 数据封装

 

• 数据和逻辑被“封装”起来了,调用很容易,但却不用知道内部实现的细节。

• 封装的另一个好处是可以给类增加新的方法;

 

class Animals(object):              # 定义类

    cn = 'china'                    #类变量

    def __init__(self,name,age,gender):    #构造函数,后面跟你要传递的参数,实例过程中执行的操作

        self.name = name            # self就是实例化的变量名,self.name是实例化属性，静态属性

        self.age = age

        self.__gender = gender      #以双下划线开头的变量名，称为私有变量或属性

 

 

    def eating(self):               #方法，与函数唯一的区别是self，动态属性

        print '%s is eating.....'%self.name

 

 

    def drink(self):

        print '%s is drinking......' %self.name

 

    def get_gender(self):

        self.__hello()

        return self.__gender

 

    def __hello(self):          # 私有方法

        print 'hello.....'

 

class Cat(Animals):

    pass

fentiao = Animals("fentiao",5,'male')

fentiao.__hello()

 

 

五 访问限制

• 在 Python 中,实例的变量名如果以 __ 开头,就变成了一个私有变量(private);

• 双下划线开头的实例变量是不是一定不能从外部访问呢?NO

 

六 继承和多态

class Animal(object):

def run(self):

print 'Animal is running...'

class Dog(Animal):

pass

class Cat(Animal):

pass

• 对于 Dog 来说,Animal 就是它的父类,对于 Animal 来说,Dog 就是它

的子类;

• 继承最大的好处是子类获得了父类的全部功能。

•继承的另一个好处:多态。子类的覆盖了父类的方法。

 

# 面向对象的特性:

#   1. 封装性:私有方法和私有属性；

#   2. 继承:继承父类的方法和属性；

#   3. 多态:

 

class Animals(object):  # 定义类

    def __init__(self, name, age):  # 构造函数,后面跟你要传递的参数,实例过程中执行的操作

        self.name = name  # self就是实例化的变量名,self.name是实例化属性，静态属性

        self.age = age

 

    def eating(self):  # 方法，与函数唯一的区别是self，动态属性

        print '%s is eating.....' % self.name

 

    def drink(self):

        print '%s is drinking......' % self.name

 

    def __del__(self):  # 数据库断开

        print "that's all, game over"

 

class Realtion(object):

    def make_friends(self,obj):

        print '%s is %s friends'%(self.name,obj.name)

 

class Cat(Animals,Realtion):

    def __init__(self,name,age,color):

        # Animals.__init__(self,name,age)

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

        self.color = color

    def eating(self):

        print '%s eating fish......' % (self.name)

    def info(self):

        print """

                    Cat info

    name:%s

    age:%d

    color:%s                    

        """ %(self.name, self.age,self.color)

 

 

class Dog(Animals,Realtion):

    # def __init__(self,name,age,gender):

    def eating(self):

        print '%s eating gutou.......' % (self.name)

 

c1 = Cat('淘气', 5,'black')

d2 = Dog('二蛋',5)

c1.make_friends(d2)

————————————————