```#
##1、什么是面向对象编程？
    以前是用函数
        现在是类+对象

##2、什么是类，什么是对象，他们又有什么关系？
    把函数放进类里
        class 类：
             def  foo(self):
                         pass
                    def  too(self):
                         pass
        obj是对象，是实例化后就得到一个对象（实例）                      
    obj=类()
        obj.foo()

##3、什么时候适合用面向对象？
1、根据一个模板创建东西的时候（cs里人的模板创建警察和劫匪）
2、多个函数传入多个相同参数或者多个函数里有相同操作时

##4、self就是调用当前方法的对象
     #公有属性应用场景：每个对象中保存相同的东西时，可以使用公有属性
         class foo:
                    #静态字段
                        #公有属性
                        countey=“中国” #创建的每一个对象都有共同的值，就能设置成公有属性
                        def __init__(self,city,count):
                            #普通字段
                                #普通属性（在每个对象都保存着自己的那一份）
                             self.city=city
                                 self.count=count
                        des bar(self):
                              pass

                        obj1=foo("上海",200000)
                        obj1.bar()

                        obj2=foo("苏州",1000000)
                        obj2.bar()

##5、什么是封装？
     类中封装了：字段、方法
         对象中封装了：普通字段的值

         class f1:
             def  __init__(self,a):
                 self.a=a
                 print("f1")

         class f2:
             def  __init__(self,arge1):
                 self.b=arge
                 print("f2")

         class f3:
             def  __init__(self,arge2):
                 self.c=arge2
                 print("f3")

    o1=f1("alex")
    02=f2(o1)
    o3=f3(o2)
    想输出“alex”
#o3=f3(o2)
   o3.c==>02

#o2=f(o1)
  o3.c=f(o1)
  o2.b==>o1

    o1=f1("alex")
    o3.c.b.a

##继承

 class f1:
             def  __init__(self):
                    print("f1")
                 def a1(self):
                    print("f1a1")
                    def a2(self):
                    print("f1a2")

 class f2(f1):
             def  __init__(self):
                    print("f2")
                 def a1(self):
                     self.a2()
                    print("f2a1")
                    def a2(self):
                    print("f2a2")

    class f3(f2):
             def  __init__(self):
                    print("f3")
                 def a1(self):
                    print("f3a1")
         def a2(self):
                    print("f3a2")

            obj=f3()
            obj.a1()
            #输出   f3a2 
                        f2a1
            obj传进去，self.a2=obj.a2=f3.a2
![](/upload/otherpic57/120670.jpg)!

##6、静态方法
      字段：普通字段(保存在对象中)
                       静态字段（保存在类中）

            方法：普通方法（保存在类中，调用者是对象，至少有一个self参数）
            calss fff:
                   def  __init__(self,name)
                            self.name=name
                        def a1(self):
                             print(self.name)

                    obj=fff()
                    obj.a1()  #值已经保存在对象中了，对象有用。

            ##当你的方法和对象里的值没有任何关系时这样调用浪费空间 
            calss fff:
                        def a1(self):
                             print(“alex”)

                    obj=fff()
                    obj.a1() 

            ##此时应用静态方法
            静态方法（保存在类中，调用者是类，可以有任意个参数）:
                             calss fff:
                                  @staticmethod
                                      def a1(): #self不是必须的了
                                           print(“alex”)

                                fff.a1() #不需要创建对象直接调用就行

## 类的继承中有（继承，组合2种方式）
class School(object):
    """"学校成员基类"""
    number=0
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
        self.enroll() #在基类里内部调用（相当于子类默认调用）

    def enroll(self):
        """注册"""
        print("%s欢迎加入我们学院！"%self.name)
        School.number+=1 #把值赋给公有属性(变成全局的)直接self.number只是在实例里面创建了一个变量number=0然后加1
    def tell(self):
        """打印自己的信息"""
        print("------info:%s-------"%self.name)
        for k,v in self.__dict__.items():
            print("\t",k,v)
        print("------end-------" )

    #def __del__(self):  # 析构
        print("[%s] 被开除了！"%self.name)
        School.number-=1

class newschool(object):
    def openschool(self,addr):
        print("open in the %s"%addr)

class Teacher(School,newschool): # 多继承（继承多个类）
    """讲师类"""
    def __init__(self,name,age,sex,salary,course):
        #School.__init__(self,name,age,sex) #经典类
        super(Teacher,self).__init__(name,age,sex) # 新式类
        self.salary=salary
        self.coures=course

    def teaching(self):
        print("Teacher [%s] is teaching [%s]"%(self.name,self.coures))

class Student(School):
    """学生类"""
    def __init__(self,name,age,sex,course,fee,ttt):
        # School.__init__(self,name,sex,age)
        super(Student,self).__init__(name,age,sex)
        self.Teacher=ttt #类的继承组合继承模式
        self.course=course
        self.fee=fee
        self.amount=0

    def pay_fee(self,amount):
        print("student [%s] has just paid [%s]"%(self.name,self.amount))
        self.amount+=amount
#t=Teacher()
t1=Teacher("王肖",29,'F*M',20000,"Python")
s1=Student("王鼎",26,"N/A",'Python',30000,t1)
s2=Student("苏晓",22,"F","Python",5000,t1)
print(s1.Teacher.salary) #类的继承组合调用

名称栏目：类的应用场景（重要运用补充）类的组合继承
标题链接：http://azwzsj.com/article/ghhcij.html