python面向对象学习

面向对象编程

OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

无论用什么形式来编程，我们都要明确记住以下原则：

1. 写重复代码是非常不好的低级行为
2. 你写的代码需要经常变更 

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

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

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

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

Polymorphism 多态
多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定

类和类对象的语法以及简单封装使用：

# 类
class Dog:
    # 初始化类，再生成角色时，初始化属性值
    def __init__(self, name):
        self.name = name

    # 方法
    def bulk(self):
        print('%s:wang-wang-wang' % self.name)

# 类对象
d1 = Dog('陈')
d2 = Dog('张')
d3 = Dog('李')


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

继承的语法以及简单使用：

class School(object):
    member = 0 #

    def __init__(self,name,addr):
        self.name = name
        self.addr = addr
        self.students = []
        self.staffs = []

    # 注册
    def enroll(self,stu_obj):
        print('为学员 %s 办理注册手续' % stu_obj.name)
        self.students.append(stu_obj)

    def hire(self,starff_obj):
        print('雇佣了 %s' %starff_obj.name)
        self.staffs.append(starff_obj)




class SchoolMember(object):

    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex


    def tell(self):
        pass






class Teacher(SchoolMember):
    def __init__(self,name,age,sex,salary,course):
        super(Teacher,self).__init__(name,age,sex)
        self.salary = salary
        self.course = course

    def tell(self):
        print('''
        -------info of Teacher : %s-------
        Name:%s
        Age:%s
        Sex:%s
        Salary:%s
        Course:%s
        ''' %(self.name,self.name,self.age,self.sex,self.salary,self.course))


    def teach(self):
        print('%s is teaching course [%s]' %(self.name,self.course))


class Student(SchoolMember):
    def __init__(self,name,age,sex,stu_id,grade):
        super(Student,self).__init__(name,age,sex)
        self.stu_id = stu_id
        self.grade = grade

    def tell(self):
        print('''
        -------info of Teacher : %s-------
        Name:%s
        Age:%s
        Sex:%s
        Stu_id:%s
        Grade:%s
        ''' % (self.name,self.name, self.age, self.sex, self.stu_id, self.grade))

    def pay_tuition(self,amount):
        print('%s has paid %s fee' % (self.name,amount))


school = School('老男孩IT','沙河')

t1 = Teacher('Oldday',56,'MF',200,'Linux')

t2 = Teacher('Alex',22,'M',30,'Python')


s1 = Student('CHEN',12,'M',1001,'py')
s2 = Student('zhou',13,'F',2001,'ios')


t1.tell()
s1.tell()

school.enroll(s1)
school.enroll(s2)
school.hire(t1)
school.hire(t2)

print('-------students staffs---------')
print(school.students)
print(school.staffs)

school.staffs[0].teach()

for stu in school.students:
    stu.pay_tuition(19800)

# class People:经典类
class People(object): # 新式类

    def __init__(self,name,age):
        self.Name = name
        self.age = age
        self.friends = []

    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):


    def make_friend(self, obj):
        print('%s is making friends with %s' %(self.Name, obj.Name))
        self.friends.append(obj)

# 继承多个类的时候，不需要每个参数都要初始化，只要有一个初始化就可以直接使用
# 继承class Son(Father):
class Man(People, Relation):

    # 重构，添加新属性
    def __init__(self,name,age,money):
        # self.name = name
        # self.age = age
        # 继承父类的构造函数
        # People.__init__(self,name,age)
        # 多继承使用：通用的继承父类方法(推荐使用)
        # 新式类的写法
        super(Man,self).__init__(name,age)

        self.money = money
        print('%s 一出生就有 %s money' %(self.Name,self.money))

    # 添加新功能
    def piao(self):
        print('%s is piaoing...20s...' % self.Name)

    # 重写父类的方法：重构了父类的方法
    def sleep(self):
        # 先执行父类的方法
        People.sleep(self)
        print('man is sleeping...')


class Woman(People, Relation):

    def get_birth(self):
        print('%s is born a body...' % self.Name)



# TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'
# m1 = Man()
m1 = Man('son',22,100000)
# m1.sleep()
#
# m1.piao()
# m1.sleep()


print('----------------')
w1 = Woman('Chen', 23)
# w1.get_birth()
# m1.get_birth()


m1.make_friend(w1)
w1.Name = '陈'
print(m1.friends[0].Name)

py2和py3继承的区别：

python2经典类是按深度优先来继承的，新式类是按广度优先来集成的
python3经典类和新式类都是用广度优先来继承的

'''

python2经典类是按深度优先来继承的，新式类是按广度优先来集成的
python3经典类和新式类都是用广度优先来继承的

'''

class A():
    def __init__(self):
        print('A')

class B(A):
    pass
    # def __init__(self):
    #     print('B')

class C(A):
    pass
    # def __init__(self):
    #     print('C')

class D(B,C):
    pass


d = D()

多态：一种接口，多种实现

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

    def talk(self):
        return 'Meow!!!'

    # 正统的多态：一种接口，多种实现
    @staticmethod
    def animal_talk(obj):
        obj.talk()


class Cat(Animal):
    def talk(self):
        print('Meow!!!')


class Dog(Animal):
    def talk(self):
        print('Woof,Woof!!!')

# 一种接口，多种实现
# def animal_talk(obj):
#     obj.talk()


d = Dog('D')
# d.talk()


c = Cat('C')
# c.talk()

# def animal_talk(obj):
#     obj.talk()
# animal_talk(c)
# animal_talk(d)

# 一种接口，多种实现
Animal.animal_talk(c)
Animal.animal_talk(d)