python------面向对象介绍

参考博客：http://www.cnblogs.com/alex3714/articles/5188179.html

一.面向对象介绍
class
object

封装
继承
多态

语法
属性
方法
构造函数
析构函数

私有方法，私有属性

类变量
实例变量

1.编程范式：
1）面向过程编程（Procedural Programming)：
             又被称为top-down languages,程序从上到下一步步执行，从头到尾。
              缺点：一次性，维护难度大。
2）面向对象编程（Object-Oriented Programming OOP）：
              利用“类”和”对象“来创建各种模型来实现对真实世界的描述。
              优点：使编程的维护和扩展变得简单，大大提高程序开发效率，
                         容易理解，团队开发变得容易。

2.面向对象编程：
1）class类：
对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象都具备的属性、共同的方法。
2) object对象：
一个对象即是一个类实例化后的实例。一个类必须经过实例化后才能在程序中调用；一个类可以实
例化多个对象，每个对象可以有不同的属性。

3）三大特性：
Encapsulation封装：在类中对数据的赋值、内部调用对外部用户是透明（用户不可见）的，
这使类变成了一个胶囊或者容器，里面包含着类的数据和方法。

Inheritance继承：一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承。

Ploymorphism多态：
多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，
指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对
父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系
列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。

比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，
而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物,
只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,
调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,
而引用所指向的对象可以在运行期间动态绑定。

3.定义类：

class Dog:
    def __init__(self,name):
        self.name = name

    def bulk(self):
        print("%s : wang wang wang" % self.name)

d1 = Dog("hah ")
d2 = Dog("hehh")
d3 = Dog("jajj")

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

 

?

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

4.构造函数class Role(object):     n = 123   #类变量     name = '我是类name'     n_list = []     #增加一个列表 #定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写，以后再讲为什么     def __init__(self,name,role,weapon,life_value=100,money=15000):         #构造函数 #初始化函数，在生成一个角色时要初始化的一些属性就填写在这里 #__init__中的第一个参数self,和这里的self都 是什么意思？         self.name = name        #等价于 r1.name = name #实例变量(静态属性），作用域就是实例本身。         self.role = role         self.weapon = weapon         self.life_value = life_value        self.__life_value = life_value  #私有属性，前面加两个下划线         self.money = money     def shot(self):  # 类的方法，功能（动态属性）         print("shooting!")   print(Role.n) r1 = Role('xiaolaizi','police','98K')  #把一个类变成一个具体对象的过程叫实例化 r1.name = "小赖子"         #改名 r1.bullet_prove = True      #添加类中没有的一个属性 r1.n_list.append("from r1")     #往类变量列表中添加内容   print(r1.n,r1.name,r1.n_list)     r2 = Role('xiaomazi','police','mini14') print(r2.n,r2.name,r2.n_list)

　　

 

　5. 类变量与实例变量区别：

               对象先调用实例变量，找不到再去类变量里面找。

                   实例变量可以修改，增加，删除 （del）。

                    实例变量：每个对象各自特有的属性；

                    类变量:  共有的属性。

   

6.类变量的作用及析构函数

       类变量的用途：大家公用的属性，节省开销。

 

   析构函数：在实例释放（就是自己写了  del  某某某之后）、销毁的时候自动执行的，通常用于做一些收尾工作，如关闭一些数据库连接，关闭打开的临时文件。

 

                   只有你自己del r1这个实例对象，python才会销毁r1对应的内存。（哪怕是你创建了r1这个内存之后再也不用了，python

             也不会去给你删除，因为他不知道你用不用，只有当你摘去r1这个门牌号，python 才会拆了这座房子）

 

 7. 私有方法，已有属性

     前面加两个下划线，只能在内部访问。

 

8.类的继承 

       

