面向对象编程的特性

于 2019-07-29 19:12:15 发布
阅读量123 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/langdei/article/details/97669383
版权 
class Person():
    tax=0.09
    def __init__(self,name,salary):
        self.name=name
        self.salary=salary
    def jiaoshui(self):
        return self.salary*Person.tax
        # return self.salary*p.tax
p=Person("张三",10000)
p.tax=0.08
print(p.jiaoshui())

class Person():
    def __init__(self,name,sex):
        self.name=name
        self.sex=sex
    def show(self):
        print(self.name,self.sex)
p=Person("张三","女")
p.show()
t=Person("李四","男")
t.show()

class A():
    lei_a=0
    lst=[]
    def __init__(self):
        pass
a=A()
a.lei_a=5
print("a.lei_a=%d A.lei_a=%d"%(a.lei_a,A.lei_a))  # a.lei_a=5 A.lei_a=0
delattr(a,"lei_a")
print("a.lei_a=%d A.lei_a=%d"%(a.lei_a,A.lei_a))  # a.lei_a=0 A.lei_a=0
a.lst.append(10)
print("a.lst=%s A.lst=%s"%(a.lst, A.lst))  # a.lst=[10] A.lst=[10]
#A.lst=100
a.lst=100
print("a.lst=%s A.lst=%s"%(a.lst, A.lst))  # a.lst=100 A.lst=[10]
#print("a.lst=%s A.lst=%s"%(a.lst, A.lst))  # a.lst=100 A.lst=[100]

面向对象特性
封装
私有化


class Girl():
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def show(self):
        print(self.name,self.__age)  # 在内部可以访问，只可以在内部使用

zs=Girl("张三",19)
#print(zs.name)
#print(zs.__age)  # 在外部访问报错
zs.show()  # 张三  19


class Girl():
    def __init__(self):
        pass
    def setAge(self,age):
        self.age=age
    def getAge(self):
        return self.age
zs=Girl()
zs.setAge(20)
print(zs.getAge())  # 20
zs.age=-9
print(zs.getAge())  # -9

class Girl():
    def __init__(self):
        pass
    def setAge(self,age):
        if age<0 or age>95:
            print("来自星星的你")
            self.age=0
        else:
            self.age=age
    def getAge(self):
        return self.age
zs=Girl()
zs.setAge(20)
print(zs.getAge())
zs.age=-9  # 解决乱赋值问题
print(zs.getAge())

class Girl():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def setAge(self,age):
        if age<0 or age>95:
            print("火星人")
            self.__age=18
        else:
            self.__age=age
    def getAge(self):
        return self.__age
zs=Girl("张三",20)
zs.setAge(21)  # 内部是私有属性
#print(zs.getAge())
#print(zs.__age)  # 私有变量在外部不能访问
#print(zs.__dict__)  # 查看属性的值
zs.__age=99  # 外部相当于给他加了一个属性,不是私有属性
#print(zs.getAge())
#print(zs.__dict__)
#print(zs.__age)


class A():
    def setAge(self,age):
        self.__age=age
    def __str__(self):
        return str(self.__age)  # 受保护，不被外部访问
a=A()
a.__age=100
print(a.__dict__)  # {'__age': 100}
print(a)


class A():
    def __init__(self,age):
        self.__age=19
    def setAge(self,age):
        self.__age=age
    def __str__(self):
        return str(self.__age)  # 受保护，不被外部访问
a=A(1)
a.__age=100
print(a.__dict__)  # {'_A__age': 19, '__age': 100}
print(a._A__age)  # 19
a._A__age=99
print(a.__dict__)  # {'_A__age': 99, '__age': 100}


class Phone():
    def test(self):
        pass
    def __test1(self):
        print("test1")
x=Phone()
x.test()
#x.__test1()  # 报错

class Phone():
    def __phone(self):  # 私有的封装一些不想往外提供的
        print("正在拨打电话")
    def phone(self,m):
        if m>=30:
            self.__phone()
        else:
            print("请先给你的手机交费30块，再来打电话")
