引入

如果说函数是解决一个问题，或多个相同的问题，那么类就是解决同一类问题。

在此之前，我们先对类与对象有个基本的了解

类是多个类似的事物组成的群体统称。他是一个抽象的概念

• 分门别类、物以类聚、人类，哺乳类，动物类，植物类。。。

对象是类的实例，例如某人-我,是人类下面的具体实现。

类

Python类的基本组成

• 类属性

• 示例方法

• 静态方法

• 类方法

class Person(objcet):    # 继承object类,object为默认可省略
    native_place = "cs"  # 类属性
    def __init__(self, name: str, age: int) -> None:
        # name，age为类的实例属性
        self.name = name
        self.age = age
                # self为实例而非类
    def info(self):  # 实例方法，在类之外定义的为函数，类之中定义的为实例方法
        print(f"MyName is {self.name}, {self.age} years age")
    @classmethod  # 类方法，最直观的体现就是不需要示例化也可调用
    def cm(cls):
        cls("payne", 20).sm()  # staticMethod
        print("classMethod")
    @staticmethod
    def sm():  # 静态方法
        print("staticMethod")
# 类方法
Person.cm()  # classMethod
print(Person.native_place)  # cs
#实例化
p1 = Person("Payne", 20)
# 访问类中的示例函数
p1.info()

创建类

使用python中关键字,class创建类.例如我们创建一个人这个类。

class Person:
        pass

面向对象技术简介

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

• 方法：类中定义的函数。

• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

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

• 局部变量：定义在方法中的变量，只作用于当前实例的类。

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

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

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

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

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

面向对象的三大特征

封装

封装，就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

# 封装性是面向对象的三大特征之一
# 封装是指隐藏对象中一些不希望被外部所访问到到属性或方法
# 如何隐藏一个对象中到属性？
#   -  将对象中到指定属性，修改为外部“不知道”到名字
#   - __ 双下划线开头的为隐藏属性, Python 内部自动转化为， __name -> _Person__name
# 如何获取（修改）对象中的属性？
#   - 需要提供一个getter / setter 方法使外部可以访问到属性
#   - getter 获取对象中的指定属性（get_属性名）
class Person:
    def __init__(self, name, age):
        self.hidden_name = name
        self.__age = age
    def say_hello(self):
        print("Hello, i am %s, %s years old" % (self.hidden_name, self.__age))
    def get_name(self):
        # 获取对象的name 属性
        return self.hidden_name
    def set_age(self, age):
        if age > 0:
            self.__age = age
p = Person("AA", 10)
p.age = "20"
p.set_age(20)
p.say_hello()
class Person1:
    def __init__(self, name, age):
        self._name = name
        self.__age = age
    def say_hello(self):
        print("Hello, i am %s, %s years old" % (self.hidden_name, self._age))
    # property 装饰器用来将getter方法，转化为对象的属性
    # 添加为property装饰器后，就可以像调用属性一样的方法使用get 方法
    # 使用property 装饰的方法， 必须和属性名一样
    # 调用应为 xxx.name  而不是 xxx.name()
    @property
    def name(self):
        return self._name
    @name.setter
    def name(self, name):
        self._name = name
p1 = Person1("Payne", 10)
# print(p1.name)  # 调用 property 装饰后的方法
p1.name = "aaa"
print(p1.name)  # 调用 方法名

继承

继承，指可以让某个类型的对象获得另一个类型的对象的属性和方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过 “继承”（Inheritance）和“组合”（Composition）来实现。继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力。

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。

通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。

继承语法

class 派生类名(基类名)
    ...

在python中继承中的一些特点：

• 1、如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法，或者不重写父类的构造方法。详细说明可查看：python 子类继承父类构造函数说明。

• 2、在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数

• 3、Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

多态

多态，是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。这意味着，虽然针对不同对象的具体操作不同，但通过一个公共的类，它们（那些操作）可以通过相同的方式予以调用。（比如输入的形参可以不同等去实现同一个方法从而得到不同的表现形式）

如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

语法：

派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示：

class SubClassName (ParentClass1[, ParentClass2, ...]):
    ...

class Parent:        # 定义父类
   parentAttr = 100
   def __init__(self):
      print "调用父类构造函数"
   def parentMethod(self):
      print '调用父类方法'
   def setAttr(self, attr):
      Parent.parentAttr = attr
   def getAttr(self):
      print "父类属性 :", Parent.parentAttr
class Child(Parent): # 定义子类
   def __init__(self):
      print "调用子类构造方法"
   def childMethod(self):
      print '调用子类方法'
c = Child()          # 实例化子类
c.childMethod()      # 调用子类的方法
c.parentMethod()     # 调用父类方法
c.setAttr(200)       # 再次调用父类的方法 - 设置属性值
c.getAttr()          # 再次调用父类的方法 - 获取属性值
# 调用子类构造方法
# 调用子类方法
# 调用父类方法
# 父类属性 : 200

