python-lhc004-类

class HaHa(object)                           #定义一个类，大驼峰写法。object为所有类的父类，python3版本的括号里可以不写

aa=HaHa()
print(aa)                                    #由类创建一个对象，输出的aa为一个16位的内存地址

aa.name='小程'
aa.age=23                                    #给对象添加实例属性，创建对象就是实例

魔法方法	使用方法
__new __	创建对象，开辟内存地址，在object里有定义__new__方法，单例模式会用到
__init __	监听对象创建成功后，给对象添加属性并赋值
__str __	追踪对象的属性值变化
__del __	监听对象的引用次数为0的时候调用

属性	说明
公开属性	可以在类内部调用，也可以在类外部调用
私有属性	只可以在类内部调用
类属性	定义在类内，方法外的属性，每个新创建的对象都会赋予该属性

调用属性
公有属性 ：对象名.属性；
私有属性 ：在类内部，定义一个公共方法，在方法内调用私有属性，这样，对象便可以在外部调用该公共方法的形式来调用私有属性；
类属性 ：类名.属性，对象名.属性；
|

方法	说明
实例方法	括号内为self,通过对象来进行调用：对象名.方法名
类方法	@classmethod 方法名(cls) ;括号内为cls，通过类来进行调用：类名.方法名或者对象名.方法名
静态方法	@staticmethod 方法名(cls);括号内没有参数，类和对象都可以进行调用

多态

class Mo(object):
  def __init__(self,name,damage):
     self.name=name
     self.damage=damage
  def skill(self):
      print('魔王%s释放了技能飞沙走石，伤害为%d'%(self.name,self.damage))
class Xian(object):
  def __init__(self,name,damage):
     self.name=name
     self.damage=damage
  def skill(self):
      print('大仙%s释放了技能龙卷雨击，伤害为%d'%(self.name,self.damage))
class Lei(object):
  def func(self,name):
      name.skill()
htg=Mo('虎头怪',2300)
ltz=Xian('龙太子',2100)
t1=Lei()
t1.func(htg)
t1.func(ltz)

不同对象做相同事情得到不同的结果称为多态。以上为代码

继承

①单继承
②多继承

class Master(object):                   # 父类Master，它的父类是object
    tool1 ='平底锅'
    def func1(self):
        return '古典秘方'


class School(object):                   # 父类School，它的父类是object
    tool2 ='精钢锅'
    def func2(self):
        return '现代秘方'


class Prentice(Master, School):  # 子类prentice，它的父类是 Master 和 School
    pass

如上所示，子类Prentice继承了 Master 和 School 的所有方法和属性；
由于继承了两个父类，此为多继承；
若只继承一个父类，便为单继承。

class Master(object):             # 属性 tool, 方法 func()
    tool ='平底锅'
    def func(self):
        return '古典秘方'


class School(object):             # 属性 tool, 方法 func()
    tool ='精钢锅'
    def func(self):
        return '现代秘方'


class Prentice(Master, School):
    def func(self):
        return '自创秘方'

上图所示此时，Prentice的两个父类拥有相同名称的属性和方法，
但Prentice继承时并不会全部继承，而是按照顺序继承，继承顺序可以通过代码 print(Prentice.mro()) 来查看。
顺序为先子类本身，然后是继承的第一个父类，第二个父类…直到object
上图中只会继承第一个父类的 name 属性
而 func() 已经被重写，所以调用重写的即自己本身的 func()。

单例模式
单例模式就是创建一个类后，由类创建的对象只会占用一个内存，优点是节约内存

class Lei(object):
     __instance=None
     def __new__(cls, *args, **kwargs):
        if not cls.__instance:
               cls.__instance = object.__new__(cls, *args, **kwargs)
        return cls.__instance

① 上面就是创建一个单例，开始先定义变量__instance 赋值为None，来开辟一块内存；
② 接下里判断是否第一次创建对象，若是，则调用object类里的__new__来开辟内存赋值给变量__instance;
③ 接下来将返回已经带有内存地址的__instance给创建的对象；
④ 当第二次创建对象的时候，__instance已经不为None，而是为第一次创建时所赋予的内存地址，所以直接执行返回 cls.__instance，将保存的内存地址给第二个创建的对象。

多态

继承

猜你喜欢