x=Phone()
x.phone(38)

继承

class Cat():
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def jiao(self):
        print("叫")
    def eat(self):
        print("吃")
    def climb(self):
        print("爬树")

class Dog():
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def jiao(self):
        print("叫")
    def eat(self):
        print("吃")
    def swimming(self):
        print("游泳")
d=Dog("藏獒",10,"公")
c=Cat("波斯",3,"母")

class Animal():
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex

    def jiao(self):
        print("叫")

    def eat(self):
        print("吃")

class Cat(Animal):  # 继承父类Animal的一样内容
    def climb(self):  # 在每个子类中定义不同的功能
        print("爬树")

class Dog(Animal):   # 继承父类Animal的一样的内容
    def swimming(self):  # 在每个子类中定义不同的功能
        print("游泳")
d=Dog("藏獒",10,"公")  # 实例化一个变量d,由类制作对象的过程叫实例化,把Dog实例化一个d
#print(d)
c=Cat("波斯",3,"母")
print(c)
d.eat()  # 调用父类的方法
d.jiao()  # 调用父类的方法
d.swimming()  # 有用自己的
c.eat()  # 调用父类的方法
c.jiao()  # 调用父类的方法
c.climb()
#查看继承的父类
print(Cat.__bases__)  # (<class '__main__.Animal'>,)  # 查看某一个类的基类,查看继承的父类
print(Animal.__bases__)  # (<class 'object'>,)  # 默认继承object类

class A():
    def hehe(self):  # 被B覆盖
        print("A:呵呵")  # A:呵呵
class B(A):
    def hehe(self):  # 覆盖A里面的方法
        print("B:呵呵")  # B:呵呵
a=A()
b=B()
a.hehe()
b.hehe()

class Animal():
    def __init__(self,name,age):  # 重载、重写、复写、覆盖
        self.name=name
        self.age=age

class Cat(Animal):
    def __init__(self,name,age,velocity):
        self.v=velocity
        super().__init__(name,age)  # 子类执行父类有的方法
    def jiao(self):
        print("喵喵")
class Dog(Animal):
    def __init__(self,name,age,height):
        self.height=height
        super().__init__(name, age)  # 子类执行父类有的方法
    def jiao(self):
        print("汪汪")
c=Cat("波斯",3,350)  # 要速度  # 先走Cat的init的，再走Animal的
d=Dog("京巴",4,1.78)  # 身高 1.89
c.jiao()
d.jiao()



class A():
    def __init__(self,x,y):
        self.x=x
        self.y=y
class B(A):
    def __init__(self,x,y,z):
        self.z=z
        super().__init__(x,y)
b=B(1,2,3)
print(b.x)  # `

class A():
    num=3
    __num1=2
    def __init__(self,x,y):
        self.x=x
        self.y=y
class B(A):
    def __init__(self,x,y,z):
        self.z=z
        super().__init__(x,y)
b=B(1,2,3)
print(b.num)  # 3
#print(b.__num1)   # 除了本类A中，类外和子类中私有化封装都不可以访问  # 报错



class A():
    num=10
    def __init__(self,x,y):
        self.x=x
        self.y=y
class B(A):
    num=20  # 和父类中有重复的变量就覆盖父类中的
    def __init__(self,x,y,z):
        self.z=z
        super().__init__(x,y)
b=B(1,2,3)
print(b.num)  # 20 # 覆盖了父类中的
print(A.num)  # 10  # 调用父类A中的num
print(B.num)  # 20  # 调用自己类中的num
print(super(B,b).num)  # 10  # 调用父类A的num


class A():
    def t1(self):
        print("A:t1")

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

class C(A,B): # C继承了A,B；就拥有A,B中的所有方法
    def t3(self):
        print("C:t3")
c=C()
c.t1()  # A:t1
c.t2()  # B:t2
c.t3()  # C:t3


