类的应用场景（重要运用补充）类的组合继承-创新互联

```#
##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
![](https://cache.yisu.com/upload/information/20200310/57/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) #类的继承组合调用

另外有需要云服务器可以了解下创新互联scvps.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。

公司主营业务：成都网站设计、做网站、移动网站开发等业务。帮助企业客户真正实现互联网宣传，提高企业的竞争能力。创新互联是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化，感谢他们对我们的高要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。创新互联推出曾都免费做网站回馈大家。
名称栏目：类的应用场景（重要运用补充）类的组合继承-创新互联
文章网址：http://mswzjz.cn/article/diiiog.html