介绍：

今天学习的主要是 面向对象编程的初级概念了解。2016年12月28日 


目录：

  1. 面向对象编程介绍

  • 类

  • 封装

  • 继承

  • 多态




面向对象编程介绍

objcet-oriented  Programming  ---OOP  

Class 类
一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

Object 对象 
一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

Encapsulation 封装
在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

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

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

类

class Role(object): #定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写，以后再讲为什么
    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

封装

class  Role(object):
    members = 0   ##人员初始化      类变量，类属性
    ac = None  ##类公共的
    def __init__(self,name,role,weapon,life_value):   ##形式参数，初始化方法
        self.name=name                    ### 实例变量，  self自己的
        self.role=role
        self.weapon=weapon
        self.life_value=life_value
        Role.members +=1   ##实例一次 加1
    def  buy_weapon(self,weapon):    ##方法
        print("{}   is buying  {}".format(self.name,weapon))
        self.weapon=weapon
##role的实例 ，把一个抽象的类变成一个具体的对象的过程 叫做  实例化
p1=Role("hequan","police","B10",90)
t1=Role("he1","Terrorist","B11",100)
t2=Role("he2","Terrorist","B12",100)
t3=Role("he2","Terrorist","B13",100)
p1.buy_weapon("AK47")
t1.buy_weapon("AK48")
p1.ac="china"  ##赋值,创建了一个变量 p1.ac=china,和 类的ac 没关系了。
t1.ac="us"
Role.ac="Janpanses"  ##修改类的ac
Role.weapon="D99"
print(p1.weapon,t1.weapon)
print(p1.ac,t1.ac)  ##获取的是 p1.ac
print(t2.ac,t3.ac)   #获取的是 类的ac
print(t2.weapon,t3.weapon)
print(Role.members)    ##总人员

继承

class SchoolMember(object):
    member_nums = 0  ##人数初始化
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
        self.enroll()
    def  enroll(self):
        print("mSchoolMember {}  is  enrolled!".format(self.name))
        SchoolMember.member_nums +=1
    def tell(self):
        print("hello  my name is [{}]".format(self.name))
class Teacher(SchoolMember):
    def __init__(self,name,age,sex,course,salary):
        super(Teacher,self).__init__(name,age,sex)
        self.course=course
        self.salary=salary
    def teaching(self):
        print("Teacher    [{}]  is teaching  {}.".format(self.name,self.course))
class Student(SchoolMember):
    def __init__(self,name,age,sex,course,tuition):
        super(Student,self).__init__(name,age,sex)
        self.course=course
        self.tuition=tuition
    def  pay_tution(self):
        print("cao,student  [{}]  paying  tution {}".format(self.name,self.tuition))
t1=Teacher("hequan",24,"F","PY","10000")
t2=Teacher("he",25,"N/A","PY","10000")
s1=Student("quan",25,"Female","python",15000)
s2=Student("li",26,"Female","python",5000)
print("-------------------人数-----------------------")
print("现在注册了：" ,SchoolMember.member_nums ,"人")
print("-------------------老师-----------------------")
t1.tell()
t1.teaching()
print("---------------------学生---------------------")
s2.tell()
s2.pay_tution()





mSchoolMember hequan   is  enrolled!
mSchoolMember he   is  enrolled!
mSchoolMember quan   is  enrolled!
mSchoolMember li   is  enrolled!
-------------------人数-----------------------
现在注册了： 4 人
-------------------老师-----------------------
hello   my name is [hequan]
Teacher    [hequan]  is teaching  PY.
---------------------学生---------------------
hello   my name is [li]
cao,student   [li]  paying  tution 5000

多态

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

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

class Animal:
    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):
        return 'Meow!'
class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'
def animl_talk(obj):
    print(obj.talk())
c = Cat("qwe")
d = Dog("asd")
"""
animals = [Cat('Missy'),
           Dog('Lassie')]
for animal in animals:
    print(animal.name + ': ' + animal.talk())
"""
animl_talk(c)
animl_talk(d)