class A():
    def t(self):
        print("A:t1")

class B():
    def t(self):
        print("B:t2")

class C(A,B): # C继承了A,B；就拥有A,B中的所有方法
    def t(self):
        print("C:t3")
c=C()
c.t()  # C:t3  # 有自己的用自己的


class A():
    def tx(self):
        print("A:t1")

class B():
    def tx(self):
        print("B:t2")

class C(A,B): # C继承了A,B；就拥有A,B中的所有方法
    def t(self):
        print("C:t3")
c=C()
c.tx()  # A:t1  # (A,B)  优先使用括号里面第一个
c.tx()  # A:t2  # (B,A)  优先使用括号里面第一个，改为（B,A)就成了t2


class A():
    def func(self):
        print("A开始")
        print("A结束")

class B(A):
    def func(self):
        print("B开始")
        super().func()
        print("B结束")

class C(A):
    def func(self):
        print("C开始")
        super().func()
        print("C结束")

class D(B,C):
    def func(self):
        print("D开始")
        super().func()
        print("D结束")
d=D()
d.func()
print(D.mro())   # mro表，广度优先，先广度再A

class A():
    def __init__(self):
        print("A开始")
        print("A结束")
class B(A):
    def __init__(self):
        print("B开始")
        super().__init__()
        print("B结束")
class C(A):
    def __init__(self):
        print("C开始")
        super().__init__()
        print("C结束")
class D(B,C):
    def __init__(self):
        print("D开始")
        super().__init__()
        print("D结束")
d=D()

多态

class Dog():
    def jiao(self):
        print("汪汪")
class Cat():
    def jiao(self):
        print("喵喵")
class Pig():
    def jiao(self):
        print("哼哼")

def honghong(a):  # 根据对象a属性调用对应方法jiao()
    a.jiao()
d=Dog()
c=Cat()
p=Pig()
honghong(d)
honghong(c)
honghong(p)

class Pay():
    def pay(self):
        pass
class Airpay():
    def pay(self,money):
        print("阿里支付",money)
class Wechat():
    def pay(self,money):
        print("微信支付",money)
class Person():
    def consume(self,pay,money):  # 根据支付不同调用pay对应的支付方式
        pay.pay(money)
ali=Airpay()
wx=Wechat()
zs=Person()
zs.consume(ali,100)
zs.consume(wx,200)

class A():
    def __init__(self):
        print("A")
        super().__init__()
class B():
    def __init__(self):
        print("b")
        super().__init__()
class C(A,B):
    def __init__(self):
        print("C")
        super().__init__()
c=C()  # （A，B）是 C  A  b  # (B,A)的话就是 C b A

总结：面向对象特性：封装、继承、多态

class A():
def init(self,name,age):
self.name=name
self.__age=age
a=A(“张三”,19)

print(a.dict) # __dict__查看属性,内部使用私有属性，自动转换成_类名__属性名
{‘name’: ‘张三’, ‘_A__age’: 19}

抽象方法
类方法，静态方法，对象方法（实例方法）

import abc
class Cat(abc,ABCMeta):

class A():
    num=10
    def hehe(self):
        print("我是实例方法（也叫对象方法）")
    @classmethod
    def haha(cls):
        print("我是类方法，我的第一个参数代表的是类，例如此例子是A",cls.num)
    @staticmethod
    def heihei():
        print("我是静态方法，我跟这个类没有太多的血缘关系")
a=A()
a.hehe()  # 对象能访问静态方法，类方法，实例方法
a.haha()  # 知道a属于哪个类,对象（实例）访问了类方法，没出问题，因为我传进去的参数虽然是对象，但是我知道它属于哪个类
a.heihei()
A.hehe(a)  # 用A.hehe()少一个关键字参数，对象，括号里面加上对象a可以。用类名访问对象方法，第一个参数如果传过来对象，是可以运行的。如果考试问：用类名可以访问对象方法吗？答案不能
missing walker
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值