2020-11-12 类继承、多态和特殊模式

1411-李同学

发表文章数:148

热门标签

首页 » Python » 正文

一、方法没有重载

解释:方法的参数没有类型,参数的数量也可以由可变参数控制。

如果在类体中定义了多个重名的方法,只有最后一个有效

二、方法的动态性

Python是动态语言,可以动态的修改添加的方法

#测试方法的动态性
class Person:
    def work(self):
        print("上班")

def playGame(s):
    print("{0}玩游戏".format(s))


def work2(s):
    print("好好工作,努力上班。")

Person.play=playGame
p=Person()
p.work()

p.play()
#修改了已经定义的方法
Person.work=work2

p.work()
#一切都是对象

三、私有属性

私有属性和方法要点

  • 两个下划线开头的属性是私有的,其他为公共

  • 类内部可以访问私有属性(方法)

  • 类外部不能直接访问私有属性(方法)

  • 类外部可以通过类名访问私有属性

方法本质也是属性,只不过可以通过()执行

#测试私有属性

class Employee:
    def __init__(self,name,age):
        self.name=name
        self.__age=age

e=Employee("james",24)

print(e.name)
#不可以在类外部直接调用私有属性
#print(e.age)
#可以通过类名调用
print(e._Employee__age)

四、私有方法

#测试私有属性

class Employee:

    __company="tencent"
    def __init__(self,name,age):
        self.name=name
        self.__age=age

    def __work(self):
        print("James is good")
        #在内部是可以自己调用私有属性的
        print("年龄:{0}".format(self.__age))
        #内部可以调用
        print(Employee.__company)

e=Employee("james",24)

print(e.name)
#不可以在类外部直接调用私有属性
#print(e.age)
#可以通过类名调用
print(e._Employee__age)

e._Employee__work()

print(e._Employee__company)

五、@property装饰器

作用:将方法的调用变成属性的调用。

#测试@property

class Employee:

    @property
    def salary(self):

        print("salary run")
        return 10000


emp1=Employee()
print(emp1.salary)
#测试@property GET和SET写法

class Employee:


    def __init__(self,name,salary):

        self.__name=name
        self.__salary=salary

    def getSalary(self):

        return self.__salary

    def setSalary(self,salary):

        if 1000< salary <50000:
            self.__salary=salary
        else:
            print("error")



emp1=Employee("james",30000)
print(emp1.getSalary())
emp1.setSalary(40000)
print(emp1.getSalary())
#测试@property调用方法

class Employee:


    def __init__(self,name,salary):

        self.__name=name
        self.__salary=salary

    @property
    def salary(self):

        return self.__salary

    @salary.setter
    def salary(self,salary):
        if 1000<salary<50000:
            self.__salary=salary
        else:
            print("error")





emp1=Employee("james",30000)
emp1.salary=-20000
print(emp1.salary)

六、面向对象的三大特征

封装:隐藏对象的谁能够和实现细节,只对外提供必要的方法

继承:继承可以让子类具有父类的特性,提高了代码的重用性

多态:多态是指一个方法调用由于对象不同会产生不同的行为。

七、继承

概念:继承是实现代码复用的重要手段

  • 父类

  • 子类

语法格式: class 子类类名(父类1,父类2)

#测试继承的基本使用

class Person:
    def __init__(self,name,age):
        self.name=name
        self.__age=age #私有属性无法在子类中调用

    def sayAge(self):
        print("年龄不知道")



class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)  #必须显示的调用父类初始化方法,不然不会调用
        self.score=score


s=Student("lixuan",24,85)
s.sayAge()
print(s.name)
#print(s.age)
print(s._Person__age)

八、方法的重写

概念:

  • 成员继承:子类继承了父类除构造方法外所有的成员

  • 方法重写:子类可以重新定义父类中的方法,这样会覆盖父类的方法,也成为重写。

#重写,在子类中重新定义了Introduce方法
class Person:
    def __init__(self,name,age):
        self.name=name
        self.__age=age #私有属性无法在子类中调用

    def sayAge(self):
        print("我的年龄",self.__age)

    def Introduce(self):
        print("我的名字是{0}".format(self.name))



