Python面向对象学习2（面向对象的语法和特性，待更新）

上一个内容我们介绍了面向对象和面向对象场景现在我们来学习下语法和特性

1，面向对象基本语法：

# -*- coding:utf-8 -*-
# Author: Colin Yao
class Dog(object): #类
    def __init__(self,name):#构造函数、构造方法 ==初始化方法
            self.NAME = name
    def sayhi(self):   #类的方法
        print("hello, i am a dog. my name is ",self.NAME)
    def food(self,food):
        print('%s is eat %s' %(self.NAME,food))

#函数注重过程、函数是模板、需要实例化
d = Dog("A")  #实例  #,Dog(d,"Alex") 实例化后缠上的对象、叫实例（当前Dog类的实例） self = d self就是实例本身  
d2 = Dog("lin")
# d.sayhi()  #调用类
d.food(food='gouliang')

__init__()叫做初始化方法(或构造方法)，在类被调用时，这个方法(虽然它是函数形式，但在类中就不叫函数了,叫方法)会自动执行，进行一些初始化的动作，所以我们这里写的__init__(self,name)就是要在创建一个角色时给它设置这些属性，那么这第一个参数self,就是实例本身！你实例化时python会自动把这个实例本身通过self参数传进去

涉及的知识和解释：

1.类，class Dog（object）#（新式类我们后面讲一下），Py3建议这样的语法，并且首字母要大写

2.构造函数，def __init__(self,name): 构造函数，构造方法，也相当于初始化方法

3.类的方法，def sayhi(self):

4.实例：d = Dog("A") 相当于Dog(d,"A") 传进了，构造函数：def __init__(self,name) ， self =d , name = A ，self.NAME=name 相当于d.NAME = name 也就是等于A

5. 在调用方法food方法的时候，d.food(food='gouliang')，相当于将d.food(d,"gouliang")传进了def food(self,food)，最后 print('%s is eat %s' %(self.NAME,food)) 就是print A is eat gouliang，self.NAME = d.NAME = A

2，面向对象的特性:

封装，封装是把一个对象的属性私有化不让外界调用，也提供一些可以被外界访问的属性的方法。

封装语法

class Role(object):
    nationlity = 'CN'  #公有属性
    def __init__(self, name, role, weapon, life_value=100, money=15000):
        self.name = name  #成员属性
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
        self.__heart = "Nomal" #私有属性一般不能直接被实例调用
    def shot(self):
        print("%s shooting..." %self.name)
        self.__heart = "Die"
        print(self.__heart)

    def get_heart(self):
        return self.__heart
r1 = Role('Alex', 'police', 'AK47') #生成一个角色
r2 = Role('Jack', 'terrorist', 'B22')  #生成一个角色
r3 = Role('lichuang','警犬','B13')
print("如果你想访问私有属性、不能修改、就需要添加代码def get_heart(self):return self.__heart----->私有属性为：",r1.get_heart())  #
print(r1.nationlity,'相当与在成员属性里添加了nationlity')  #公有属性在类里直接定义的

私有属性: self.__heart = "Nomal" （正常情况是不可以访问到私有属性的，这里写了一段，def get_heart(self): return 就可以访问了）

共有属性： class Role(object):；nationlity = 'CN'

成员属性： self.name = name...

继承，继承是使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展，继承的过程就是一般到特殊的过程，同一类对象有父类子类分别继承，实现继承可以通过继承和组合来实现

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: Colin Yao
class Person(object):   #父类
    def __init__(self,name,age):
        self.name = name  #self = b self.name =b.name
        self.age = age
        self.sex = "noraml"
    def talk(self):
        print("persion is talking")

class  BlackPerson(Person):#子类
    def __init__(self,name,age,strength):#这时候如果重新写就会覆盖父类的方法、所以我门需要先继承，在重构
        Person.__init__(self,name,age) #调用还没有实例化的类，self 传的是BlackPerson的类
        self.strength = strength
      #  print(self.name,self.age,self.sex)
    def talk(self):
        print("Black person is blaba....")

    def walk(self):
        print("is walking")

class WhitePerson(Person):
    pass

b = BlackPerson("Weiersmith","30","strong")
b.talk()

在python中继承中的一些特点：

1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。有别于C#

2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数

3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作“多重继承” 。

例如（这里的基类相当与父类）：

多级继承

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: Colin Yao
msg = '''
class Person(object): #new style
 super
class Person(object) #classical style
 ParentClass.__init__()
大家主要写新式类的 object
 继承顺序的区别、多级继承
'''
class A:#经典类
 def __init__(self):
self.n ="A"
class B(A):
#def __init__(self):
 # self.n ="B"
 pass
class C(A):
# def __init__(self):
 # self.n ="C"
 pass
class D(B,C):
# def __init__(self):
 # self.n ="D"
pass
d = D()
print(d.n)

这里会涉及到新式类和经典类的一个区别：

大概的查找顺序是： py3里新式类和经典类都是横向查找，py2里新式类的查找方式是横向的，例如class D(B,C): 先找B再找C最后找A ，但是经典类则是先找B，在找A不会找C

3.多态，多态指的是一类事物有多种形态，作用就是为了类在继承和派生的时候保证使用家谱中任意类的实例的某一属性的正确调用，也可以说当我们可以向不同的对象发送同一条消息

#多态是同一种事物的多种形态
class Animal:
    def talk(self):
            print('正在叫')


class People(Animal):
    def talk(self):
        print('say hello')

class Pig(Animal):
    def talk(self):
        print('哼哼哼')

class Dog(Animal):
    def talk(self):
        print('wangwangwang')


class Cat(Animal):
    def talk(self):
        print('喵喵喵')
peo1=People()
pig1=Pig()
dog1=Dog()
cat1=Cat()


#多态性

peo1.talk()
dog1.talk()
pig1.talk()


def func(x):
    x.talk()
func(dog1)

输出：

say hello
哼哼哼
wangwangwang
喵喵喵

参考资料：

http://www.cnblogs.com/zjltt/p/7000695.html

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

http://www.cnblogs.com/Joans/archive/2012/11/09/2757368.html