Python 面向对象2

面向对象2

1. 单例设计模式

   • 单例设计模式的使用场景，创建一个全局唯一变量，比如回收站
   • 利用类创建一个对象的时候首先调用 **_new_**方法，申请内存，然后再调用 _init_ 方法添加数据
   • 所以实现单例设计模式会就会重写 _new_ 方法和 _init_ 方法

   class Singleton(object):
       __instance=None   #创建一个类属性
       __is_first=True
       @classmethod
       def __new__(cls, *args, **kwargs):#申请内存
           if cls.__instance==None:#如果类的__instance空，那么申请内存，否则返回申请好的内存
               cls.__instance=object.__new__(cls)
           return cls.__instance
       def __init__(self,a,b):
           if self.__is_first:#第一次访问的是类属性，后面访问的是自身，因为类属性不能通过对象更改
               self.a=a
               self.b=b
               self.__instance=False
   s1=Singleton('hehe','heiheihei')
   s2=Singleton('haha','xixixi')
   #print(s1 is s2)#如果不重写__new__方法，那么两次内存地址是不一样的
   print(s1.a,s1.b)
   print(s2.a,s2.b)  #如果不重写__init__方法，每次创建都会覆盖前面的创建
   

2. 继承

   • 面向对象的三大特征：封装，继承，多态

     • 封装：函数是一个一个语句的封装；类是函数的封装

     • 继承：子类继承父类的属性，子类可以使用父类的函数

     • 多态：一种技巧

     class Animal(object):    #Animal是父类
      def __init__(self,name,age):
             self.name=name
             self.age=age
         def sleep(self):
             print(self.name+'正在睡觉')
     
     class Dog(Animal):    #()里面写父类，子类可以调用父类的属性和函数
         def bark(self):
             print(self.name+'正在叫')
     class Student(Animal):
         def study(self):
             print(self.name+'正在好好学习')
     
     d1=Dog('大黄',3)
     d1.sleep()
     d1.bark()
     s1=Student('zhangsan',18)
     s1.study()
     s1.sleep()
     

   • 继承的注意事项

     • Python里面支持多继承：括号里多个父类

     • 继承具有传递性：

     • <类名>._mro_，查看子类继承顺序：同名的函数和属性，按照逆向嫡长子顺序继承

      class A(object):   #Python3里，如果不写(object)，默认继承object
       def __init__(self,name,age):
               self.name=name
               self.age=age
           @staticmethod
           def demo_a():
               print('我是A类里面的demo_a方法')
           @staticmethod
           def foo():
               print('我是A类里面的foo函数')
      class B(object):   #Python3里，如果不写(object)，默认继承object
           def __init__(self,height,score,tel):
               self.height=height
               self.score=score
               self.tel=tel
           @staticmethod
           def demo_b():
               print('我是B类里面的demo_b方法')
           @staticmethod
           def foo():
               print('我是A类里面的foo函数')
       
       class C(A,B):
           pass
       c=C('zhangsan','age')   #按照继承顺序，他的赋值应该采用A的__init__方法
       
       print(C.__mro__)
       c.foo()
     #result
     (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
     我是A类里面的foo函数
     

   • 私有属性继承的特点：子类不会继承父类的私有属性和方法

   • 子类强调父类的私有属性和方法格式： 对象._父类命__私有对象和方法

     class Animal():
         def __init__(self,name,age):
             self.name=name
             self.age=age
     
         def eat(self):
             print(self.name+'正在吃饭')
         @staticmethod
         def __test():
             print('我是Animal中的私有方法test')
     class Person(Animal):
         @staticmethod
         def __demo():
             print('我是Person中的私有方法demo')
     
     p=Person('张三',18)
     p._Person__demo()   #一般的私有方法的强调的方法
     #p._Person__test()  #报错，因为子类不能继承父类的私有属性和方法
     p._Animal__test()   #子类强调父类的私有属性和方法格式： 对象._父类__私有对象和方法
     

   • 面向对象的相关方法

     • 使用isinstance 判断对象是否由指定的类或者父类实例化的
     • 使用 issubclass判断类是否是一个元组中至少一个类的子类

   • 多态的方法

     子类重写父类的方法，使得不同子类通过同样的方法实现不同的功能