캡슐화, 상속, 다중

대상을 대상으로 프로그래밍하는 데는 세 가지 중요한 특징이 있는데 그것이 바로 봉인, 계승과 다태이다.

물려받다

계승 메커니즘은 코드의 복용을 실현했다. 여러 클래스가 공용하는 코드 부분은 한 클래스에서만 제공할 수 있고 다른 클래스는 이 클래스만 계승하면 된다.
OOP 프로그램 설계에서 우리가 새로운 클래스를 정의할 때 새로운 클래스는 하위 클래스(Subclass)라고 하고 계승된 클래스는 기본 클래스, 부모 클래스 또는 슈퍼 클래스(Base class, Super class)라고 한다.상속의 가장 큰 장점은 자류가 부류의 모든 변수와 방법을 얻는 동시에 수요에 따라 수정하고 확대할 수 있다는 것이다.구문 구조는 다음과 같습니다.

class Foo(superA, superB,superC....):
class DerivedClassName(modname.BaseClassName):  ##             

Python3, 클래스를 정의할 때 계승이 없으면 Object를 쓸 수 있습니다.Object를 쓰든 안 쓰든 상관없지만, 모두가 쓰는 것을 권장합니다.

#     
class people:
    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.__weight = weight
    def speak(self):
        print("%s  :   %d  。" % (self.name, self.age))
#      
class student(people):
    def __init__(self, name, age, weight, grade):
        #           
        people.__init__(self, name, age, weight)
        self.grade = grade
    #      speak  
    def speak(self):
        print("%s  :   %d   ，    %d   " % (self.name, self.age, self.grade))
s = student('ken', 10, 30, 3)
s.speak()

python3의 계승 메커니즘

파이톤3의 계승 메커니즘은 파이톤2와 다르다.그 핵심 원칙은 아래 두 가지입니다. 명심하세요!
1. 자류는 어떤 방법이나 변수를 호출할 때 먼저 자신의 내부에서 찾고 찾지 못하면 상속 메커니즘에 따라 부류에서 찾기 시작한다.
2. 부류 정의의 순서에 따라 깊이 우선의 방식으로 부류를 하나씩 찾습니다!

super() 함수:

우리는 자류에 부류와 같은 이름의 구성원이 있다면 부류의 구성원을 덮어쓰는 것을 모두 알고 있다.그럼 부류의 멤버를 강제로 뽑고 싶다면?super() 함수 사용!
문법: super( , self). (), 입력해야 하는 것은 하위 클래스 이름과self이고, 호출해야 하는 것은 부 클래스의 방법이며, 부 클래스의 방법에 따라 매개 변수를 입력해야 한다.

class A:
    def __init__(self, name):
        self.name = name
        print("   __init__      ！")
    def show(self):
        print("   show      ！")
class B(A):
    def __init__(self, name, age):
        super(B, self).__init__(name=name)
        self.age = age
    def show(self):
        #      
        A.show(self)
        #      
        super(B, self).show()
obj = B("jack", 18)
obj.show()

사유 방법과 속성의 계승

class A:
    self.num = 100
    self.__num2 = 100
    
    def test1(self):
        print("--test1--")
    def __test2(self):
        print("--test2--")
    def test3(self):
        self.__test2()
        print(self.__num2)


class B(A):
    def test4(self):
        self.__test2()
        print(self.__num2)

b = B()
b.test1()
b.__test2()
print(b.num)
print(b.__num2)
b.test3()

만약에 계승된 부류의 방법을 사용한다면 이 공유 방법에서 부류의 사유 속성과 사유 방법을 방문할 수 있지만 부류에서 하나의 공유 방법을 실현한다면 이 방법은 계승된 부류의 사유 방법과 사유 속성을 사용할 수 없다

다상속

class Base(object):
    def test(self):
        print("--base--")
class A(Base):
    def test1(self):
        print("--test1--")
class B(Base):
    def test2(self):
        print("--test2--")
class C(A,B):
    pass
c = C()
c.test1()
c.test2()
c.test()

C클래스의 방법과 A, B,Base클래스의 방법이 모두 이름이 바뀌면 호출할 때의 순서는 어떻게 됩니까?

  .__mro__
print(C.__mro__)
         ，     ，            ，       
(, , , , )

다태

다태적 개념은 자바와 C# 같은 강한 유형 언어에 응용되고 파이톤은'오리 유형'을 숭상한다
동적 언어가 실례적인 방법을 호출할 때 유형을 검사하지 않고 방법이 존재하고 파라미터가 정확하면 호출할 수 있습니다.이것이 바로 동적 언어의'오리 유형'이다. 이것은 엄격한 계승 체계를 요구하지 않는다. 한 대상이'오리처럼 보이고 길을 걸을 때 오리처럼 보인다'면 오리로 볼 수 있다.
이른바 다중태: 정의할 때의 유형과 운행할 때의 유형이 다르면 이때는 다중태가 된다.

class Dog(object):
    def print_self(self):
        print("   ，  xxxx")
#   Dog 
class Xiaotq(Dog):
    def print_self(self):
        print("   ，       ")
def info(obj):
    obj.print_self()
dog = Dog()
dog1 = Xiaotq()
info(dog)
info(dog1)

봉인

봉인이란 데이터와 구체적인 조작의 실현 코드를 특정한 대상 내부에 두어 이러한 코드의 실현 세부 사항이 외부에 발견되지 않도록 하고 외부는 인터페이스를 통해 이 대상을 사용할 수 있을 뿐 그 어떠한 형식으로도 대상 내부를 수정할 수 없다. 바로 봉인 메커니즘 때문에 절차가 특정한 대상을 사용할 때 해당 대상의 데이터 구조의 세부 사항과 조작 실현 방법에 관심을 갖지 않아도 된다.

class Student:
    classroom = '101'
    address = 'beijing' 

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

    def print_age(self):
        print('%s: %s' % (self.name, self.age))
#         
#                ，         
print(classroom)
print(adress)
print_age()