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

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()						#通过对象名调用

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