六大基本原则：SPR, OCP, LSP, DIP, ISP,LoD

单一职责原则SRP(Single Responsibility Principle)

是指一个类的功能要单一，不能包罗万象。如同一个人一样，分配的工作不能太多，否则一天到晚虽然忙忙碌碌的，但效率却高不起来。

开放封闭原则OCP(Open－Close Principle)

一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。比如：一个网络模块，原来只服务端功能，而现在要加入客户端功能，那么应当在不用修改服务端功能代码的前提下，就能够增加客户端功能的实现代码，这要求在设计之初，就应当将服务端和客户端分开，公共部分抽象出来。

里式替换原则LSP(the Liskov Substitution Principle LSP)

子类应当可以替换父类并出现在父类能够出现的任何地方。（比如父类public，子类一定是public）比如：公司搞年度晚会，所有员工可以参加抽奖，那么不管是老员工还是新员工，也不管是总部员工还是外派员工，都应当可以参加抽奖，否则这公司就不和谐了。

依赖倒置原则DIP(the Dependency Inversion Principle DIP)

A.高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。

B.抽象不应该依赖于具体实现，具体实现应该依赖于抽象。

具体依赖抽象，上层依赖下层。高层模块就是调用端，底层模块就是具体实现类。（应该让底层模块定义抽象接口并且实现，让高层模块调用抽象接口，而不是直接调用实现类。）

通俗来讲：依赖倒置原则的本质就是通过抽象（接口或抽象类）使各类或模块的实现彼此独立，互不影响，实现模块间的松耦合。

问题描述：类A直接依赖类B，假如要将类A改为依赖类C，则必须通过修改类A的代码来达成。这种场景下，类A一般是高层模块，负责复杂的业务逻辑；类B和类C是低层模块，负责基本的原子操作；假如修改类A，会给程序带来不必要的风险。

解决方案：将类A修改为依赖接口interface，类B和类C各自实现接口interface，类A通过接口interface间接与类B或者类C发生联系，则会大大降低修改类A的几率。（比如A依赖于车的轮胎，速度，牌子等接口，然后让B，C直接实现这些接口的方法，A间接通过接口与BC发生联系。）

好处：依赖倒置的好处在小型项目中很难体现出来。但在大中型项目中可以减少需求变化引起的工作量。使并行开发更友好。

接口分离原则ISP(the Interface Segregation Principle ISP)

模块间要通过抽象接口隔离开，而不是通过具体的类强耦合起来，即面向接口编程。（提供接口，给其他模块调用）

核心思想：类间的依赖关系应该建立在最小的接口上通俗来讲：建立单一接口，不要建立庞大臃肿的接口，尽量细化接口，接口中的方法尽量少。

也就是说，我们要为各个类建立专用的接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。

问题描述：类A通过接口interface依赖类B，类C通过接口interface依赖类D，如果接口interface对于类A和类C来说不是最小接口，则类B和类D必须去实现他们不需要的方法。

需注意：接口尽量小，但是要有限度。对接口进行细化可以提高程序设计灵活性，但是如果过小，则会造成接口数量过多，使设计复杂化。所以一定要适度提高内聚，减少对外交互。使接口用最少的方法去完成最多的事情为依赖接口的类定制服务。只暴露给调用的类它需要的方法，它不需要的方法则隐藏起来。只有专注地为一个模块提供定制服务，才能建立最小的依赖关系。

迪米特法则（Law of Demeter,简称LoD）

核心思想：类间解耦。

通俗来讲：一个类对自己依赖的类知道的越少越好。自从我们接触编程开始，就知道了软件编程的总的原则：低耦合，高内聚。无论是面向过程编程还是面向对象编程，只有使各个模块之间的耦合尽量的低，才能提高代码的复用率。

耦合：

简单地说，软件工程中对象之间的耦合度就是对象之间的依赖性。指导使用和维护对象的主要问题是对象之间的多重依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。

有软硬件之间的耦合，还有软件各模块之间的耦合。

耦合性是程序结构中各个模块之间相互关联的度量。它取决于各个模块之间的接口的复杂程度、调用模块的方式以及哪些信息通过接口。

耦合可以分为以下几种，它们之间的耦合度由高到低排列如下：

• 内容耦合。

当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。

• 公共耦合。

两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。

• 外部耦合。

一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。

• 控制耦合。

一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。

• 标记耦合。

若一个模块A通过接口向两个模块B和C传递一个公共参数，那么称模块B和C之间存在一个标记耦合。

• 数据耦合。

模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。

• 非直接耦合。

两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。

总结

耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。

同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。