class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)  #必须显示的调用父类初始化方法,不然不会调用
        self.score=score

    def Introduce(self):
        print("父类被重写了")


s=Student("lixuan",24,85)
s.sayAge()
s.Introduce()

九、object跟类

通过类的方法mro()或者类的属性__mro__可以输出这个类的继承层次结构。

概念:object类是所有类的父类,因此所有的类都有object类的属性和方法。

dir()查看对象和属性

  • 注意:方法也是属性,只不过是method类型

十、重写__str__()方法

作用:返回一个对象的描述

#测试重写__str__()
class Person:   #默认继承object类
    def __init__(self,name):
        self.name=name

    def __str__(self):
        return "名字是:{0}".format(self.name)


p=Person("JAMES")
print(p)

十一、多重继承

Python支持多重继承,一个子类可以有多个直接父类,具备了多个父类的特点。

十二、Mro()

如果父类中有相同名字的方法,在子类没有指定父类名时,解释器将从左到右搜索

mro(method resolution order):方法解析顺序。

#测试mro方法
class A:
    def aa(self):
        print("aa")

    def say(self):
        print("say aa")


class B:
    def bb(self):
        print("bb")

    def say(self):
        print("say bb")

class C(B,A):
    def cc(self):
        print("cc")

c=C()
c.cc()
c.aa()
c.bb()
#B在A之前,所有先执行b
c.say()

print(C.mro())
c.say()

十三、super()获得父类定义

解释:在子类中,用super直接获得父类的方法。

#测试super()方法,代表父类的定义,而不是对象。
class A:

    def say(self):
        print("say aa")


class B(A):


    def say(self):
        #A.say(self)
        super().say()
        print("say bb")


B().say()

十四、多态

概念:指同一个方法调用由于对象不同可能会产生不同行为

  • 多态是方法的多态,属性没有多态

  • 多态的存在有两个必要条件:继承、方法重写。

#多态

class Man:
    def eat(self):
        print("吃饭了")

class Chinese(Man):

    def eat(self):
        print("中国人用筷子吃饭")


class English(Man):

    def eat(self):
        print("英国人用叉子吃饭")


class Indian(Man):

    def eat(self):
        print("印度人用右手吃饭")

class Japanese:

    def eat(self):
        print("印度人用右手吃饭")

def manEat(m):
    if isinstance(m,Man):
        m.eat()

    else:
        print("不会吃饭")

manEat(Chinese())
manEat(English())
manEat(Indian())
manEat(Japanese())

十五、特殊方法和运算符重载

2020-11-12 类继承、多态和特殊模式
2020-11-12 类继承、多态和特殊模式

#测试运算符的重载

class Person:
    def __init__(self,name):
        self.name=name

    def __add__(self,other):
         if isinstance(other,Person):
             return"{0}--{1}".format(self.name,other.name)
         else:
             return "不是同类对象不能相加"

    def __mul__(self, other):
        if isinstance(other, int):
            return self.name*other
        else:
            return "不是同类对象不能相乘"

p1=Person("lixuan")
p2=Person("james")

x=p1+p2
print(x)
print(p1*30)

十六、特殊属性

obj或class输入类或者对象
2020-11-12 类继承、多态和特殊模式

十七、对象的浅拷贝和深拷贝

变量的赋值操作:只能形成两个变量,实际上还是指向同一个对象

  • 浅拷贝:对象包含的子对象内容不拷贝。因此,源对象和拷贝对象会引用同一个子对象

  • 深拷贝:递归拷贝对象中包含的子对象,源对象和拷贝对象的队友的子对象也不同。

import copy

# 测试对象的浅拷贝、深拷贝


class MobilePhone:
    def __init__(self,cpu,screen):
        self.cpu=cpu
        self.screen=screen


class CPU:
    def calculate(self):
        print("算12345")
        print("cpu:",self)

class Screen:
    def show(self):
        print("显示中")
        print("screen对象:",self)

