Python基础（三）--- Python面向对象oop，类、方法和变量，继承

一、面向对象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)