一、面向物件oop
-----------------------------------------------------
    1.類
        用來描述具有相同的屬性和方法的物件的集合。
        它定義了該集合中每個物件所共有的屬性和方法。
        物件是類的例項。

    2.類變數
        類變數在整個例項化的物件中是公用的。
        類變數定義在類中且在函式體之外。
        類變數通常不作為例項變數使用。

    3.資料成員
        類變數或者例項變數用於處理類及其例項物件的相關的資料。

    4.方法重寫
        如果從父類繼承的方法不能滿足子類的需求，可以對其進行改寫，這個過程叫方法的覆蓋（override），也稱為方法的重寫。

    5.例項變數
        定義在方法中的變數，只作用於當前例項的類。

    6.繼承
        即一個派生類（derived class）繼承基類（base class）的欄位和方法。
        繼承也允許把一個派生類的物件作為一個基類物件對待。
        例如，有這樣一個設計：一個Dog型別的物件派生自Animal類，這是模擬"是一個（is-a）"關係（Dog是一個Animal）。

    7.例項化
        建立一個類的例項，類的具體物件。

    8.物件
        通過類定義的資料結構例項。物件包括兩個資料成員（類變數和例項變數）和方法。


二、類、方法和變數
----------------------------------------------
    1.區分例項變數和類變數
        類中定義的是類變數，相當於靜態變數
        方法中self定義的是例項變數

    2.刪除成員
        del d1.name

    3.類的內建函式
        print(hasattr(d1,"age"))    # 判斷指定例項是否有指定成員
        setattr(d1,"name",'xxx')    # 給成員賦值set操作
        print(getattr(d1,"name"))   # 取成員值 get操作
        delattr(emp1,'age')         # 刪除指定的成員

    4.內建類屬性
        Dog.__dict__            //類屬性，字典型別。
        Dog.__doc__             //文件字串
        Dog.__name__            //類名
        Dog.__module__          //類所在模組
        Dog.__bases__           //所有父類構成的元組

    5.解構函式
        __del__:
            xxx

        銷燬物件時呼叫：
            d1 = None
            del d1

    6.程式碼展示
        # -*- encoding=utf-8 -*-
        # 建立一個類
        class Dog:
            #類變數，類似於靜態成員。可以直接通過類訪問
            name = "dahuang"
            #定義建構函式
            def __init__(self):
                Dog.name = "xiaohuang"
                self.name = "jing8"
                print("new a Dog, name is " + Dog.name + ": " + self.name)

            #定義方法[self首參]
            def watch(self,str):
                #例項變數
                self.name = str;
                print("watch..." + str)

            #定義方法
            def add(self,a,b):
                return a + b

            #定義解構函式
            def __del__(self):
                print("執行解構函式！")

        # new Dog
        d1 = Dog()

        # 訪問變數
        print(d1.name)
        print(Dog.name)

        # 呼叫函式
        d1.watch("tom");            #方法中，對例項的變數進行賦值操作
        print(d1.name)              #訪問的是例項的變數
        print(Dog.name)             #訪問的是類的變數
        print(d1.add(1,2))

        # del d1.name               #刪除成員
        print(hasattr(d1,"age"))    #判斷指定物件是否含有指定的成員

        # 內建方法
        setattr(d1,"name",'xxx')    # 給成員賦值set操作
        print(getattr(d1,"name"))   # 取成員值 get操作

        # 內建欄位
        print(Dog.__dict__)
        print(Dog.__doc__)
        print(Dog.__name__)
        print(Dog.__module__)
        print(Dog.__bases__)

        # 銷燬d1物件，呼叫解構函式
        del d1
        # d1 = None

    7.定義私有方法
        如果一個函式前面加'__'兩個下劃線修飾，那麼就是私有方法。只能在物件內部呼叫、外部無法訪問
        class Cat:
            name2 = "";
            age2 = 0;

            def __init__(self,name2,age2):
                self.name2 = name2;
                self.age2 = age2;
                # 私有方法只能在內部訪問
                self.__eatFish();

            def catchMouse(self):
                print("抓老鼠")

            # 定義私有方法
            def __eatFish(self):
                print(self.name2 + "愛吃魚")

        cat = Cat("tom",12);
        cat.__eatFish()             # 錯誤，沒有成員__eatFish

    8.定義靜態方法
        class DogCat(Dog,Cat):
            def staticFunc(args):                   #靜態方法
                print("我是靜態方法，使用類名打點呼叫")
                print("我是靜態方法，例項打點呼叫，是錯誤的")

    9.定義例項方法
        class DogCat(Dog,Cat):
            def catchMouse(self):
                print("我不會抓老鼠")
                print("例項打點呼叫")
                print("類打點呼叫，但是必須傳入例項物件充當self")

    10.類的成員和方法類似，分為靜態成員，例項成員和私有成員
        __name = "tom"              # 表示私有成員，在例項內部使用self.__name進行呼叫
        類中定義的name = "tom"       # 表示靜態成員 Dog.name 呼叫的是類成員name,定義在類中的
        函式中定義的name = "tom"     # 表示例項成員 d1.name 呼叫的是物件d1的name,一般是在函式中給出的


三、繼承
------------------------------------------------------
    1.特點
        a.支援多重繼承
        b.子類的構造__init__，不會自動呼叫父類的__init__，需要自己在子類的init中顯示呼叫父類的init,並傳遞self引數
        c.呼叫父類方法，使用父類名做字首，還要攜帶self引數
        d.查詢方法線本類，在父類

    2.如果有多個父類，那麼至少需要顯示呼叫其中一個帶參的建構函式

    3.方法重寫

    4.程式碼演示
        class Cat:
            name2 = "";
            age2 = 0;

            def __init__(self,name2,age2):
                self.name2 = name2;
                self.age2 = age2;
                self.__eatFish();

            def catchMouse(self):
                print("抓老鼠")

            def __eatFish(self):
                print(self.name2 + "愛吃魚")



        class DogCat(Dog,Cat):
            __happy = "xxx";
            def __init__(self):
                Dog.__init__(self,"tom");            #顯示呼叫父類的建構函式
                Cat.__init__(self,"tom",22);         #顯示呼叫父類的建構函式

            def run(self):
                Dog.watch(self,"lalala")            #子類呼叫父類的方法
                print("running...")

            def catchMouse(self):                   #子類重寫父類的方法
                print("我不會抓老鼠" + self.__happy)

            def staticFunc(args):                   #靜態方法
                print("我是靜態方法，使用類名打點呼叫")
                print("我是靜態方法，例項打點呼叫，是錯誤的")

        # cat= Cat("tom",12);
        # cat.__eatFish();
        dc = DogCat()
        # dc.watch("ttt")
        dc.catchMouse()
        # dc.run()
        DogCat.staticFunc("");
        DogCat.catchMouse(dc)