#测试变量的赋值
'''m1=MobilePhone()
m2=m1
print(m1)
print(m2)
'''
#测试浅复制
c1=CPU()
s1=Screen()
m1=MobilePhone(c1,s1)
m2=copy.copy(m1)
#手机变了里面的没改变
print(m1,m1.cpu,m1.screen)
print(m2,m2.cpu,m2.screen)


#不仅手机对象不一样,子对象也会重新复制一遍
#测试深复制
m3=copy.deepcopy(m1)
print(m1,m1.cpu,m1.screen)
print(m3,m3.cpu,m3.screen)

十八、组合

is-a关系可以使用继承

has-a 关系 可以使用组合

#测试组合

class A1:
    def sayA1(self):
        print("a1,a1,a1")

class B1(A1):
    pass



b1=B1()
b1.sayA1()

#组合

class A2:
    def sayA2(self):
        print("a2,a2,a2")
class B2:
    def __init__(self,a):
        self.a=a

a2=A2()
b2=B2(a2)
b2.a.sayA2()
#将a2这个对象作为B2中的参数,就可以实现以b这个对象去执行A2类中的函数

十九、设计模式_工厂模式实现

设计模式是面向对象语言特有的内容,GOF23种设计模式

  • 工厂模式

  • 单例模式

工厂模式实现了创建者和调用者的分离,使用专门的工厂类将选择实现类、创建对象进行统一的管制和控制。

#测试工厂模式

class CarFactory:
    def createCar(self,brand):
        if brand=="奔驰":
            return Benz()

        elif brand=="宝马":
            return BMW()
        elif brand=="比亚迪":
            return BYD()

        else:
            return "未知品牌无法创建"


class Benz:
    pass

class BMW:
    pass

class BYD:
    pass


factory=CarFactory()
car1=factory.createCar("奔驰")
car2=factory.createCar("比亚迪")
car3=factory.createCar("东风")
print(car1)
print(car2)
print(car3)

二十、设计模式_单例模式实现

单例模式的核心作用是确保一个类只有一个实例,并且提供一个访问该实例的全局访问点。

单例模式只产生一个实例对象,减少了对系统资源的开销。当一个对象的产生需要比较多的资源,如读取配置文件、产生其他依赖对象时。可以使用单例模式。

#测试单例模式

class MySingleton:

    __obj=None  #类属性

    __init_flag=True

    def __new__(cls, *args, **kwargs):
        if cls.__obj==None:
            cls.__obj=object.__new__(cls) #调用object类创建单例对象

        return cls.__obj

    def __init__(self,name):

        if MySingleton.__init_flag:

            print("init.....")
            self.name=name
            MySingleton.__init_flag=False

#a和b目前是一个对象,初始化的方法被调用了两次,将__init_flag改变为false,初始化操作就只会进行一次。
a=MySingleton("aa")
b=MySingleton("bb")
print(a)
print(b)
#测试单例模式和工厂模式的整合
class CarFactory:
    __obj = None  # 类属性

    __init_flag = True

    def createCar(self,brand):
        if brand=="奔驰":
            return Benz()

        elif brand=="宝马":
            return BMW()
        elif brand=="比亚迪":
            return BYD()

        else:
            return "未知品牌无法创建"


    def __new__(cls, *args, **kwargs):
        if cls.__obj==None:
            cls.__obj=object.__new__(cls) #调用object类创建单例对象

        return cls.__obj

    def __init__(self):

        if CarFactory.__init_flag:

            print("init CarFactory.....")

            CarFactory.__init_flag=False


class Benz:
    pass

class BMW:
    pass

class BYD:
    pass

factory=CarFactory()
car1=factory.createCar("奔驰")
car2=factory.createCar("比亚迪")
car3=factory.createCar("东风")
print(car1)
print(car2)
print(car3)

factory2=CarFactory()
print(factory2)
print(factory)
标签:

拜师教育学员文章:作者:1411-李同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《2020-11-12 类继承、多态和特殊模式》 发布于2020-11-12

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录