面向对象之封装、继承

一、面向对象

1、创建一个类的基本格式,并调用

class 类名：
     def  __init__(self):  # 必写
         "数据的封装"
     def 方法名（self）:
         "方法体"

#   调用
对象名=类名（参数1，参数2....）
对象名.方法名（）

2、构造函数
类里的__init__方法属于构造函数，其作用是进行数据初始化

应用：

　　(1)将数据分装到对象中，供自己方法调用

 class FileHandler:
     def __init__(self,file_path):
         self.file_path = file_path
         self.f = open(self.file_path, 'rb')
 
      def read_first(self):
            # self.f.read()
          # ...
         pass
 
     def read_last(self):
         # self.f.read()
         # ...
         pass

     def read_second(self):
         # self.f...
         # ...
         pass
                             
 obj = FileHandler('C:/xx/xx.log')
 obj.read_first()
 obj.read_last()
 obj.read_second()
 obj.f.close()        

 　　(2)、将数据封装到对象中,以供其他函数调用

def new_func(arg):
    arg.k1
    arg.k2
    arg.k6

class Foo:
    def __init__(self,k1,k2,k6):
        self.k1 = k1
        self.k2 = k2
        self.k6 = k6

obj = Foo(111,22,333)
new_func(obj)

3、面向对象代码的编写
方式一：归类+提取公共值

class File:
    def file_read(self,file_path):
        pass

    def file_update(self,file_path):
        pass

    def file_delete(self,file_path):
        pass

    def file_add(self,file_path):
        pass

class Excel:
    def excel_read(self,file_path):
        pass

    def excel_update(self,file_path):
        pass

    def excel_delete(self,file_path):
        pass

    def excel_add(self,file_path):
        pass

提取公共值

class File:
    def __init__(self,file_path):
        self.file_path = file_path
                            
    def file_read(self):
        pass

    def file_update(self):
        pass

    def file_delete(self):
        pass

    def file_add(self):
        pass

class Excel:
    def __init__(self,file_path):
        self.file_path = file_path
                            
    def excel_read(self):
        pass

    def excel_update(self):
        pass

    def excel_delete(self):
        pass

    def excel_add(self):
        pass

 # 将相同的参数封装在构造函数里，每个方法不需要传参

 方法二：在指定的类中编写和当前类相关的所有代码+提取公共值

class Message:
    def email(self):    
    pass 
                
class Person:
    def __init__(self,na, gen, age, fig)
        self.name = na
        self.gender = gen
        self.age = age
        self.fight =fig
                        
        def grassland(self):    
        self.fight = self.fight - 10  
                        
    def practice(self):
        self.fight = self.fight + 90   
                        
    def incest(self):
        self.fight = self.fight - 666
                        
                
cang = Person('刘安', '女', 18, 1000)   
dong = Person('李静', '男', 20, 1800)  
bo = Person('张华', '女', 19, 2500)      
            
dong.grassland()        

二、面向对象的三大特性：分装、继承、多态
1、封装

# 将相关功能封装到一个类中:
class Message:
    def email(self):pass
    def msg(self):pass
    def wechat(self):pass

# 将数据分装到一个对象中：
class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
                        
obj = Person('李静',18,'女')

2、继承，提高代码的重用性
一个子类可以继承多个父类，当调用的方法在子类里没有时，到父类的方法找，如果有则调用

class SuperBase:
    def f3(self):
        print('f3')

class Base(SuperBase):  # 父类,基类
    def f2(self):
        print('f2')

class Foo(Base):        # 子类,派生类
                    
    def f1(self):
        print('f1')
                        
obj = Foo()
obj.f1()
obj.f2()
obj.f3()

 关于继承的查找顺序

练习1

class Base1:
    def f1(self):
        print("base1.1")
    def f2(self):
        print("base1.f2")
    def f3(self):
        print("base1.f3")
class Base2:
    def f1(self):
        print("base2.f1")
class Foo(Base1,Base2):
    def f0(self):
        print("f00.f0")
        self.f3()

练习2

class Base1:
    def f1(self):
        print("base1.1")
    def f2(self):
        print("base1.f2")
    def f3(self):
        print("base1.f3")
class Base2:
    def f1(self):
        print("base2.f1")
class Foo(Base1,Base2):
    def f0(self):
        print("f00.f0")
        self.f3()

obj=Foo()
obj.f0()