Python面向对象下

1. 继承

• 面向对象三大特性之一
• def Class(Super), Class 继承了类Super中所有的属性
• 定义类， def Class( ) 或者 def Class(object), object 是所有类的超类
• 继承提高了类的复用性。让类于类之间馋了关系，有了这个关系，才有了多态的特性

2. 方法的重写

• 定义子类的时候，可以重新定义超类中同名的方法。子类的实例都可以调用新定义的方法。
• 当我们调用一个对象的方法时候：
  1. 会优先去当前对象中寻找是否具有该方法，如果又则直接调用
  2. 如果没有， 则去当前对象的父类中寻找， 如果父类中又则直接调用父类中的方法
  3. 如果没有， 则去父类的父类寻找，以此类推，知道找到object，如果依然没有找到就报错

3. super( )

• 定义子类时候， 调用父类中的方法。super().sleep()
  super().init(self.name, self.age)
• 并且通过super()返回对象调用父类方法是，不需要传递self

class Animal(object):

    def __init__(self, name, age):
        self.name = name
        self.age = age
        print('动物')

    def sleep(self):
        print('动物会睡觉')

    def run(self):
        print('动物会跑')


class Dog(Animal):

    def __init__(self, name, age):
        self.name = name
        self.age = age
        super().__init__(self.name, self.age)
        print('狗')

    def sleep(self):
        print('狗会睡觉')
        # Animal.sleep(self)
        # super(Dog, self).sleep()   python2的写法
        super().sleep()

    def run(self):
        print('狗会跑')

    def speak(self):
        print('汪汪汪')


dog = Dog('狗', 18)

4. 多重继承

class A(object):
    def test(self):
        print('A。。。。')


class B(object):
    # def test(self):
    #     print('B。。。。')
    pass


class C(B, A):
    pass

• 一个类可以继承多个父类，并且可以获取到父类中的方法
• 在开发中没有特殊情况，应该尽量比米娜使用多重继承。 因为多重继承会让代码更加复杂
• 如果多个父类中又同名的方法， 则会先在第一个父类中寻找，然后找第二个，找第三个… 前面会覆盖后面的

5. 多态

• 多态是面向对象三大特性之一
• 一个函数可以实现很多功能。 只要传递给函数的类有同样的方法名，那么就可以通过obj.name 来调用不通类中的的属性，实现一个函数调用不同值的功能
• 面向对象三大特性
  1. 封装：确保对象中数据安全
  2. 继承：保证了对象的扩展性
  3. 多态：保证了程序的灵活性

class Duck(object):
    def fly(self):
        print('鸭子沿着地面飞起来了')


class Swan(object):
    def fly(self):
        print('天鹅在空中翱翔')


class Plane(object):
    def fly(self):
        print('飞机在云层飞翔')


def fly(obj):
    obj.fly()


duck = Duck()
swan = Swan()
plane = Plane()

fly(duck)
fly(swan)
fly(plane)

• 这里的fly()就具有多态的特性， 传递不同的类实例，因为这些类中有同名的方法fly，所以可以调用不同类实例的fly方法

• Python中多态的特点

  1. 只关心对象的实例方法是否同名，不关心对象所属的类型
  2. 对象所属的类之间，继承关系可有可无
  3. 多态的好处是可以增加代码的外部调用灵活度，让代码更加通用，交融性比较强
  4. 多态是调用用方法的技巧，不会影响到类的内部设计

6. 属性和方法

• 属性

  • cls.obj & self.obj
  • 类属性，可以通过类或者类的实例访问到， 但是只能通过类对象来修改。 无法通过实例来修改
  • 实例属性， 只能通过实例对象来访问和修改，类休想无法访问修改

• 方法

  • 类的定义中， 以self为第一个参数的方法都是实例方法
  • 实例方法在调用时，Python会自动调用对象以self传入
  • 实例方法可以类实例和类去调用
  • 当通过实例调用时， 会自动讲当前调用对象作为self传入
  • 当通过类调用时，不会自动传递self，我们必须手动传递self
  • @classmethod来修饰的方法属于类方法，
  • 类方法中访问类属性， cls.obj
  • 类方法的第一个参数是cls，也会自动被传递。 cls就是当前的类对象
  • 类方法可以通过类去调用， 也可以通过实例调用
  • @staticmethod 来装饰的方法叫静态方法，记本上是一个和当前类无关的方法， 它只是一个保存到 类中的函数
  • 静态方法不需要指定任何的默认参数，静态方法可以通过类和实例调用

7. 单例模式

__new__() 方法

__new__()方法用于创建与返回一个对象，然后这个返回的对象会调用 __init__()进行初始化。

1. 通过__new__() 方法创建对象
2. 将对象返回，传给__init__()

__new__() 与__init__()区别

• __init__()实例方法，__new__()类方法
• __init__()在对象创建后自动调用， __new__()创建对象的方法

单例模式介绍

单例模式是一种常见的软件设计模式。也就是说，该类只包含一个实例。

通过单例模式，可以保证系统中一个类只有一个实例而且该实例已于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

通常应用在一些资源管理器中， 比如日志记录等。

单例模式实现

• 当对象不存在，创建对象
• 当对象存在，永远返回当前已经创建对象

class Single(object):
    __isinstance__ = None
    
    def __new__(cls, *args, **kwargs):
        if cls.__isinstance__ is None:
            cls.__isinstance__ = super().__new__()
            return cls.__isinstance__
        else:
            return cls.__isinstance__