Python之面向对象详解

Python之面向对象详解

一、对面向对象的理解

1、面向对象的编程———object oriented programming

简称：OOP，是一种编程思想。OOP把对象当成一个程序的基本单元，一个对象包含了数据和操作数据的函数。面向对象的出现极大的提高了编程的效率，使其编程的重用性增高。

2、面向对象的重要术语

1.类：具有相同属性及方法的对象的集合，它定义了该集合下对象共有的属性和方法

2.实例：也称对象，通过类定义的具体初始化方法，为其赋值

3.实例化：通过类变成实例的过程叫做实例化

4.实例属性：定义在示例中的变量，其他实例方法无法调用

5.类属性：类里面的变量，该变量在类体内方法体之外

6.类方法：类方法是将类本身当作对象进行调用的方法

7.静态方法：静态方法是指类本身，可以调用并运行的方法，不需要实例来调用（当然实例也可以调用该方法）

8.封装：把需要重用的函数或者功能封装，方便其他程序直接调用

9.继承：子类继承父类的某些功能，在程序中表现某种联系

10.多态：一个函数有多种表现形式，调用一个方法有多种联系，但是其表现出的方法是不一样的的.

3、函数和面向对象编程的区别

相同点：都是把程序进行封装、方便重复利用，提高效率。

不同点：函数重点是用于整体调用，一般用于一段不可更改的程序。仅仅是解决代码重用性的问题。

而面向对象除了代码重用性。还包括继承、多态等。使用上更加灵活。

二、封装，继承，多态

1、封装（Encapsulation）

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。

class Foo:
 
    def __init__(self, name, age ,gender):
        self.name = name
        self.age = age
        self.gender = gender
 
    def eat(self):
        print "%s,%s岁,%s,吃奶" %(self.name, self.age, self.gender)
 
    def he(self):
        print "%s,%s岁,%s,喝水" %(self.name, self.age, self.gender)
 
    def shui(self):
        print "%s,%s岁,%s,睡觉" %(self.name, self.age, self.gender)
 
a = Foo('jack', 10, '男')
a.eat()
a.he()
a.shui()
 
b = Foo('rose', 11, '女')
b.eat()
b.he()
b.shui()

2、继承（Inheritance）

继承，面向对象中的继承和现实生活中的继承相同，即：子类可以继承父类的内容。

例如：

猫可以：喵喵叫、吃、喝、拉、撒

狗可以：汪汪叫、吃、喝、拉、撒

公共的部分就是 吃、喝、拉、撒

如下实现:

class Animal:
 
    def eat(self):
        print "%s 吃 " %self.name
 
    def drink(self):
        print "%s 喝 " %self.name
 
    def shit(self):
        print "%s 拉 " %self.name
 
    def pee(self):
        print "%s 撒 " %self.name
 
class Cat(Animal):
 
    def __init__(self, name):
        self.name = name
        self.breed ＝ '猫'
 
    def cry(self):
        print '喵喵叫'
 
class Dog(Animal):
 
    def __init__(self, name):
        self.name = name
        self.breed ＝ '狗'
 
    def cry(self):
        print '汪汪叫'
 
# ######### 执行 #########
 
c1 = Cat('猫one')
c1.eat()
 
c2 = Cat('猫two')
c2.drink()
 
d1 = Dog('狗one')
d1.eat()

注意： 关于多继承

• 在Python中，如果父类和子类都重新定义了构造方法__init__( )，在进行子类实例化的时候，子类的构造方法不会自动调用父类的构造方法，必须在子类中显示调用。
• Python的类可以继承多个类，Java和C#中则只能继承一个类
• Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先
• 当类是经典类时，多继承情况下，会按照深度优先方式查找，当类是新式类时，多继承情况下，会按照广度优先方式查找

3、多态（Polymorphism）

首先Python不支持多态，也不用支持多态，python是一种多态语言，崇尚鸭子类型。

在程序设计中，鸭子类型（英语：duck typing）是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定。这个概念的名字来源于由James Whitcomb Riley提出的鸭子测试，“鸭子测试”可以这样表述：
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”
在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为鸭的对象，并调用它的走和叫方法。在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的走和叫方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。任何拥有这样的正确的走和叫方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。
鸭子类型通常得益于不测试方法和函数中参数的类型，而是依赖文档、清晰的代码和测试来确保正确使用。从静态类型语言转向动态类型语言的用户通常试图添加一些静态的（在运行之前的）类型检查，从而影响了鸭子类型的益处和可伸缩性，并约束了语言的动态特性.

例子

class A:    
    def prt(self):    
        print "A"    
 
class B(A):    
    def prt(self):    
        print "B"    
 
class C(A):    
    def prt(self):    
        print "C"    
 
class D(A):    
    pass    
 
class E:    
    def prt(self):    
        print "E"    
 
class F:    
    pass    
 
def test(arg):    
    arg.prt()    
 
a = A()    
b = B()    
c = C()    
d = D()    
e = E()    
f = F()    
 
test(a)    
test