类的应用场景（重要运用补充）

标签：pass   ati   RoCE   调用   技术分享   -o   count   image   函数   

##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

!``

##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() #不需要创建对象直接调用就行

类的应用场景（重要运用补充）

标签：pass   ati   RoCE   调用   技术分享   -o   count   image   函数   

原文地址：http://blog.51cto.com/12992048/2292362