Գլուխ 3. Օբյեկտ-կողմնորոշված ծրագրավորում

Ժառանգություն

Ժառանգությունը թույլ է տալիս ստեղծել նոր կլաս՝ հիմնված գոյություն ունեցող կլասի վրա: Էկապսուլյացիայի հետ մեկտեղ ժառանգությունը օբյեկտի վրա հիմնված ծրագրավորման հիմնաքարերից մեկն է:

Ժառանգության հիմնական հասկացությունները ենթակլաս և գերկլաս են : Ենթակլասը ժառանգում է բոլոր հանրային հատկանիշները և մեթոդները գերկլասից: Գերկլասը կոչվում է նաև բազային կլաս կամ ծնող կլաս, իսկ ենթակլասը՝ ստացված կլաս կամ երեխա կլաս։

կլասի ժառանգության շարահյուսությունը հետևյալն է.

class subclass (superclass):
    subclass_methods

Օրինակ, մենք ունենք Անձի կլաս, որը ներկայացնում է անձին.

class Person:

    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    def display_info(self):
        print(f"Name: {self.__name}")

Ենթադրենք, մեզ պետք է աշխատողների կլաս, որն աշխատում է որոշակի ձեռնարկությունում: Մենք կարող ենք զրոյից ստեղծել նոր կլաս, օրինակ Employee կլասը.

class Employee:

    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    def display_info(self):
        print(f"Name: {self.__name} ")

    def work(self):
        print(f"{self.name} works")

Այնուամենայնիվ, Employee կլասը կարող է ունենալ նույն հատկանիշներն ու մեթոդները, ինչ Person կլասը, քանի որ աշխատողը մարդ է: Այսպիսով, վերը նշված Employee կլասում ավելացվում է միայն մեթոդը works, մնացած կոդը կրկնում է Person կլասի ֆունկցիոնալությունը: Բայց որպեսզի մի կլասի ֆունկցիոնալությունը չկրկնօրինակվի մյուսում, այս դեպքում ավելի լավ է օգտագործել ժառանգությունը։

Այսպիսով, եկեք ժառանգենք Employee կլասը Person կլասից.

class Person:

    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    def display_info(self):
        print(f"Name: {self.__name} ")


class Employee(Person):

    def work(self):
        print(f"{self.name} works")


tom = Employee("Tom")
print(tom.name)     # Tom
tom.display_info()  # Name: Tom
tom.work()          # Tom works

Employee կլասը ամբողջությամբ վերցնում է Person կլասի ֆունկցիոնալությունը՝ ավելացնելով միայն work(). Համապատասխանաբար, Employee օբյեկտ ստեղծելիս մենք կարող ենք օգտագործել Person-ից ժառանգված կոնստրուկտորը՝

tom = Employee("Tom")

Եվ դուք կարող եք նաև մուտք գործել ժառանգված ատրիբուտներ/հատկություններ և մեթոդներ.

print(tom.name)     # Tom
tom.display_info()  # Name: Tom

Այնուամենայնիվ, հարկ է նշել, որ __name տիպի մասնավոր ատրիբուտները հասանելի չեն Employee-ի համար: Օրինակ, մենք չենք կարող մուտք գործել մասնավոր հատկանիշ աշխատանքային մեթոդում self.__name.

def work(self):
    print(f"{self.__name} works")

Բազմակի ժառանգություն

Python լեզվի տարբերակիչ առանձնահատկություններից մեկը բազմակի ժառանգության աջակցությունն է, այսինքն՝ մեկ կլասը կարող է ժառանգվել մի քանի կլասերից.

class Employee:
    def work(self):
        print("Employee works")


class Student:
    def study(self):
        print("Student studies")


class WorkingStudent(Employee, Student):
    pass


tom = WorkingStudent()
tom.work()      # Employee works
tom.study()     # Student studies

Այն սահմանում է Աշխատակիցների կլասը, որը ներկայացնում է ընկերության աշխատակցին, և Ուսանողների կլասը, որը ներկայացնում է ուսանող ուսանողին: WorkingStudent կլասը, որը ներկայացնում է աշխատող ուսանողին, չի սահմանում որևէ ֆունկցիոնալություն, ուստի այն սահմանում է անցումային օպերատոր : WorkingStudent կլասը պարզապես ժառանգում է ֆունկցիոնալությունը երկու կլասերից Employee և Student: Համապատասխանաբար, այս կլասի օբյեկտի վրա մենք կարող ենք կանչել երկու կլասերի մեթոդներ:

Միևնույն ժամանակ, ժառանգված կլասերը կարող են ավելի բարդ լինել ֆունկցիոնալությամբ, օրինակ.

class Employee:

    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    def work(self):
        print(f"{self.name} works")


class Student:

    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    def study(self):
        print(f"{self.name} studies")


class WorkingStudent(Employee, Student):
    pass


tom = WorkingStudent("Tom")
tom.work()      # Tom works
tom.study()     # Tom studies

Բազմակի ժառանգությունը կարող է հարմար թվալ, բայց դա կարող է հանգեցնել շփոթության, եթե երկու ժառանգված կլասերը պարունակում են նույն անունով մեթոդներ/ատրիբուտներ: Օրինակ:

class Employee:
    def do(self):
        print("Employee works")

class Student:
    def do(self):
        print("Student studies")


# class WorkingStudent(Student,Employee):
class WorkingStudent(Employee, Student):
    pass

tom = WorkingStudent()
tom.do()     # ?

Երկուսն էլ Employee և Worker բազային կլասերը սահմանում են do մեթոդ, որը տպում է այլ տող վահանակի վրա: Այս իրականացումներից ո՞րն է օգտագործելու WorkingStudent-ի հետնորդ կլասը: կլաս սահմանելիս բազային կլասերի ցանկում առաջին կլասը Employee կլասն է

class WorkingStudent(Employee, Student)

Հետևաբար, do մեթոդի իրականացումը կվերցվի Employee կլասից։

Եթե փոխենք կլասերի հերթականությունը.

class WorkingStudent(Student,Employee)

այնուհետև կօգտագործվի Ուսանողների կլասի իրականացումը Անհրաժեշտության դեպքում մենք կարող ենք ծրագրային կերպով դիտել բազային կլասերի ֆունկցիոնալության կիրառման կարգը։ Դա անելու համար օգտագործեք __mro__ հատկանիշը կամ mro() մեթոդը.

print(WorkingStudent.__mro__)
print(WorkingStudent.mro())

Python

Գլուխ 3. Օբյեկտ-կողմնորոշված ծրագրավորում

Ժառանգություն

Արագ հղում

Կապ

Պատկերասրահ