返回顶部

封装/多态/继承

面向对象

  • 封装思想:将同一类的函数函数封装到同一个py文件中,方便调用

  • 面向对象也有封装的作用,将同一类的函数封装到一个类中

  • 多态(鸭子模型):多种类型/多种形态

    #,什么是鸭子模型
    对于一个函数,python对于参数的类型不会限制,传入参数时就可以是各种类型,但是在函数中如果有类似于索引等特有方法,就会对传入的参数类型有一个限制(类似于字符串的.append.send方法)
    类似于上述的函数我们认为只要能呱呱叫的就是鸭子(只要有.send方法,就是我们要想的类型)
    # Python
    def func(arg):
        v = arg[-1] # arg.append(9)
        print(v)
    
    # java
    def func(str arg):
        v = arg[-1]
        print(v)
    

1.面向对象基本用法

1.1基本格式

class 类名:
    def __init__(self,x):
        self.x = x
    def 方法名字 (self):   #函数在类里称为方法,self就是固定参数,必须写self
        print('方法')
        return 
    def 方法名字 (self):   
        print('方法')
        return 
#实例化一个类的对象
v1 = 类(可以传参)
v2.方法()

1.2调用方法

  1. 创建类的对象(实例化对象)

    obj=类名() #创建了一个Account类的对象

  2. 使用对象调用类的方法

    obj.函数名字()调用时方法是有返回值的,与函数类似

  • 应用场景:
 - 函数(业务功能)比较多,可以使用面向对象来进行归类。
 - 想要做数据封装(创建字典存储数据时,面向对象)。
 - 游戏示例:创建一些角色并且根据角色需要再创建人物。

1.3对象的作用

  • 存储一些值,方便自己使用

    class file:
        def read(self):
            with open(self.xxx, mode='mode='r', encoding='utf-8') as f:
                data = f.read()
            return data
    
        def write(self,content):
            with open(self.xxx, mode='mode='a', encoding='utf-8') as f:
                f.write(content)
    
    # 实例化一个file的对象
    v1 = file()
    # 在对象中写了一个xxx='test.log'
    v1.xxx = 'test.log'
    # 通过对象调用类中的read方法,read方法中的self就v1:
    #v1.read()
    obj1.write('alex')
    

1.4类的初始化方法

  • 类() 实例化对象,自动执行此类中的 __ init __方法。
  • __ init __ 初始化方法(构造方法),为对象内部做初始化
  • 如果有一个反复使用的公共值,课可以放到对象中
class Person:
    def __init__ (self,n,a,g):
        self.name=n
        self.age =a
        self.gender= g
    def show(self):
        temp= '我是%s,今年%s,性别%s'%(self.name,self.age,self.gender)
        print(temp)
# 类() 实例化对象,自动执行此类中的 __init__方法。
p1 = Person('bigox',20,'男')
p1 = show()

2.面向对象的三大特性

2.1封装

class File:
    def read(self):
        pass
    def write(self):
        pass
class Person:
    def __init__(sef,name,age):
        self.name = name
        self.age = age
p = Person('alex',19)

2.2继承

#基本格式
class Base:
    pass
class Foo(Base):
    pass
  • 在多个类中如果有公共的方法,可以使用继承,增加代码的重用性.

  • 继承关系中查找方法的顺序

    • self是谁?
    • self是哪个类创建的,就从此类开始找,自己没有就找父类
  • 多继承就从左往右

    # 父类(基类)
    class Base:
        def f1(self):
            pass
    # 子类(派生类)
    class Foo(Base):
        def f2(self):
            pass
    
    # 创建了一个字类的对象
    obj = Foo()
    # 执行对象.方法时,优先在自己的类中找,如果没有就是父类中找。
    obj.f2()
    obj.f1()
    
    # 创建了一个父类的对象
    obj = Base()
    obj.f1()
    
    

2.3多态

对于一个函数,python对于参数的类型不会限制,传入参数时就可以是各种类型,但是在函数中如果有类似于索引等特有方法,就会对传入的参数类型有一个限制(类似于字符串的.append.send方法)
类似于上述的函数我们认为只要能呱呱叫的就是鸭子(只要有.send方法,就是我们要想的类型)
# Python
def func(arg):
    v = arg[-1] # arg.append(9)
    print(v)

# java
def func(str arg):
    v = arg[-1]
    print(v)

posted @ 2019-04-25 21:28  高薪程序员  阅读(223)  评论(0编辑  收藏  举报