面向对象（二）

一、继承

　　1.什么是继承

　　　　继承是一种关系，描述两个对象之间，什么是什么的关系

　　　　例如麦兜，佩奇，猪刚鬣，都是猪

　　　　在程序中，继承描述的是类和类之间的关系

　　　　例如a继承b，a就能直接使用b已经存在的方法和属性

　　　　a称之为子类，b称之为父类，又称为基类

　　2.为什么要使用继承

　　　　继承的一方可以直接使用被继承一方已经有的东西

　　　　其目的是为了重用已经有的代码，提高重用性

　　3.如何使用继承

　　　　语法：

　　　　class 类名称（父类的名称）：

　　　　　　类的内容

　　　　在python中，一个子类可以同时继承多个父类

class Base:
    desc = "这是一个基类"

    def show_info(self):
        print(self.desc)

    def make_money(self):
        print("一天赚一个亿...")

#指定父类位Base
class SubClass(Base):
    pass


obj = SubClass()
#即使类中什么都没有也可以使用父类中已有的内容
obj.make_money()
print(obj.desc)

二、抽象

　　1.将多个子类中相同的部分进行抽取，形成一个新的类，这个过程也称之为抽象的过程

　　2.正确的使用继承：

　　　　（1）先抽象在继承

　　　　（2）继承一个已经现存的类，扩展或是修改原始的功能

# 抽取老师和学生中相同的部分形成person类

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

    def say_hi(self):
        print("name:%s,gender:%s,age:%s" % (self.name,self.gender,self.age))

class Teacher(Person):
    def teaching(self):
        print("老师教学生,写代码....")

t1 = Teacher("jack","male",20)
t1.say_hi()

class  Student(Person):
    pass

stu1 = Student("rose","female",18)
stu1.say_hi()

三、属性的查找顺序

　　1.对象自己的——所在类中——找父类——父类的父类——Object

class A:
    text = "haha"

class B(A):
    text = "heihei"
    pass

b = B()
b.text = "xixi"
print(b.text)

四、派生

　　1.当一个子类中出现了与父类中不同的内容时，这个子类就称之为派生类

　　　通常子类都会写一些新的代码，不可能和父类完全一样，既通常都是派生类

　　　派生类其实就是子类

class Person:
    def say_hi(self):
        print("hello")

class Student(Person):
    pass
    

五、覆盖

　　1.又称重写overrides

　　　当子类出现了与父类名称完全一致的属性或是方法

class Person:
    def say_hi(self):
        print("hello")

class Student(Person):
    def say_hi(self):
        print("hello world!")

stu = Student()
stu.say_hi()

　　2.练习

　　　　实现一个可以限制元素类型的容器（字典、列表、元组、集合、字符串）

"""
需求 实现一个能够限制元素类型的列表类

"""
class MyList(list):
    def __init__(self,element_type):
        super().__init__() # 调用父类的初始化方法 来完成基本的初始化
        self.element_type = element_type

    def append(self, object):
        """
        :param object: 是要存储的元素
        :return: 没有
        """
        if type(object) == self.element_type:
            #我们需要在这里访问父类的append函数来完成真正的存储操作
            super(MyList,self).append(object)
        else:
            print("sorry sir, you element type not is %s" % self.element_type)


# 创建是指定要存储的元素类型
m = MyList(int)
# 当你有需求,是需要在创建对象时 干点什么事儿  那就该想到初始化方法

m.append(1)
print(m[0])
m.append("121212")

六、子类中访问父类的内容

　　1.方式：

方式1:
super(当前类名称,self).你要调的父类的属性或方法
方式2:
super().你要调的父类的属性或方法
方式3:
类名称.你要调的父类的属性或方法(self)  

 

class Parent:
    text = "abc"

    def say_something(self):
        print("anything")

class Sub(Parent):

    def show_info(self):
        # print(super(Sub,self).text)
        # super(Sub,self).say_something()

        # 访问方式2  py3的新语法 最常用的方式
        print(super().text)
        super().say_something()

        #方式3 直接指定类名调用
        # print(Parent.text)
        # Parent.say_something(self)


# sub = Sub()
# sub.show_info()

