21.面向对象三大特征 21.继承与抽象 属性的查找顺序 派生与覆盖 子类访问父类 初始化方法 必须调用super 组合 多继承

OOP三大特征

1.OOP 面向对象 三大特征

    封装
    继承
    多态


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

  例如麦兜,佩奇,猪刚鬣 都是猪啊,

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

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

a称之为子类,b称之为父类,也称之为基类

2.为什么要使用继承
    继承的一方可以直接使用被继承一方已经有的东西

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

## 如何使用继承

语法:

class 类名称(父类的名称):
    类的内容

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

2.抽象
    不具体 不清晰 很模糊 看不懂

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

正确的使用继承
    1.先抽象再继承
    2.继承一个已经现存的类,扩展或是修改原始的功能

3.属性的查找顺序
    对象自己的 - > 所在类中 -> 找父类 - >父类的父类 ->Object



4.派生 与 覆盖
    派生: 当一个子类中出现与父类中不同内容时,这个子类就称为派生类
    通常子类都会写一些新的代码,不可能和父类完全一样 , 既通常都是派生类,

    所以派生类指的就是子类

    覆盖 也称之为重写 overriders
        当子类出现了与父类名称完全一致的属性或是方法



6.子类访问父类的内容
  语法:
      方式1:
            super(当前类名称,self).你要调的父类的属性或方法
      方式2:
            super().你要调的父类的属性或方法

      方式3:
        类名称.你要调的父类的属性或方法(self)
        #方式3与继承无关

#### 强调在强调:

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


8.组合

    也是一种关系,描述两个对象之间 是什么有什么的关系

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

    将一个对象作为另一个对象的属性,(既什么有什么)

    组合的目的:也是为了重用现有代码

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

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

    另外组合相比继承,耦合度更低了


了解知识点

## 菱形继承

首先明确python支持多继承



##### 补充:新式类与经典类

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

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

经典类,既不是Object的子类 ,仅在python2中出现



当出现了菱形继承时,新式类,先深度,当遇到了共同父类时就广度

​                                    新式类,就是深度优先

​

# 小结:

1.继承是什么

2.为什么用继承

3.语法

4.先抽象在继承

6.派生

7.覆盖

8.子类访问父类的属性或方法 super ().名字

​    如果你继承一个已有的类,并且你覆盖了init  一定要先调用父类的init

9.继承的原理,mro列表

10,新式类与经典类

11.菱形继承 了解

12,属性的查找顺序

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)

# 抽取老师和学生中相同的部分形成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,age:%s,gender:%s" % (self.name,self.age,self.gender))


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

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

class Student(Person):
    pass

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

class A:
    text = "haha"

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

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

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



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

stu = Student()
stu.say_hi()

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

"""

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("12223")

class Parent:
    text = 'abc'

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


class Sub(Parent):
    def show_info(self):
        print(super(Sub,self).text,1)
        print(super(Sub,self).say_something())

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

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

sub = Sub()
sub.show_info()

# class Person:
#     def __init__(self,name,gender,age):
#         self.name = name
#         self.gender = gender
#         self.age = age
#
#     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("number:%s" % self.number)
#
#
# stu = Student("rose","mael",20,"old01")
# stu.say_hi()

# 为什么要在初始化方法中调用 父类的初始化方法
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()

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

# # coding:utf-8
# class A:
#     pass
#
# class B:
#     pass
#
# class C:
#     pass
#
# class Test(A,B,C):
#     pass
#
# print(Test.mro())
"""
[<class '__main__.Test'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class 'object'>]
"""
# class A(object):
#     pass
#
# print(A.mro()) # [<class '__main__.A'>, <class 'object'>]
#
# print(A.__dict__)
"""
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
"""
# 菱形继承
# class A:
#     j = 1
#     pass
#
# class B:
#     # j = 2
#     pass
#
# class C(A):
#     # j = 3
#     pass
#
# class D(A):
#     j = 4
#     pass
#
# class E(B,C,D):
#     # j = 5
#     pass
#
# d = E()
# print(d.j)
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]

抽象

菱形继承的查找顺序