class People:
    """类的继承,父类"""
    def __init__(self,name,age):
        self.Name = name        #self.name = name
        self.Age = age        #Age是变量名，age是参数名。可以不一样，但是一般 都写一样的。

    def eat(self):
        print("%s is eating ..." % self.Name)

    def sleep(self):
        print("%s is sleeping ..." % self.Name)

    def talk(self):
        print("%s is talking ..." % self.Name)

class Man(People):
    def piao(self):
        print("%s is piaoing ..." % self.Name)

    #def sleep(self):    #覆盖了父类方法
     #   print("man is sleeping ...")
      #  print("-"*20)

    def sleep(self):          #重构父类的方法
        People.sleep(self)    #既执行父类的方法，又执行子类的方法
        print("+" * 20)
        print("man is sleeping ...")

class Women(People):
    def get_birth(self):
        print("%s is born a baby" % self.Name)


m1 = Man("xiaolaizi",22)
w1 = Women("xiaolizi",24)
m1.eat()
m1.piao()
m1.sleep()
w1.get_birth()

问题来了，那么怎么在父类的基础上只给Man类增加除了name ,age 之外的属性呢，而不影响Women子类？

class People:
    """类的继承,父类"""
    def __init__(self,name,age):
        self.Name = name        #self.name = name
        self.Age = age        #Age是变量名，age是参数名。可以不一样，但是一般 都写一样的。

    def eat(self):
        print("%s is eating ..." % self.Name)

    def sleep(self):
        print("%s is sleeping ..." % self.Name)

    def talk(self):
        print("%s is talking ..." % self.Name)

class Man(People):
    def __init__(self,name,age,money):    #对构造函数进行重构
18         People.__init__(self,name,age)
           #等价于  super(Man,self).__init__(name,age) 优点是不用写父类名（哈哈哈）
            
19         self.money = money
        print("%s 一生下来就有钱。。。。" % self.Name)
        
    def piao(self):
        print("%s is piaoing ..." % self.Name)

    def sleep(self):          #重构父类的方法
        People.sleep(self)    #既执行父类的方法，又执行子类的方法
        print("man is sleeping ...")

class Women(People):
    def get_birth(self):
        print("%s is born a baby" % self.Name)
m1 = Man("xiaolaizi",22,1000)
w1 = Women("xiaolizi",24)
m1.eat()
m1.piao()
m1.sleep()
w1.get_birth()

     

多继承：

class People(object):     #新式类   父类1
    """类的继承,父类"""
    def __init__(self,name,age):
        self.Name = name        #self.name = name
        self.Age = age        #Age是变量名，age是参数名。可以不一样，但是一般 都写一样的。

    def eat(self):
        print("%s is eating ..." % self.Name)

    def sleep(self):
        print("%s is sleeping ..." % self.Name)

    def talk(self):
        print("%s is talking ..." % self.Name)

class Relation(object):   #父类2
    def make_friend(self,obj):
        print("%s is making friends with %s" %(self.Name,obj.Name))


class Man(People,Relation):   #多继承 继承的顺序从左到右
    def __init__(self,name,age,money):    #对构造函数进行重构
        #People.__init__(self,name,age)
        super(Man,self).__init__(name,age)    #新式类的写法

        self.money = money
        print("%s 一生下来就有钱。。。。" % self.Name)

    def piao(self):
        print("%s is piaoing ..." % self.Name)

    def sleep(self):          #重构父类的方法
        People.sleep(self)    #既执行父类的方法，又执行子类的方法
        print("man is sleeping ...")

class Women(People,Relation):
    def get_birth(self):
        print("%s is born a baby" % self.Name)
m1 = Man("xiaolaizi",22,1000)
w1 = Women("xiaolizi",24)
m1.make_friend(w1)
执行结果：

xiaolaizi 一生下来就有钱。。。。
xiaolaizi is making friends with xiaolizi

那么问题来了，父类2 没有构造函数，怎么就传进去参数了呢？
   那是因为我们已经在父类1继承了name,age 属性（哈哈哈）