　　强调：当你继承一个现有的类，并且你覆盖了父类的init方法时，必须在初始化方法的第一行调用父类的初始化方法，并传入父类所需要的参数　　　

七、组合

　　1.描述两个对象之间的关系（什么是什么的某种关系）

　　　例如：学生有手机，游戏中角色拥有某些装备

　　　将一个对象作为另一个对象的属性（既什么有什么）

　　2.目的：

　　　　为了重用现有的代码

　　　　什么时候使用继承：分析两个类的关系，到底是不是：什么是什么的关系

　　　　什么时候使用组合：如果两个类之间，没有太大的关系，完全不属于同类

　　　　组合相比继承，耦合度更低了

　　3.初始化方法必须调用super

class Person:
    def __init__(self,name,gender,age,*args):
        self.name = name
        self.gender = gender
        self.age = age
        self.aa()

    def aa(self):
        print("aa run")


    def say_hi(self):
        print("name:%s ，gender:%s,age:%s" % (self.name,self.gender,self.age))


class Student(Person):

    def __init__(self,name,gender,age,number):
        super().__init__(name,gender,age)
        self.number= number

    def say_hi(self):
        super().say_hi()
        print("numnber:%s" % self.number)

stu = Student("rose","mael",20,"old01")
stu.say_hi()

　　4.练习

class Phone:
    def __init__(self,price,kind,color):
        self.price = price
        self.kind = kind
        self.color = color

    def call(self):
        print("正在呼叫XXXX;")

    def send_message(self):
        print("正在发送短信....")


class Student:
    def __init__(self,name,gender,phone):
        self.name = name
        self.gender = gender
        self.phone = phone

    def show_info(self):
        print("name:%s gender:%s" % (self.name,self.gender))

phone = Phone(1000,"apple","red")

stu1 = Student("rose","male",phone)
stu1.phone.call()

八、菱形继承

　　1.明确python支持多继承

class B:
    # num = 2
    pass

class C:
    # num = 3
    pass

class E(B):
    # num = 5
    pass

class F(C):
    # num = 6
    pass

class G(C):
    num = 7
    pass

class H(E,F,G):
    # num = 8
    pass

print(H.num)
print(H.mro())
#[H，E,B,F，G,C,object]

九、新式类与经典类

　　python3中任何类都是直接或间接继承了Object

　　新式类，任何显示或隐式地继承自object的类就称之为新式类，python3中全部都是新式类

　　经典类，既不是object的子类，仅在python2中出现

　　当出现了菱形继承时，新式类，先深度，当遇到了共同父类时就广度，而经典类就是深度优先

　　作业：

 

"""
程序员
    姓名 性别 年龄  工资  编程技能
和项目经理
    多了奖金,管理技能
项目经理也是程序员晋升而来
"""
import os
import pickle

class BaseClass:
    """我们希望将数据的存取操作单独抽取 这样可以降低耦合度 """

    def save(self):
        """先根据类的名称来拼接具体的路径 """
        cls_name = self.__class__.__name__
        #判断类名对应的文件夹是否存在
        if not os.path.exists(cls_name):
            os.makedirs(cls_name)  # 不存在则创建文件夹

        path = os.path.join(cls_name,self.name)
        with open(path,"wb") as f:
            pickle.dump(self,f)

    @classmethod
    def get_obj(cls,name):
        # 拼接路径
        path = os.path.join(cls.__name__,name)
        # 判断路径是否存在
        if os.path.exists(path):
            #读取并返回对象
            with open(path,"rb") as f:
                return pickle.load(f)

class  Coder(BaseClass):
    def __init__(self,name,gender,age,salary):
        self.name = name
        self.gender = gender
        self.age = age
        self.salary = salary

    def programming(self):
        print("正在开发项目....")

class Manager(Coder):
    def __init__(self,name,gender,age,salary,bonus):
        super().__init__(name,gender,age,salary)
        self.bonus = bonus

    def manage(self):
        print("正在与程序员肢体沟通...")

if __name__ == '__main__':
    # cod1 = Coder("jerry","男神",19,1000)
    # cod1.programming()
    # cod1.save()

    pass