1.10 类、方法、封装、继承、多态、装饰器

一、介绍类

类(class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例

实例化：创建一个类的实例，类的具体对象。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法

方法：类中定义的函数

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。

类变量通常不作为实例变量使用。

实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）

"关系（例图，Dog是一个Animal）。方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写

=====================================

二、定义类

（1）class 关键字 声明一个类

（2）class 类定义方法

第一种：class 类名（object）： 新式类

第二种：class 类名（）：

第三种：class 类名

（3）案例

class Hz(object):
    def __init__(self,name,age): #构造函数
        self.name=name   #实例变量
        self.age=age     # #实例变量
    def a(self):  #创建一个函数， 也叫方法
        print(self.name+"砍柴")
    def b(self):
        print("你们都是"+self.age)
if __name__ == '__main__':
    d=Hz("zt","18")  # 创建类的对象
    d.a()
    d.b()
（4）————init————初始化文件构造函数

1、定义类的时候__init__是一个构造函数，该函数是两个下划线开头和两个下划线结束，其作用就是当创建类的对象和实例时系统会自动调用构造函数，通过构造函数对类进行初始化操作

2、定义类的时候__init__方法中有一个参数self，这也是类中的方法与普通函数的区别，类的中的方法必须有一个参数self，而且位于参数列表的开头，在类中self就是代表类的当前类的实例（对象）自身，在python调用时无需传值，python会将对象自动传给self接受

===========================

三、类中的类变量、实例变量

1、类变量在类的下方，构造函数的上方

2、实例变量在构造函数的下方 self.开头

===========================

类中的实例方法、动态方法、静态方法

（1）实例方法：

class Hz(object):
    name="jz" #类变量
    def __init__(self,name,age): #构造函数
        self.name=name   #实例变量
        self.age=age     # #实例变量
    def a(self):  #创建一个函数， 也叫方法
        print(self.name+"砍柴")
    def b(self):
        print("你们都是"+self.age)
if __name__ == '__main__':
    d=Hz("zt","18")  # 创建类的对象
    d.a()
    d.b()

（2）动态方法（也叫类方法）

class Hz(object):
    name="jz" #类变量
    def __init__(self,name,age): #构造函数
        self.name=name   #实例变量
        self.age=age     # #实例变量
    def a(self):  #创建一个函数， 也叫方法
        print(self.name+"砍柴")
    def b(self):
        print("你们都是"+self.age)
    @classmethod
    def d(cls):
        print(cls.name)
if __name__ == '__main__':
    d=Hz("zt","18")  # 创建类的对象
    d.d()

（3）静态方法（私有方法），装饰器

class Hz(object):
    name="jz" #类变量
    def __init__(self,name,age): #构造函数
        self.name=name   #实例变量
        self.age=age     # #实例变量
    def a(self):  #创建一个函数， 也叫方法
        print(self.name+"砍柴")
    def b(self):
        print("你们都是"+self.age)
    @classmethod
    def d(cls):
        print(cls.name)
    @staticmethod
    def sy(name):
        print("私有方法"+name)
if __name__ == '__main__':
    d=Hz("zt","18")  # 创建类的对象
    d.sy("yuyan")

备注：（1）静态方法，实例方法（self），动态方法 （cls）
      
===============================================
类的三大特性：

封装、 继承、多态

一、封装：
1、封装：封装就是隐藏对象一些不希望外部所访问到的属性和方法，保证安全
2、概念:指的是在设计时，不对外提供，隐藏起来，提供公共方法以外对其方法就是把属性和方法封装到一个抽象的类中，

3、封装相当于一个黑盒子，我们将事务相关的属性和方法封装在一个类中，在调用类创建实例，不用关注内部代码的实现细节，我们只要调用结果就可以。

4、封装的优点：
（1）封装数据可以很好的保护隐私、
（2）封装方法主要原因是隔离复杂度
（3）封装提高了代码的复用性
（4）隐藏对象的属性和实现细节，提供公共方法对其访问


5、python中类的封装分为两种：
（1）公用（共用）
类中变量和方法公用，他们名称前没有下滑线，共有的变量和方法，在类的外部，内部以及子类都可以调用
（2）私用 
在类中变量和方法中,___下滑线开头命名，则改变变量或方法为私用，私有的变量和方法，只能在内部使用，类的尾部以及子类都无法使用。
私有属性：格式 ___属性名 =值    在类的外部不能使用（对象不能调用属性）
私有化封装后的限制：
a、类可以访问
b、类外，对象外  不可访问
c子类和子类的对象   不可访问

案例1：数据封装：

class  sjfz():
    def  __init__(self,name,age):
        self .name=name
        self.age=age

案例2：方法封装

class  sjfz(object):
    def  __init__(self,name,age):
        self .name=name #
        self.age=age
    def  getname(self):#方法封装
        print(self.name)

案例3：私有方法

class  Sjfz(object):
    def  __init__(self,name,age):
        self .name=name #
        self.age=age
    def  getname(self):#方法封装
        print(self.name)
    def  __sy(self):
        print(self.age)
    def  sydy(self):
        self.__sy()
if __name__ == '__main__':
    d=Sjfz("ZJ","18")
    d.getname()
    d.sydy()   #d只能调用sydy函数，无法直接调用__sy函数。

案例4：

class  Sjfz(object):
    def  __init__(self,name,age):
        self .__name=name #私有变量
        self.__age=age   #私有变量
    def  setname(self,newname):#方法封装，改变私有变量的值
        self.__name=newname
    def  getname(self):  
        return  self.__name
if __name__ == '__main__':
    d=Sjfz("ZJ","18")
    d.setname("zt")
    print(d.getname())

=====================================
继承：

1、继承：类的继承是面向对象程序设计的一个重要思想，继承时子类可以继承父类的内容，包括成员变量和成员函数。

2、在继承中一个类被另外一个类继承这个类称之为父类也称之为基类，则另外一个类则为子类也称之为派生类

案例1：

class   F(object):
    def  fh(self):
        print("富豪")
class M():
    def  fp(self):
        print("富婆")
class S(F,M):
    def  qg(self):
       print("乞丐")

if __name__ == '__main__':
    s=S()
    s.qg()
    s.fh()
    s.fp()

========================================
多态

1、多态是以继承和重写父类方法为前提，对所有子类实例化产生的对象调用相同的方法，执行产生不同的执行结果。

2、例如同样是人，但是当问起一个人的职业时会有不同的结果，可能是软件测试工程师，可能是HR

3、一个对象的属性和行为不是由他所继承的父类决定的，而是由其本身包含的属性和方法决定的

案例1：

class  A(object):
    def  talk(self):
        print("我是动物")
class  Cat(A):
    def  talk(self):
        print("喵喵")
class  Dog(A):
    def talk(self):
        print("汪汪")
if __name__ == '__main__':
    c=Cat()
    c.talk()  #喵喵
    d=Dog()
    d.talk()  #汪汪
====================
案例2：

class  Cc(object):
    def cs(self,x,y):
        print(x+y)
if __name__ == '__main__':
    c=Cc()
    c.cs(1,2) #数值
    c.cs("1","2") #字符
    c.cs(" 杭州","多测师") # 汉字

====================
案例3：

class F(object):#定义一个父类
    def  work(self):
        print("测试")
class   S1(F):#定一个类重写父类方法
    def work(self):
        print("开发")
class   S2(F):#定一个类重写父类方法
    def work(self):
        print("测试开发")
class  p(object):
    def  r_work(self,F):
        F.work()
if __name__ == '__main__':
    f=F()
    f.work()
    s1=S1()
    s1.work()
    s2 = S2()
    s2.work()
    r=p()
    r.r_work(f)
    r.r_work(s1)
    r.r_work(s2)

====================
拓展：
一、

二、装饰器

（1）装饰器定义：

装饰器，本质是一个pyhton函数，他可以让其他函数在不需要做任何代码改动的前提下（增加额外功能），装饰器的返回值也是一个函数对象。

（2）应用场景：

插入日志，性能测试，事务处理，缓存，权限校验等场景

常见的装饰器:

内置装饰器，类装饰器，函数装饰器，带参数的函数装饰器

案例：
class A():
def init(self):

self.name =“wangwang”
self.__myname=“jingjing”
def a(self):
print(“001”)
def __b(self):
print(“002”)
def c(self):
print(“003”)
self.__b()
@property
def age(self):
return self.__myname
if name == ‘main’:
x=A()
print(x.name)

print(x.age)