day6-面向对象补充之知识点回顾

self关键字

面向对象里面的self是什么？

我们知道面向对象编程就是把函数嵌套了一层类，放在其里面，本质其实就是函数，而self放到了函数的上面，它其实就是个形式参数，而这个形式参数不需要我们给其传值，所以：

实质：self代指的就是调用当前方法的那个对象

class Foo:     
    #静态字段
    #公有属性
    country = "中国"   #只保存一份
 
    def __init__(self,name,count):
        #普通字段
        #普通属性
        self.Name = name
        self.Count = count
 
    def bar(self):
        pass
 
obj1 = Foo("河南"，120000)
obj1.bar

obj2 = Foo("山东"，10000)
obj2.bar

解析：country = “中国”属于公共属性(静态字段),如果属于静态字段，那么类名为Foo里面有__init__方法和bar()方法，还有country = "中国",在创建对象时，如obj1,obj2,每个对象想要找"中国"的话,原理是和找方法的方式一样：先通过类对象指针—>找到类Foo—>类Foo再帮你找它里面的东西，这样的话，country = "中国"这种静态字段(公共属性)只保存一份且保存在类里面。不需要在每个对象里面保存一份了。

 

静态字段的适用场景

以后创建的每个对象中保存相同的值时，可以使用静态字段

封装

类中封装了：字段、方法

对象中封装了：普通字段的值

不仅可以封装字段，还可以封装对象

class F1:
    def __init__(self,n):
        self.N = n
        print("F1")
     
class F2:
    def __init__(self,arg1):
        self.a = arg1
        print("F2")
 
class F3:
     
   def __init__(self,arg2):
        self.b = arg2
        print("F3")
 
o1 = F1("Dick")
o2 = F2(o1)
o3 =F3(o2)
 
######输出Dick####
# o3 =F3(o2)
o3.b = o2  ,o3 ====> o2
 
# o2 = F2(o1)
o3.b.a = o1
 
# o1 = F1("Dick")
o3.b.a.N = "Dick"

继承

原理：子类继承父类，对象调用方法时，先从自己的类中去找，找不到，就会去找父类中的方法。

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): #4
        self.a2() #5
        print("F2a1") #7
 
    def a2(self):
        print("F2a2")
 
class F3(F2): #3
    def __init__(self):
        print("F3")
 
    def a2(self): #6
        print("F3a2")
 
obj = F3() #1
obj.a1() #2
#输出
F3a2
F2a1

解析：先执行#1，然后#2，查找#3中没有a1()，所以在父类里面找，执行了#4里面的#5，此时self(形式参数)是指调用此函数的对象即obj = F3()的F3的对象，所以会重新回到F3对象里面类对应的方法，那么就是#6，执行完再执行#7，结束。

静态方法

1.类的组成

• 字段：1.普通字段(保存在对象中)，2静态字段(保存在类中)
• 方法：普通方法(保存在类中，用对象去调用，至少有self参数)

class F1:
  
    country = "中国" #静态字段

    def __init__(self,name,。。。。。。):
        self.name = name #普通字段
        
 
    def a1(self):   #普通方法
        print(self.name,。。。。。。)

obj = F1("Dick")
obj.a1()
#普通字段
obj.name
#静态字段（推荐使用），当然也可以使用对象来访问静态字段obj.country，但是为了有一个好的代码习惯。
F1.country

解析：当我们执行此代码时，传入一个Dick的参数，同时调用obj.a1()时，那么程序会将封装在对象里面的参数Dick进行输出，在这种情况下，我们已经把Dick这些值封装到对象里了，这时，此对象处于可用状态，但是如果我们把参数去掉，直接在函数里面输出：

class F1:
 
    def a1(self):   #普通方法
        print(“Dick”)

obj = F1() #对象
obj.a1()

这时，在调用obj.a1时，因为对象没有传入任何参数，所以没有在对象里封装任何东西，但是输出了东西，Python知道我们没有给这个对象传入任何参数，此时，Python知道它是一个对象，会给它传一些东西，那么，这个对象还是会占用内存空间，所以，在这种情况下，我们用这个对象访问这个类，白白的创建这个对象。这个时候Pycharm也会提示，因为这里面没有使用对象里面的东西，我们没有封装东西。

在这种情况下，如果你的方法和对象里面的值，没有任何关系的时候，这么去调用，就会白白的浪费内存空间，所以此时我们使用静态方法。

2.静态方法

用法：当对象不需要传入参数时，去创建对象有些浪费，白白浪费内存空间，所以还不如直接用类名直接去调用，这个类似于函数。

特点：1.保存在类中，2.调用者类（不需要创建对象），3.可以有任意个参数（也可以没有）

class F1:
    @staticmethod
    def a1(s1,a2):   #无需传入参数，但是可以声明多个值
        print(“Dick”)

#obj = F1() #创建对象(普通方法)
F1.a1(1,2)  #静态方法（可以不创建对象，直接通过类调用方法，类似函数调用）