以下代碼運(yùn)行前，可以思考輸出是什么，對(duì)比真實(shí)輸出，查漏補(bǔ)缺。

關(guān)于類的私有方法和私有屬性

'''
類的私有方法和私有屬性，不能被類的實(shí)例對(duì)象直接訪問！
'''
class Person(object):
    name = "Andrew"

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

    def eat(self):
        print("The Person %s is eating" % self.name)

    def __personOnly(self):
        print("外部訪問內(nèi)部私有方法（__personOnly）需要對(duì)象名+類名+方法才能訪問")

    def innerInvoke(self):
        Person.__personOnly(self)
        print("但是如果類的內(nèi)部方法（innerInvoke）訪問私有方法（__personOnly）簡(jiǎn)單許多")


p = Person("Parker")
print(p.name)
p.eat()
print("<--------------------------->")
# 可見，Python中類的私有方法不能直接被外部類的實(shí)例對(duì)象訪問
# 需要 "對(duì)象名._類名__xxx" 才能訪問。不過一般用于類的內(nèi)部訪問。
p._Person__personOnly()
print(Person.name)
print("<--------------------------->")
p.innerInvoke()



# Output 
Parker
The Person Parker is eating
<--------------------------->
外部訪問內(nèi)部私有方法（__personOnly）需要對(duì)象名+類名+方法才能訪問
Andrew
<--------------------------->
外部訪問內(nèi)部私有方法（__personOnly）需要對(duì)象名+類名+方法才能訪問
但是如果類的內(nèi)部方法（innerInvoke）訪問私有方法（__personOnly）簡(jiǎn)單許多

關(guān)于屬性和方法的使用

'''
方法可以借助修飾器實(shí)現(xiàn)屬性化,直接通過類似于屬性訪問和修改方式訪問方法。
'''


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

    def getname(self):
        return self.__name

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

    name = property(getname, setname)


u = User("Parker")
print(u.name)

u.name = "Andrew"
print(u.name)

u.age = 21
print(u.age)
u.__age = 22
print(u.__age)

# Output 
Parker
Andrew
21
22

關(guān)于類的多繼承和順序問題

'''
關(guān)于類的繼承，子類要么直接重新構(gòu)造init函數(shù)，或者只能繼承一個(gè)多父類的一個(gè)父類構(gòu)造函數(shù)
并且，依據(jù)順序繼承。
'''


class Employee:
    def __init__(self, salary):
        self.salary = salary

    def work(self):
        print("salary is %d" % self.salary)


class Customer:
    def __init__(self, salary, job):
        self.salary = salary
        self.job = job

    def info(self):
        print("the salary is %d and the job is %s" % self.salary, self.job)


# 這樣顯然是優(yōu)先繼承父類Employee的構(gòu)造方法（在沒有自己初始化init函數(shù)）
class Manager(Employee, Customer):
    pass


m = Manager(5000)
m.work()
# 由于繼承順序原因，所以只接受兩個(gè)參數(shù)，self和salary；
# 因此會(huì)報(bào)錯(cuò)輸出！
m1 = Manager(5000, "teacher")
m1.info()

# Output
salary is 5000
Traceback (most recent call last):
  File "/Users/Parker/PycharmProjects/Python/Test/OOP/test3.py", line 32, in <module>
    m1 = Manager(5000, "teacher")
TypeError: __init__() takes 2 positional arguments but 3 were given

關(guān)于特殊方法的運(yùn)用

'''
特殊方法如：__init__ __str__ __del__ 不同于私有方法 __name __age;
'''


class User:
    def __init__(self, name, salary):
        self.__name = name
        self.__salary = salary

    def __str__(self):
        return self.name + " has a salary of " + str(self.salary)

    def __del__(self):
        print("一旦重寫__del__析構(gòu)方法，則Python將把內(nèi)存管理交給程序員；否則自動(dòng)調(diào)用其方法")
        print("注意：這個(gè)特殊方法在程序結(jié)束后自動(dòng)調(diào)用！")
        print("auto del")

    # 方法屬性化方法一，注意函數(shù)命名相同，但是修飾器的修飾不同！
    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name

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

    # 方法屬性化方法二，這個(gè)比較一目了然。只需要給property一個(gè)setter和getter函數(shù)就可以
    def get_salary(self):
        return self.__salary

    def set_salary(self, salary):
        self.__salary = salary

    salary = property(get_salary, set_salary)


# 初始化，調(diào)用特殊方法init
u = User("Andrew", 5000)
# 調(diào)用方法屬性化方式訪問修改name
print(u.name)
u.name = "Parker"
# 調(diào)用方法屬性化方式去修改salary
print(u.salary)
u.salary = 9000
# 調(diào)用特殊方法str，輸出！程序結(jié)束后，自動(dòng)調(diào)用特殊方法del
print(u)

# Output 
Andrew
5000
Parker has a salary of 9000
一旦重寫__del__析構(gòu)方法，則Python將把內(nèi)存管理交給程序員；否則自動(dòng)調(diào)用其方法
注意：這個(gè)特殊方法在程序結(jié)束后自動(dòng)調(diào)用！
auto del

小結(jié)

針對(duì)于OOP，也就是Python的面向?qū)ο缶幊虂碚f，有和Java類似之處，但上面列出的幾個(gè)例子都是相比較于java，Python的面向?qū)ο缶幊痰奶匦裕?/p>