python面向对象设计（初学小总）

川长思鸟来 2022-12-20 12:32 133阅读 0赞

**1. 类的定义和使用**  
1.1 面向对象最基础的概念就是类和对象（就是实例），面向对象设计思想就是把事物的特征和行为包含在类中。  
1.2 定义类就是class 类名，  
实例化为 对象名=类名()，  
1.3 而在类里边创建方法参数需要以**self**为前缀，大概理解为self就是将其创建的对象传入方法，因为类可以创建多个对象，加self就是可以区分运用多个对象。在外部调用对象方法时不需要传递该参数。例如：

Class a:
          def b(self):
                 print("输出")
    aa=a()
    a.b()

（补充）当然self的命名可以随意更改，只不过self命名只是一个习惯。  
1.4 **构造方法**固定名称为\_\_init\_\_(),当创建类的对象时，则系统会**自动调用构造方法**，从而实现对对象进行初始化。例：

class a:
         def__init__(self):
             self.l=1
             self.w=2
         def tangle(self):
             print('长为{}，宽为{}'.format(self.l,self.w)
    aa=a()#无论创多少个对象，l和w属性的初值都是默认值
    a.tangle

当然也有带参构造方法。  
只需加参数，然后在创建对象时传参即可。  
1.5 **析构方法**就是当一个**对象被删除**时，释放类所占的资源时**自动调用**，也可以用del语句删除对象手动调用，固定名称为def\_\_del\_\_(self)  
**2. 类成员和实例成员的区别**  
类成员时在类中所有方法之外定义的数据成员，可以通过类名或对象名访问；实例成员一般定义在构造函数里边，定义和使用必须以self作为前缀，只能通过对象名访问。

**3. 封装**  
封装时面向对象的特征之一，就是把客观事物封装成抽象的类，并规定类中的数据和方法只让可信的或对象操作(书上的话真的有哲理，越读越明白‘小蒙b’）  
封装可分为两个层面:  
1）第一层为，创建类和对象时，分别创建两者的名称，只通过类名或者对象名加“.”的方式访问内部成员和方法  
2）第二层为，类中把某些成员和方法隐藏起来，或者定义为私有，只在类中内部使用，在类的外部无法访问，可以留少量接口供外部访问  
补充（前面的大部分都为第一种封装，下面主要介绍第二种）例子如下：

class A: #定义类
         def__init__(self): 
               self._X=10   #定义私有变量
         def__foo(self):     #定义私有方法
               print('from A')
         def bar(self):      #定义接口函数
               self.__foo()   #类内部访问私有
               return self.__X
    a=A()
    b=a.bar()  #调用接口函数
    print(b)

**4.继承**  
继承学过Java大家应该都有所了解就是事物的从属关系，就是子类继承父类，子类就可以使用父类的属性（公有方法和变量）  
**4.1 单继承**  
意思就是一个子类只有一个父类。  
**4.2 多继承**  
当然就是一个子类有多个父类，就继承多个父类的特性（如果多个父类有相同的方法名，同时调用时，则优先调用参数的第一个）例：  
class s(a,b):表示s继承a和b，若父类中有相同方法名优先调用a  
**4.3 重写父类方法与调用父类方法**  
例：

class Person():
         def__init__(self,name,sex):
              self.name=name
              self.sex=sex
    class Stu(Person):
         def__init__(self,name,sex,score):
              super().__init__(name,sex) #调用父类
              self.score=score
    student=Stu('liming','male',66)
    print("姓名:%s,性别:%s,成绩:%s"%(student.name,student.sex,student.score))

**5.多态**  
就是多个子类继承父类：向不同对象发送同一个消息，不同的对象在接收时会产生不同行为（方法），也即每个对象可以用自己的方式区响应共同的消息（调用函数）

#定义父类
    class Person:
        def __init__(self, name, gender):
            self.name = name
            self.gender = gender
        def who(self):                      #定义who方法
            print('I am a Person, my name is %s' % self.name)
    #定义学生子类
    class Student(Person):
        def __init__(self, name, gender, score):
            super().__init__(name, gender)
            self.score = score
        def who(self):                      #重写父类方法
            print('I am a Student, my name is %s' % self.name)
    #定义教师子类
    class Teacher(Person):
        def __init__(self, name, gender, course):
            super().__init__(name, gender)
            self.course = course
        def who(self):                      #重写父类方法
            print('I am a Teacher, my name is %s' % self.name)
    #定义函数用于接收对象
    def fun(x):
        x.who()                         #调用who方法
    #创建对象
    p = Person('Jack', 'Male')
    s = Student('Tom', 'Male', 88)
    t = Teacher('Lily', 'Female', 'English')
    #调用函数
    fun(p)
    fun(s)
    fun(t)

通过向函数中传入不同对象，who方法输出不同的结果  
**6.类方法和静态方法**  
1）类方法是类所拥有的方法，需要用修饰器“@classmethod”来标识其为类方法，第一参数必须是类对象，一般以cls作为参数（和self一样）例子：

#定义类
    class People:
        country = 'china'					#定义类成员并赋值
    #类方法，用classmethod来进行修饰
        @classmethod
        def getCountry(cls):
            return cls.country				#返回类成员的值
    p = People()							#创建对象
    print(p.getCountry())					#通过实例对象引用
    print(People.getCountry())				#通过类对象引用

用对象名和类名调用类方法的效果一样。  
（类方法可以访问类成员，但无法访问实例成员）  
2）静态方法  
使用静态方法，需在类方法前加上“@staticmethod"标记符以表示下面的成员方法是静态方法，静态方法可以不带任何参数，所有无法访问类的实例成员和类成员。例子：

#定义类
    class Test:
    #静态方法，用@staticmethod进行修饰 
        @staticmethod
        def s_print():
            print('----静态方法----')
    Test.s_print()					#通过类名调用
    t = Test()						#创建对象
    t.s_print()						#通过对象名调用

一般不用静态方法，大部分用于辅助功能，打印菜单。