面向对象初级篇

一.面向对象三大特性:

　　1.封装

　　　　　(1)将相关功能封装到一个类中:　　　

                class Message:
                    def email(self):pass
                    def msg(self):pass
                    def wechat(self):pass

　　　　　(2)将数据封装到一个对象中:　　　　　　　　　

                class Person:
                    def __init__(self,name,age,gender):
                        self.name = name
                        self.age = age
                        self.gender = gender
                        
                obj = Person('盖伦',18,'男')

　　　2.继承　　　

            class SuperBase:
                    def f3(self):
                        print('f3')

                class Base(SuperBase):  # 父类,基类
                    def f2(self):
                        print('f2')

                class Foo(Base):        # 子类,派生类
                    
                    def f1(self):
                        print('f1')
                        
                obj = Foo()
                obj.f1()
                obj.f2()
                obj.f3()

　　　　3.多态

　　　　　　鸭子模型.传入的参数可以是任何一种形态,只要能完成相应的功能就可以了

二.类的成员

　　1.成员

　　　　1.变量

　　　　　　--类变量(静态字段) 类.字段/对象.字段

　　　　　　--实例变量(字段) 对象.字段

　　　　2.方法

　　　　　　--实例方法　　　　对象.方法名

　　　　　　--静态方法　　　　类.方法/对象.方法名

　　　　　　--类方法　　　　　类.方法名/对象.方法名

　　　　3.属性

　　　　　　 --属性　　　　　　对象.属性名(不用加括号)

　　　　4.主动调用其他类的成员

　　　　　　方式一:类.实例方法(自己传self),与继承无关　　　　　

            class Base(object):

                def f1(self):
                    print('5个功能')

            class Foo(object):

                def f1(self):
                    print('3个功能')
                    Base.f1(self)

            obj = Foo()
            obj.f1()

　　　　　　方式二:按照类的继承顺序,找下一个　　　　　

            class Foo(object):
                def f1(self):
                    super().f1()
                    print('3个功能')

            class Bar(object):
                def f1(self):
                    print('6个功能')

            class Info(Foo,Bar):
                pass

            # obj = Foo()
            # obj.f1()

            obj = Info()
            obj.f1()

　　　　　　5.特殊成员

　　　　　　　　__init__ 类名()自动执行(初始化方法,不是构造方法)

　　　　　　　　__call__ 对象()自动执行

　　　　　　　　__getitem__ 对象["xx"]自动执行

　　　　　　　　__setitem__ 对象["xx"]=11 自动执行

　　　　　　　　__delitem__ del 对象["xx] 自动执行

　　　　　　　　__add__ 对象+对象自动执行

　　　　　　　　__new__ 这个才是真正的构造方法,创造了当前类的一个空对象

　　　　　　　　with 对象 as f　　自动执行 __enter__中return的内容就是f的内容 /__exit__

　　　　　　　　__str__ 把返回的值当作对象的名字

　　　　　　　　__doc__ 打印类中的注释

　　　　　　　　__dict__ 将初始化中的参数和值匹配成字典

　　　　　　　　__iter__　如果想要把不可迭代对象->可迭代对象,在类中定义__iter__方法,iter()返回一个迭代器(生成器也是一种特殊迭代器)

　　　2.修饰符

　　　3.组合(嵌套)

猜你喜欢